@byok-sdk/protocol 0.30.1 → 0.31.0

package/dist/messages.d.ts

@@ -151,13 +151,6 @@ export declare const ConnHelloPayloadSchema: z.ZodObject<{
     cursor: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type ConnHelloPayload = z.infer<typeof ConnHelloPayloadSchema>;
-/** server -> daemon: handshake acknowledgement. */
-export declare const ConnAckPayloadSchema: z.ZodObject<{
-    protocolVersion: z.ZodNumber;
-    capabilities: z.ZodArray<z.ZodString>;
-    serverTime: z.ZodISODateTime;
-}, z.core.$strip>;
-export type ConnAckPayload = z.infer<typeof ConnAckPayloadSchema>;
 /**
  * The web-selected runtime/model target carried end to end with a task.
  *
@@ -192,128 +185,8 @@ export declare const DispatchSelectionSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     }, z.core.$strict>;
 }, z.core.$strict>], "lane">;
 export type DispatchSelection = z.infer<typeof DispatchSelectionSchema>;
-/**
- * server -> daemon: offer a task for a device to claim.
- *
- * `taskId` used to be duplicated here; it is now carried only by the
- * envelope's `task_id` (M1 gap #7 — single source of truth for routing).
- */
-export declare const TaskOfferPayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
-    sealing: z.ZodOptional<z.ZodNever>;
-    instruction: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        blobRef: z.ZodObject<{
-            blobId: z.ZodString;
-            contentHash: z.ZodString;
-            size: z.ZodNumber;
-            contentType: z.ZodString;
-            url: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strict>]>;
-    runtime: z.ZodOptional<z.ZodEnum<{
-        claude: "claude";
-        codex: "codex";
-        pi: "pi";
-    }>>;
-    harnessId: z.ZodOptional<z.ZodString>;
-    dispatchSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        lane: z.ZodLiteral<"subscription">;
-        runtimeId: z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-        }>;
-        providerId: z.ZodNull;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerId: z.ZodString;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok-profile">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerProfile: z.ZodObject<{
-            profileRef: z.ZodString;
-            profileRevision: z.ZodString;
-            profileHash: z.ZodString;
-            modelId: z.ZodString;
-            requiredCapabilities: z.ZodArray<z.ZodEnum<{
-                "image-input": "image-input";
-            }>>;
-        }, z.core.$strict>;
-    }, z.core.$strict>], "lane">>;
-    sessionRef: z.ZodOptional<z.ZodString>;
-    workspaceHint: z.ZodOptional<z.ZodString>;
-    limits: z.ZodOptional<z.ZodObject<{
-        maxDurationMs: z.ZodOptional<z.ZodNumber>;
-        maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type TaskOfferPayload = z.infer<typeof TaskOfferPayloadSchema>;
 /** Every named toolset is required; duplicates are rejected instead of silently de-duplicated. */
 export declare const RequiredToolsetsSchema: z.ZodArray<z.ZodString>;
-/**
- * Additive v1 offer variant for tasks whose semantics require local MCP
- * tools. This is a distinct message type rather than an optional field on
- * `task.offer`, so an older daemon can never strip an unknown optional control
- * field and run the task without its required tools. An unknown type is not
- * silently skipped either: on long-poll it freezes the cursor, so the enqueue
- * capability gate is the real compatibility boundary. The whole payload is
- * strict because every field here affects execution authority.
- */
-export declare const TaskOfferWithToolsetsPayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
-    sealing: z.ZodOptional<z.ZodNever>;
-    instruction: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        blobRef: z.ZodObject<{
-            blobId: z.ZodString;
-            contentHash: z.ZodString;
-            size: z.ZodNumber;
-            contentType: z.ZodString;
-            url: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strict>]>;
-    runtime: z.ZodOptional<z.ZodEnum<{
-        claude: "claude";
-        codex: "codex";
-        pi: "pi";
-    }>>;
-    harnessId: z.ZodOptional<z.ZodString>;
-    dispatchSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        lane: z.ZodLiteral<"subscription">;
-        runtimeId: z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-        }>;
-        providerId: z.ZodNull;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerId: z.ZodString;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok-profile">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerProfile: z.ZodObject<{
-            profileRef: z.ZodString;
-            profileRevision: z.ZodString;
-            profileHash: z.ZodString;
-            modelId: z.ZodString;
-            requiredCapabilities: z.ZodArray<z.ZodEnum<{
-                "image-input": "image-input";
-            }>>;
-        }, z.core.$strict>;
-    }, z.core.$strict>], "lane">>;
-    sessionRef: z.ZodOptional<z.ZodString>;
-    workspaceHint: z.ZodOptional<z.ZodString>;
-    limits: z.ZodOptional<z.ZodObject<{
-        maxDurationMs: z.ZodOptional<z.ZodNumber>;
-        maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    requiredToolsets: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type TaskOfferWithToolsetsPayload = z.infer<typeof TaskOfferWithToolsetsPayloadSchema>;
 /**
  * How an Agent Attempt uses its Agent home. `memory-reader` runs the Attempt
  * in its own run directory, `<home>/.byok/runs/<taskId>/`, beside other
@@ -345,32 +218,36 @@ export declare const AgentMemorySelectionSchema: z.ZodEnum<{
 }>;
 export type AgentMemorySelection = z.infer<typeof AgentMemorySelectionSchema>;
 /**
- * Strict additive offer for a durable host-owned Agent. An older daemon that
- * does not advertise `agent-home-contract` skips this distinct message type
- * instead of stripping identity and applying legacy workspace semantics.
- *
- * `agentMemory` selects the Agent memory of this one task (see
- * {@link AgentMemorySelectionSchema}). Absent keeps the daemon admission. A
- * host sends it only to a device that advertises `agent-memory-selection`. The
- * prepared offer replaces it with its own required selection.
+ * How a `task.offer` starts its runtime session. `resume` continues the named
+ * session; `fresh` lets the selected runtime mint one after start. It is
+ * required, so an offer without a resume reference is never read as fresh.
  */
-export declare const TaskOfferForAgentPayloadSchema: z.ZodObject<{
+export declare const SessionSelectionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"resume">;
+    sessionRef: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    mode: z.ZodLiteral<"fresh">;
+}, z.core.$strict>], "mode">;
+export type SessionSelection = z.infer<typeof SessionSelectionSchema>;
+/** server -> daemon: a `task.offer` of a task that is not sealed. */
+export declare const TaskOfferPlainPayloadSchema: z.ZodObject<{
     sealed: z.ZodOptional<z.ZodNever>;
     sealing: z.ZodOptional<z.ZodNever>;
-    instruction: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        blobRef: z.ZodObject<{
-            blobId: z.ZodString;
-            contentHash: z.ZodString;
-            size: z.ZodNumber;
-            contentType: z.ZodString;
-            url: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strict>]>;
     agentRef: z.ZodObject<{
         agentId: z.ZodString;
         profileRevision: z.ZodString;
     }, z.core.$strict>;
-    homeAccess: z.ZodOptional<z.ZodLiteral<"memory-reader">>;
+    session: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"resume">;
+        sessionRef: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"fresh">;
+    }, z.core.$strict>], "mode">;
+    preparation: z.ZodOptional<z.ZodObject<{
+        reference: z.ZodString;
+        requestDigest: z.ZodString;
+        artifactDigest: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     agentMemory: z.ZodOptional<z.ZodEnum<{
         none: "none";
         read: "read";
@@ -378,6 +255,7 @@ export declare const TaskOfferForAgentPayloadSchema: z.ZodObject<{
         "read-write": "read-write";
         "read-write-if-admitted": "read-write-if-admitted";
     }>>;
+    homeAccess: z.ZodOptional<z.ZodLiteral<"memory-reader">>;
     requiredToolsets: z.ZodOptional<z.ZodArray<z.ZodString>>;
     runtime: z.ZodOptional<z.ZodEnum<{
         claude: "claude";
@@ -418,22 +296,48 @@ export declare const TaskOfferForAgentPayloadSchema: z.ZodObject<{
         contract: z.ZodString;
         schema: z.ZodCustom<import("./result-schema").ResultSchema, import("./result-schema").ResultSchema>;
     }, z.core.$strict>], "mode">>;
-    sessionRef: z.ZodOptional<z.ZodString>;
     limits: z.ZodOptional<z.ZodObject<{
         maxDurationMs: z.ZodOptional<z.ZodNumber>;
         maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strict>;
-export type TaskOfferForAgentPayload = z.infer<typeof TaskOfferForAgentPayloadSchema>;
-/**
- * Strict Agent offer which consumes the typed egress policy. It is a distinct
- * message so an older Agent-home daemon cannot strip control data and proceed
- * with an unconsumed egress declaration.
- */
-export declare const TaskOfferForAgentWithEgressPayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
-    sealing: z.ZodOptional<z.ZodNever>;
-    instruction: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    }, z.core.$strict>>;
+    egressPolicy: z.ZodOptional<z.ZodObject<{
+        policyRevision: z.ZodString;
+        activity: z.ZodObject<{
+            delivery: z.ZodLiteral<"latest-value">;
+            maxCoalesceMs: z.ZodNumber;
+            maxEventBytes: z.ZodNumber;
+        }, z.core.$strict>;
+        reliable: z.ZodObject<{
+            maxPendingEventsPerAgent: z.ZodNumber;
+            maxPendingBytesPerAgent: z.ZodNumber;
+            maxPendingBytesPerTenant: z.ZodNumber;
+        }, z.core.$strict>;
+        transfers: z.ZodObject<{
+            workspace: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                maxBytes: z.ZodNumber;
+                allowedMimeTypes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>;
+            transcript: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                maxBytes: z.ZodNumber;
+                allowedMimeTypes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>;
+            artifact: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
+                maxBytes: z.ZodNumber;
+                allowedMimeTypes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    messageEgress: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodLiteral<"required">;
+        contract: z.ZodString;
+        contentType: z.ZodEnum<{
+            "text/markdown": "text/markdown";
+            "text/plain": "text/plain";
+        }>;
+        maxBytes: z.ZodNumber;
+    }, z.core.$strict>>;
+    routineRef: z.ZodOptional<z.ZodNever>;
+    instruction: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         blobRef: z.ZodObject<{
             blobId: z.ZodString;
             contentHash: z.ZodString;
@@ -441,12 +345,21 @@ export declare const TaskOfferForAgentWithEgressPayloadSchema: z.ZodObject<{
             contentType: z.ZodString;
             url: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
-    }, z.core.$strict>]>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export type TaskOfferPlainPayload = z.infer<typeof TaskOfferPlainPayloadSchema>;
+/** server -> daemon: a `task.offer` of a sealed task. */
+export declare const TaskOfferSealedPayloadSchema: z.ZodObject<{
     agentRef: z.ZodObject<{
         agentId: z.ZodString;
         profileRevision: z.ZodString;
     }, z.core.$strict>;
-    homeAccess: z.ZodOptional<z.ZodLiteral<"memory-reader">>;
+    session: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"resume">;
+        sessionRef: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"fresh">;
+    }, z.core.$strict>], "mode">;
     agentMemory: z.ZodOptional<z.ZodEnum<{
         none: "none";
         read: "read";
@@ -454,6 +367,7 @@ export declare const TaskOfferForAgentWithEgressPayloadSchema: z.ZodObject<{
         "read-write": "read-write";
         "read-write-if-admitted": "read-write-if-admitted";
     }>>;
+    homeAccess: z.ZodOptional<z.ZodLiteral<"memory-reader">>;
     requiredToolsets: z.ZodOptional<z.ZodArray<z.ZodString>>;
     runtime: z.ZodOptional<z.ZodEnum<{
         claude: "claude";
@@ -497,9 +411,8 @@ export declare const TaskOfferForAgentWithEgressPayloadSchema: z.ZodObject<{
     limits: z.ZodOptional<z.ZodObject<{
         maxDurationMs: z.ZodOptional<z.ZodNumber>;
         maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    sessionRef: z.ZodString;
-    egressPolicy: z.ZodObject<{
+    }, z.core.$strict>>;
+    egressPolicy: z.ZodOptional<z.ZodObject<{
         policyRevision: z.ZodString;
         activity: z.ZodObject<{
             delivery: z.ZodLiteral<"latest-value">;
@@ -525,7 +438,7 @@ export declare const TaskOfferForAgentWithEgressPayloadSchema: z.ZodObject<{
                 allowedMimeTypes: z.ZodArray<z.ZodString>;
             }, z.core.$strict>]>;
         }, z.core.$strict>;
-    }, z.core.$strict>;
+    }, z.core.$strict>>;
     messageEgress: z.ZodOptional<z.ZodObject<{
         mode: z.ZodLiteral<"required">;
         contract: z.ZodString;
@@ -535,18 +448,7 @@ export declare const TaskOfferForAgentWithEgressPayloadSchema: z.ZodObject<{
         }>;
         maxBytes: z.ZodNumber;
     }, z.core.$strict>>;
-}, z.core.$strict>;
-export type TaskOfferForAgentWithEgressPayload = z.infer<typeof TaskOfferForAgentWithEgressPayloadSchema>;
-/**
- * Strict fresh-session Agent egress offer. It deliberately omits `sessionRef`:
- * the selected runtime is the sole authority that can mint that identity after
- * start. This distinct message prevents a missing resume reference from being
- * interpreted as a fresh execution by an older daemon.
- */
-export declare const TaskOfferForAgentWithEgressFreshPayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
-    sealing: z.ZodOptional<z.ZodNever>;
-    instruction: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    instruction: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         blobRef: z.ZodObject<{
             blobId: z.ZodString;
             contentHash: z.ZodString;
@@ -554,12 +456,74 @@ export declare const TaskOfferForAgentWithEgressFreshPayloadSchema: z.ZodObject<
             contentType: z.ZodString;
             url: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
-    }, z.core.$strict>]>;
+    }, z.core.$strict>]>>;
+    sealing: z.ZodObject<{
+        scopeId: z.ZodString;
+        epoch: z.ZodNumber;
+        categories: z.ZodArray<z.ZodEnum<{
+            "task-input": "task-input";
+            "task-output": "task-output";
+        }>>;
+    }, z.core.$strict>;
+    sealed: z.ZodOptional<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
+        category: z.ZodLiteral<"task-input">;
+        scope: z.ZodObject<{
+            id: z.ZodString;
+            epoch: z.ZodNumber;
+            keyId: z.ZodString;
+        }, z.core.$strict>;
+        chainHead: z.ZodObject<{
+            seq: z.ZodNumber;
+            hash: z.ZodString;
+        }, z.core.$strict>;
+        sender: z.ZodString;
+        salt: z.ZodString;
+        nonce: z.ZodString;
+        paddedLength: z.ZodNumber;
+        contentMac: z.ZodString;
+        ciphertext: z.ZodOptional<z.ZodString>;
+        ciphertextRef: z.ZodOptional<z.ZodObject<{
+            blobId: z.ZodString;
+            contentHash: z.ZodString;
+            size: z.ZodNumber;
+            contentType: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    routineRef: z.ZodOptional<z.ZodObject<{
+        routineId: z.ZodString;
+        definitionVersion: z.ZodNumber;
+        notAfter: z.ZodString;
+    }, z.core.$strict>>;
+    preparation: z.ZodOptional<z.ZodNever>;
+}, z.core.$strict>;
+export type TaskOfferSealedPayload = z.infer<typeof TaskOfferSealedPayloadSchema>;
+/**
+ * server -> daemon: the one task-opening offer. Both branches are strict, so a
+ * field this decoder does not know stops the daemon's cursor (the long-poll
+ * treats it like an unknown type) instead of being stripped. The plaintext
+ * branch comes first and refuses `sealing`, so a sealed offer always takes the
+ * sealed branch; narrow with `payload.sealing !== undefined`.
+ */
+export declare const TaskOfferPayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
+    sealed: z.ZodOptional<z.ZodNever>;
+    sealing: z.ZodOptional<z.ZodNever>;
     agentRef: z.ZodObject<{
         agentId: z.ZodString;
         profileRevision: z.ZodString;
     }, z.core.$strict>;
-    homeAccess: z.ZodOptional<z.ZodLiteral<"memory-reader">>;
+    session: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"resume">;
+        sessionRef: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"fresh">;
+    }, z.core.$strict>], "mode">;
+    preparation: z.ZodOptional<z.ZodObject<{
+        reference: z.ZodString;
+        requestDigest: z.ZodString;
+        artifactDigest: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     agentMemory: z.ZodOptional<z.ZodEnum<{
         none: "none";
         read: "read";
@@ -567,6 +531,7 @@ export declare const TaskOfferForAgentWithEgressFreshPayloadSchema: z.ZodObject<
         "read-write": "read-write";
         "read-write-if-admitted": "read-write-if-admitted";
     }>>;
+    homeAccess: z.ZodOptional<z.ZodLiteral<"memory-reader">>;
     requiredToolsets: z.ZodOptional<z.ZodArray<z.ZodString>>;
     runtime: z.ZodOptional<z.ZodEnum<{
         claude: "claude";
@@ -610,8 +575,8 @@ export declare const TaskOfferForAgentWithEgressFreshPayloadSchema: z.ZodObject<
     limits: z.ZodOptional<z.ZodObject<{
         maxDurationMs: z.ZodOptional<z.ZodNumber>;
         maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    egressPolicy: z.ZodObject<{
+    }, z.core.$strict>>;
+    egressPolicy: z.ZodOptional<z.ZodObject<{
         policyRevision: z.ZodString;
         activity: z.ZodObject<{
             delivery: z.ZodLiteral<"latest-value">;
@@ -637,7 +602,7 @@ export declare const TaskOfferForAgentWithEgressFreshPayloadSchema: z.ZodObject<
                 allowedMimeTypes: z.ZodArray<z.ZodString>;
             }, z.core.$strict>]>;
         }, z.core.$strict>;
-    }, z.core.$strict>;
+    }, z.core.$strict>>;
     messageEgress: z.ZodOptional<z.ZodObject<{
         mode: z.ZodLiteral<"required">;
         contract: z.ZodString;
@@ -647,39 +612,38 @@ export declare const TaskOfferForAgentWithEgressFreshPayloadSchema: z.ZodObject<
         }>;
         maxBytes: z.ZodNumber;
     }, z.core.$strict>>;
-}, z.core.$strict>;
-export type TaskOfferForAgentWithEgressFreshPayload = z.infer<typeof TaskOfferForAgentWithEgressFreshPayloadSchema>;
-/**
- * Strict offer for an already-counted prepared Execution.
- *
- * A DISTINCT message type, not a `preparation` field added to
- * `task.offer_for_agent`, for the same N/N-1 reason the toolset and egress
- * variants are distinct. On long-poll, both an unknown message type and an
- * unknown key on a strict payload freeze the cursor. The enqueue capability
- * gate is the compatibility boundary: v6 requires a drain and paired upgrade,
- * with no dual token or dual read.
- *
- * It carries no `instruction`: the user request is already inside the frozen
- * envelope the referenced record retained, and an offer that carried both would
- * have two answers to what the runtime is about to send. `sessionRef` is absent
- * for the same structural reason the adapter refuses the pair — a prepared
- * Execution never resumes.
- *
- * Every value under `preparation` is the Host RE-PRESENTING what the device
- * already told it. The device compares each one against its own durable record
- * and declines non-retryably on any difference; nothing here is authority.
- */
-export declare const TaskOfferPreparedPayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
-    sealing: z.ZodOptional<z.ZodNever>;
-    agentRef: z.ZodObject<{
-        agentId: z.ZodString;
-        profileRevision: z.ZodString;
-    }, z.core.$strict>;
-    homeAccess: z.ZodOptional<z.ZodLiteral<"memory-reader">>;
-    requiredToolsets: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    runtime: z.ZodOptional<z.ZodEnum<{
-        claude: "claude";
+    routineRef: z.ZodOptional<z.ZodNever>;
+    instruction: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        blobRef: z.ZodObject<{
+            blobId: z.ZodString;
+            contentHash: z.ZodString;
+            size: z.ZodNumber;
+            contentType: z.ZodString;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>, z.ZodObject<{
+    agentRef: z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
+    }, z.core.$strict>;
+    session: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"resume">;
+        sessionRef: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"fresh">;
+    }, z.core.$strict>], "mode">;
+    agentMemory: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        read: "read";
+        "read-if-admitted": "read-if-admitted";
+        "read-write": "read-write";
+        "read-write-if-admitted": "read-write-if-admitted";
+    }>>;
+    homeAccess: z.ZodOptional<z.ZodLiteral<"memory-reader">>;
+    requiredToolsets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    runtime: z.ZodOptional<z.ZodEnum<{
+        claude: "claude";
         codex: "codex";
         pi: "pi";
     }>>;
@@ -720,18 +684,8 @@ export declare const TaskOfferPreparedPayloadSchema: z.ZodObject<{
     limits: z.ZodOptional<z.ZodObject<{
         maxDurationMs: z.ZodOptional<z.ZodNumber>;
         maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    preparation: z.ZodObject<{
-        reference: z.ZodString;
-        requestDigest: z.ZodString;
-        artifactDigest: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    agentMemory: z.ZodEnum<{
-        none: "none";
-        read: "read";
-        "read-write": "read-write";
-    }>;
-    egressPolicy: z.ZodObject<{
+    }, z.core.$strict>>;
+    egressPolicy: z.ZodOptional<z.ZodObject<{
         policyRevision: z.ZodString;
         activity: z.ZodObject<{
             delivery: z.ZodLiteral<"latest-value">;
@@ -757,7 +711,7 @@ export declare const TaskOfferPreparedPayloadSchema: z.ZodObject<{
                 allowedMimeTypes: z.ZodArray<z.ZodString>;
             }, z.core.$strict>]>;
         }, z.core.$strict>;
-    }, z.core.$strict>;
+    }, z.core.$strict>>;
     messageEgress: z.ZodOptional<z.ZodObject<{
         mode: z.ZodLiteral<"required">;
         contract: z.ZodString;
@@ -767,8 +721,57 @@ export declare const TaskOfferPreparedPayloadSchema: z.ZodObject<{
         }>;
         maxBytes: z.ZodNumber;
     }, z.core.$strict>>;
-}, z.core.$strict>;
-export type TaskOfferPreparedPayload = z.infer<typeof TaskOfferPreparedPayloadSchema>;
+    instruction: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        blobRef: z.ZodObject<{
+            blobId: z.ZodString;
+            contentHash: z.ZodString;
+            size: z.ZodNumber;
+            contentType: z.ZodString;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strict>]>>;
+    sealing: z.ZodObject<{
+        scopeId: z.ZodString;
+        epoch: z.ZodNumber;
+        categories: z.ZodArray<z.ZodEnum<{
+            "task-input": "task-input";
+            "task-output": "task-output";
+        }>>;
+    }, z.core.$strict>;
+    sealed: z.ZodOptional<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
+        category: z.ZodLiteral<"task-input">;
+        scope: z.ZodObject<{
+            id: z.ZodString;
+            epoch: z.ZodNumber;
+            keyId: z.ZodString;
+        }, z.core.$strict>;
+        chainHead: z.ZodObject<{
+            seq: z.ZodNumber;
+            hash: z.ZodString;
+        }, z.core.$strict>;
+        sender: z.ZodString;
+        salt: z.ZodString;
+        nonce: z.ZodString;
+        paddedLength: z.ZodNumber;
+        contentMac: z.ZodString;
+        ciphertext: z.ZodOptional<z.ZodString>;
+        ciphertextRef: z.ZodOptional<z.ZodObject<{
+            blobId: z.ZodString;
+            contentHash: z.ZodString;
+            size: z.ZodNumber;
+            contentType: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    routineRef: z.ZodOptional<z.ZodObject<{
+        routineId: z.ZodString;
+        definitionVersion: z.ZodNumber;
+        notAfter: z.ZodString;
+    }, z.core.$strict>>;
+    preparation: z.ZodOptional<z.ZodNever>;
+}, z.core.$strict>]>;
+export type TaskOfferPayload = z.infer<typeof TaskOfferPayloadSchema>;
 /** Daemon -> cloud: one durable reliable-lane item, forwarded as the Agent produced it. */
 export declare const AgentEgressReliablePayloadSchema: z.ZodObject<{
     agentRef: z.ZodObject<{
@@ -1032,7 +1035,7 @@ export type AgentMemoryIntentAvailablePayload = z.infer<typeof AgentMemoryIntent
  * Server -> daemon: one task-free, exact-device remote input preparation.
  *
  * Distinct message type rather than an optional field on an existing one, for
- * the same N/N-1 reason `task.offer_with_toolsets` is: an optional field could be
+ * the same N/N-1 reason the Agent offers are: an optional field could be
  * legally STRIPPED by a daemon that predates this contract, which would then
  * answer as though a preparation it never performed had somehow been handled.
  * An unknown type (`parseMessage` -> `UnknownMessageTypeError`) is not skipped
@@ -1179,18 +1182,15 @@ export type AgentInputPreparationPayload = z.infer<typeof AgentInputPreparationP
  * `task.fail`/`task.cancelled` if resuming turns out to be impossible) — no
  * new ack message type is introduced. See docs/protocol.md "Approval flow".
  *
- * `approvalId` (M5, additive-minor — docs/protocol.md §5.3): OPTIONAL target
- * identity for the SPECIFIC pending approval this decision resolves, rather
- * than "whichever one is currently pending" (the pre-M5 behavior, and still
- * what happens when this field is absent — a legacy server that never
- * learned an id, or one talking to a legacy daemon). When present, the
- * daemon compares it against its own currently-dispatched approval id
- * (`ActiveTask.pendingApprovalId`, `packages/client`'s `task-runner.ts`) and
- * treats a mismatch as a stale, audit-only no-op instead of resolving
- * whatever happens to be pending right now — see `TaskRunner.handleApprove`.
+ * `approvalId` (required since v4): the SPECIFIC pending approval this
+ * decision resolves. The daemon compares it against its own
+ * currently-dispatched approval id (`ActiveTask.pendingApprovalId`,
+ * `packages/client`'s `task-runner.ts`) and treats a mismatch as a stale,
+ * audit-only no-op, so a late decision never lands on the task's next
+ * approval — see `TaskRunner.handleApprove`.
  */
 export declare const TaskApprovePayloadSchema: z.ZodObject<{
-    approvalId: z.ZodOptional<z.ZodString>;
+    approvalId: z.ZodString;
 }, z.core.$strip>;
 export type TaskApprovePayload = z.infer<typeof TaskApprovePayloadSchema>;
 /**
@@ -1201,13 +1201,13 @@ export type TaskApprovePayload = z.infer<typeof TaskApprovePayloadSchema>;
  * message just tells the daemon to stop, and the daemon reports the outcome
  * via its existing `task.fail` terminal message.
  *
- * `approvalId` (M5, additive-minor — docs/protocol.md §5.3): same optional
- * targeting semantics as `TaskApprovePayloadSchema.approvalId` above, applied
- * to the reject path (`TaskRunner.handleReject`).
+ * `approvalId` (required since v4): same targeting as
+ * `TaskApprovePayloadSchema.approvalId` above, applied to the reject path
+ * (`TaskRunner.handleReject`).
  */
 export declare const TaskRejectPayloadSchema: z.ZodObject<{
     reason: z.ZodOptional<z.ZodString>;
-    approvalId: z.ZodOptional<z.ZodString>;
+    approvalId: z.ZodString;
 }, z.core.$strip>;
 export type TaskRejectPayload = z.infer<typeof TaskRejectPayloadSchema>;
 /**
@@ -1223,13 +1223,23 @@ export declare const TaskCancelPayloadSchema: z.ZodObject<{
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type TaskCancelPayload = z.infer<typeof TaskCancelPayloadSchema>;
-/** server -> daemon: inject steering text into a running task. */
-export declare const TaskSteerPayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
-    sealing: z.ZodOptional<z.ZodNever>;
-    text: z.ZodString;
-}, z.core.$strip>;
-export type TaskSteerPayload = z.infer<typeof TaskSteerPayloadSchema>;
+/** Maximum offer admission duration, and of each phase in it (seven days). */
+export declare const OFFER_ADMISSION_MAX_DURATION_MS = 604800000;
+/**
+ * #1014: how long this device spent admitting an offer, in milliseconds of its
+ * monotonic clock, from receiving the offer to sending the claim or decline
+ * that ends admission. A phase is present only when it ran; the time no phase
+ * names is `totalMs` minus their sum.
+ */
+export declare const OfferAdmissionTimingsSchema: z.ZodObject<{
+    totalMs: z.ZodNumber;
+    agentHomeWaitMs: z.ZodOptional<z.ZodNumber>;
+    messageHelperPreflightMs: z.ZodOptional<z.ZodNumber>;
+    resultHelperPreflightMs: z.ZodOptional<z.ZodNumber>;
+    toolsetProbeMs: z.ZodOptional<z.ZodNumber>;
+    runtimeLaunchMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type OfferAdmissionTimings = z.infer<typeof OfferAdmissionTimingsSchema>;
 /**
  * daemon -> server: claim an offered task (idempotent CAS on the server
  * side). `taskId` used to be duplicated here; it is now carried only by the
@@ -1239,18 +1249,17 @@ export type TaskSteerPayload = z.infer<typeof TaskSteerPayloadSchema>;
  * `task.started`.
  *
  * `runtime` (M5, additive-minor — docs/protocol.md §3.1): the ACTUAL
- * adapter this device selected for the task, distinct from `task.offer`'s
- * own `runtime` (the merely REQUESTED one, `TaskOfferPayloadSchema.runtime`
+ * adapter this device selected for the task, distinct from the offer's
+ * own `runtime` (the merely REQUESTED one, `TaskOfferPayloadSchema`'s `runtime`
  * above). When an offer names no runtime the daemon auto-selects (pi-first —
  * `TaskRunner.pickAdapter`, `packages/client`'s `task-runner.ts`), and before
  * this field existed the server had no way to learn which adapter actually
  * ran — `TaskSnapshot.runtime` (`packages/server`'s `types.ts`) only ever
  * recorded what was requested. Plain optional property on this already-
  * tolerant `z.object()`: an old server simply never reads it, so this needed
- * no version bump and no emission gating (same shape as `approvalId` on
- * `task.await_approval`/`task.approve`/`task.reject`, §5.3) — a new daemon
- * sends it unconditionally, regardless of whether the connected server is
- * new enough to store it.
+ * no version bump and no emission gating — a new daemon sends it
+ * unconditionally, regardless of whether the connected server is new enough
+ * to store it.
  *
  * `capabilities` (S0/D-4, additive-minor — docs/protocol.md §2.4): the
  * TASK-level capability authority — what the claiming adapter reported about
@@ -1287,6 +1296,14 @@ export declare const TaskClaimPayloadSchema: z.ZodObject<{
         mcpToolsets: z.ZodOptional<z.ZodBoolean>;
         messageDraft: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    admission: z.ZodOptional<z.ZodObject<{
+        totalMs: z.ZodNumber;
+        agentHomeWaitMs: z.ZodOptional<z.ZodNumber>;
+        messageHelperPreflightMs: z.ZodOptional<z.ZodNumber>;
+        resultHelperPreflightMs: z.ZodOptional<z.ZodNumber>;
+        toolsetProbeMs: z.ZodOptional<z.ZodNumber>;
+        runtimeLaunchMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 export type TaskClaimPayload = z.infer<typeof TaskClaimPayloadSchema>;
 /**
@@ -1296,170 +1313,6 @@ export type TaskClaimPayload = z.infer<typeof TaskClaimPayloadSchema>;
  */
 export declare const TaskStartedPayloadSchema: z.ZodObject<{}, z.core.$strip>;
 export type TaskStartedPayload = z.infer<typeof TaskStartedPayloadSchema>;
-/**
- * #654: a sealed decline code names a fixed, non-retryable outcome and
- * carries no content, so its `reason` is the code itself. A free-text reason
- * or `retryable: true` never goes with it.
- */
-export declare const TaskDeclinePayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
-    sealing: z.ZodOptional<z.ZodNever>;
-    reason: z.ZodString;
-    retryable: z.ZodOptional<z.ZodBoolean>;
-    agentRef: z.ZodOptional<z.ZodObject<{
-        agentId: z.ZodString;
-        profileRevision: z.ZodString;
-    }, z.core.$strict>>;
-    code: z.ZodOptional<z.ZodEnum<{
-        agent_home_reader_busy: "agent_home_reader_busy";
-        agent_home_writer_busy: "agent_home_writer_busy";
-        sealed_content_mac_mismatch: "sealed_content_mac_mismatch";
-        sealed_key_unavailable: "sealed_key_unavailable";
-        sealed_open_failed: "sealed_open_failed";
-        sealing_policy_mismatch: "sealing_policy_mismatch";
-    }>>;
-}, z.core.$strip>;
-export type TaskDeclinePayload = z.infer<typeof TaskDeclinePayloadSchema>;
-/**
- * daemon -> server: batch of normalized agent events.
- *
- * `events` elements are known-or-unknown (`AgentEventOrUnknownSchema` —
- * `agent-event.ts`), not bare `AgentEventSchema`: pre-freeze, an unrecognized
- * event `type` must not fail the whole batch, since a peer running a newer
- * minor version may have emitted an additive event variant this schema
- * doesn't know about yet. See `agent-event.ts` for the full rationale and
- * `partitionAgentEvents`/`isKnownAgentEvent` for how consumers should skip
- * unknowns instead of choking on them.
- */
-export declare const TaskProgressPayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
-    sealing: z.ZodOptional<z.ZodNever>;
-    seq: z.ZodNumber;
-    events: z.ZodArray<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"progress">;
-        text: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"tool_use">;
-        tool: z.ZodString;
-        mcp: z.ZodOptional<z.ZodObject<{
-            server: z.ZodString;
-            tool: z.ZodString;
-        }, z.core.$strict>>;
-        input: z.ZodOptional<z.ZodUnknown>;
-        toolCallId: z.ZodOptional<z.ZodString>;
-        spill: z.ZodOptional<z.ZodObject<{
-            field: z.ZodEnum<{
-                input: "input";
-                output: "output";
-            }>;
-            totalBytes: z.ZodNumber;
-            omittedBytes: z.ZodNumber;
-            contentType: z.ZodLiteral<"application/json">;
-            blob: z.ZodOptional<z.ZodObject<{
-                blobId: z.ZodString;
-                contentHash: z.ZodString;
-                size: z.ZodNumber;
-                contentType: z.ZodString;
-                url: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            unstoredReason: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"tool_result">;
-        tool: z.ZodString;
-        mcp: z.ZodOptional<z.ZodObject<{
-            server: z.ZodString;
-            tool: z.ZodString;
-        }, z.core.$strict>>;
-        output: z.ZodOptional<z.ZodUnknown>;
-        toolCallId: z.ZodOptional<z.ZodString>;
-        isError: z.ZodOptional<z.ZodBoolean>;
-        spill: z.ZodOptional<z.ZodObject<{
-            field: z.ZodEnum<{
-                input: "input";
-                output: "output";
-            }>;
-            totalBytes: z.ZodNumber;
-            omittedBytes: z.ZodNumber;
-            contentType: z.ZodLiteral<"application/json">;
-            blob: z.ZodOptional<z.ZodObject<{
-                blobId: z.ZodString;
-                contentHash: z.ZodString;
-                size: z.ZodNumber;
-                contentType: z.ZodString;
-                url: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            unstoredReason: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"artifact">;
-        name: z.ZodString;
-        contentType: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"needs_approval">;
-        summary: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"turn_end">;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"error">;
-        message: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"usage">;
-        inputTokens: z.ZodOptional<z.ZodNumber>;
-        cachedInputTokens: z.ZodOptional<z.ZodNumber>;
-        outputTokens: z.ZodOptional<z.ZodNumber>;
-        reasoningTokens: z.ZodOptional<z.ZodNumber>;
-        totalTokens: z.ZodOptional<z.ZodNumber>;
-        contextTokens: z.ZodOptional<z.ZodNumber>;
-        contextWindow: z.ZodOptional<z.ZodNumber>;
-        contextSource: z.ZodOptional<z.ZodEnum<{
-            estimate: "estimate";
-            provider: "provider";
-        }>>;
-    }, z.core.$strip>], "type">, z.ZodObject<{
-        type: z.ZodString;
-    }, z.core.$loose>]>>;
-}, z.core.$strip>;
-export type TaskProgressPayload = z.infer<typeof TaskProgressPayloadSchema>;
-/** daemon -> server: an artifact produced by the task, inline or by blob ref. */
-export declare const TaskArtifactPayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
-    sealing: z.ZodOptional<z.ZodNever>;
-    name: z.ZodString;
-    contentType: z.ZodString;
-    inline: z.ZodOptional<z.ZodString>;
-    blobRef: z.ZodOptional<z.ZodObject<{
-        blobId: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        contentType: z.ZodString;
-        url: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type TaskArtifactPayload = z.infer<typeof TaskArtifactPayloadSchema>;
-/**
- * daemon -> server: task is blocked on an out-of-band approval.
- *
- * `approvalId` (M5, additive-minor — docs/protocol.md §5.3): the daemon's own
- * locally-generated identity for THIS SPECIFIC pending approval
- * (`ApprovalRegistry`, `packages/client`'s `approvals.ts`) — included
- * unconditionally by an M5+ daemon, regardless of whether the connected
- * server has advertised the `approval-targeting` capability flag
- * (`version.ts`; see that flag's own doc comment for why no emission gating
- * is needed here — it's a tolerant `z.object()` field, so an older server
- * simply ignores it). Optional purely for wire tolerance with a pre-M5
- * daemon build that never set it at all: a server that never learns an id
- * for a task's current approval can't target a later `approve`/`reject`
- * decision and falls back to resolving "whichever approval is currently
- * pending" — the same behavior every server had before this field existed.
- */
-export declare const TaskAwaitApprovalPayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
-    sealing: z.ZodOptional<z.ZodNever>;
-    summary: z.ZodString;
-    approvalId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type TaskAwaitApprovalPayload = z.infer<typeof TaskAwaitApprovalPayloadSchema>;
 /**
  * Hard cap (1 MiB) on a single `task.complete.document` (see
  * {@link TaskCompletePayloadSchema}), measured as the UTF-8 byte length of
@@ -1544,7 +1397,6 @@ export declare const TERMINAL_INFERENCE_USAGE_MAX_TOKENS = 1000000000;
 /** Maximum device-observed elapsed duration retained in one terminal observation (seven days). */
 export declare const TERMINAL_INFERENCE_USAGE_MAX_DURATION_MS = 604800000;
 export declare const TERMINAL_INFERENCE_USAGE_PROVIDER_MAX_LENGTH = 160;
-export declare const TERMINAL_INFERENCE_USAGE_MODEL_MAX_LENGTH = 160;
 export declare const TERMINAL_INFERENCE_USAGE_CLIENT_VERSION_MAX_LENGTH = 128;
 /**
  * A bounded, non-billing observation associated with one terminal runtime
@@ -1646,45 +1498,126 @@ export declare const TerminalAgentHomeMemoryChangeSchema: z.ZodDiscriminatedUnio
     outcome: z.ZodLiteral<"unmeasured">;
 }, z.core.$strict>], "outcome">;
 export type TerminalAgentHomeMemoryChange = z.infer<typeof TerminalAgentHomeMemoryChangeSchema>;
+/** A closed runtime failure class (#869). `unknown` means the runtime gave no structured evidence. */
+export declare const RuntimeFailureClassSchema: z.ZodEnum<{
+    auth: "auth";
+    billing: "billing";
+    input_too_large: "input_too_large";
+    invalid_request: "invalid_request";
+    limit_reached: "limit_reached";
+    model_unavailable: "model_unavailable";
+    output_schema: "output_schema";
+    overloaded: "overloaded";
+    provider: "provider";
+    quota: "quota";
+    rate_limited: "rate_limited";
+    runtime_exited: "runtime_exited";
+    unknown: "unknown";
+}>;
+export type RuntimeFailureClass = z.infer<typeof RuntimeFailureClassSchema>;
 /**
- * daemon -> server: task finished successfully.
- *
- * `document` (docs/protocol.md §7.2): the OPTIONAL
- * structured terminal result of the task — one JSON value the product on the
- * other side consumes as the task's actual output, as opposed to `summary`
- * (human-readable prose) or `artifactRefs` (files). Deliberately
- * `z.unknown()`: this SDK never understands, validates, or transforms the
- * product's own document schema — that validation belongs to the consumer.
- * The only constraints the wire imposes are the ones
- * {@link checkResultDocument} enforces: it must be PLAIN JSON DATA (equal to
- * its own JSON round trip — see that function for why "stringify succeeded"
- * is not enough), and its canonical JSON UTF-8 encoding must be at most
- * {@link RESULT_DOCUMENT_MAX_BYTES}. An over-cap document is REJECTED here,
- * never truncated (see that constant's own doc comment). A sender puts the
- * check's `canonical` snapshot on the wire, never the original object.
- *
- * Wire v3: every v3 server keeps this field, so no capability flag gates it
- * (the v2 `result-document` flag is gone). For a
- * `terminalProjection.mode: 'result-document'` offer it carries the outcome
- * the daemon validated against the offer's frozen schema
- * (`validateResultOutcome`, `result-schema.ts`, at most
- * `RESULT_OUTCOME_MAX_BYTES`).
+ * The machine-readable failure of a `task.fail` (#869); `reason` stays display
+ * text. `resetsAt` (ISO 8601 UTC) exists only on `quota`, and only when the
+ * runtime reported when the limit resets.
  */
-export declare const TaskCompletePayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
+export declare const TaskFailureSchema: z.ZodUnion<readonly [z.ZodObject<{
+    class: z.ZodLiteral<"quota">;
+    resetsAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>, z.ZodObject<{
+    class: z.ZodEnum<{
+        auth: "auth";
+        billing: "billing";
+        input_too_large: "input_too_large";
+        invalid_request: "invalid_request";
+        limit_reached: "limit_reached";
+        model_unavailable: "model_unavailable";
+        output_schema: "output_schema";
+        overloaded: "overloaded";
+        provider: "provider";
+        rate_limited: "rate_limited";
+        runtime_exited: "runtime_exited";
+        unknown: "unknown";
+    }>;
+}, z.core.$strict>]>;
+export type TaskFailure = z.infer<typeof TaskFailureSchema>;
+/**
+ * daemon -> server: a pending `task.await_approval` was resolved entirely
+ * LOCALLY on the device — the local control-socket `approvals.resolve` RPC,
+ * a fail-closed `requestApproval` timeout, or a fail-closed eviction/finish
+ * rejection (see `packages/client`'s `task-runner.ts`/`approvals.ts`) —
+ * *without* a wire `task.approve`/`task.reject` ever having been exchanged
+ * for it. Baseline since v4: the daemon reports every local resolution, and
+ * this report is the server's only source for one; the server does not infer
+ * a resolution from later task activity.
+ *
+ * Observability-class tolerance applies (not control/security — see the
+ * freeze rule's asymmetry, `docs/protocol.md`): this is a daemon reporting
+ * what it already did locally, not a payload that grants/denies anything on
+ * its own — the receiving server's own state machine (`TASK_TRANSITIONS`,
+ * `task-state.ts`) is still what decides whether the reported resolution is
+ * legal to apply. Plain `z.object()` (not `.strict()`), same as every other
+ * non-control payload in this file.
+ *
+ * `resolvedBy` is a single-value enum (`'local'`) rather than a bare string:
+ * a later wave could add a DISTINCT value as a gated addition, while the
+ * shape stays closed and typed today.
+ */
+export declare const TaskApprovalResolvedPayloadSchema: z.ZodObject<{
+    approvalId: z.ZodString;
+    decision: z.ZodEnum<{
+        approve: "approve";
+        reject: "reject";
+    }>;
+    resolvedBy: z.ZodEnum<{
+        local: "local";
+    }>;
+    at: z.ZodISODateTime;
+}, z.core.$strip>;
+export type TaskApprovalResolvedPayload = z.infer<typeof TaskApprovalResolvedPayloadSchema>;
+/**
+ * server -> daemon: sealed steering text. `steerId` names this steer in the
+ * AAD and the content MAC, so the Host cannot replay an earlier steer of the
+ * same task as a new one.
+ */
+export declare const TaskSteerSealedPayloadSchema: z.ZodObject<{
+    steerId: z.ZodUUID;
+    sealed: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
+        category: z.ZodLiteral<"task-input">;
+        scope: z.ZodObject<{
+            id: z.ZodString;
+            epoch: z.ZodNumber;
+            keyId: z.ZodString;
+        }, z.core.$strict>;
+        chainHead: z.ZodObject<{
+            seq: z.ZodNumber;
+            hash: z.ZodString;
+        }, z.core.$strict>;
+        sender: z.ZodString;
+        salt: z.ZodString;
+        nonce: z.ZodString;
+        paddedLength: z.ZodNumber;
+        contentMac: z.ZodString;
+        ciphertext: z.ZodOptional<z.ZodString>;
+        ciphertextRef: z.ZodOptional<z.ZodObject<{
+            blobId: z.ZodString;
+            contentHash: z.ZodString;
+            size: z.ZodNumber;
+            contentType: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TaskSteerSealedPayload = z.infer<typeof TaskSteerSealedPayloadSchema>;
+/**
+ * daemon -> server: `task.complete` of a sealed task. `summary`,
+ * `finalMessage` and `document` are sealed. `artifactRefs` and
+ * `preparedObservation` are not carried in v1.
+ */
+export declare const TaskCompleteSealedPayloadSchema: z.ZodObject<{
     sealing: z.ZodOptional<z.ZodNever>;
     harnessId: z.ZodOptional<z.ZodString>;
-    summary: z.ZodString;
-    finalMessage: z.ZodOptional<z.ZodString>;
     sessionRef: z.ZodString;
-    artifactRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        blobId: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        contentType: z.ZodString;
-        url: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    document: z.ZodOptional<z.ZodUnknown>;
     usage: z.ZodOptional<z.ZodObject<{
         runtime: z.ZodEnum<{
             claude: "claude";
@@ -1699,11 +1632,6 @@ export declare const TaskCompletePayloadSchema: z.ZodObject<{
         clientVersion: z.ZodString;
         reportedAt: z.ZodISODateTime;
     }, z.core.$strip>>;
-    preparedObservation: z.ZodOptional<z.ZodObject<{
-        requestDigest: z.ZodString;
-        initialPromptTokens: z.ZodNumber;
-        maxPromptTokens: z.ZodNumber;
-    }, z.core.$strict>>;
     agentRef: z.ZodOptional<z.ZodObject<{
         agentId: z.ZodString;
         profileRevision: z.ZodString;
@@ -1723,60 +1651,42 @@ export declare const TaskCompletePayloadSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         outcome: z.ZodLiteral<"unmeasured">;
     }, z.core.$strict>], "outcome">>;
-}, z.core.$strip>;
-export type TaskCompletePayload = z.infer<typeof TaskCompletePayloadSchema>;
-/** A closed runtime failure class (#869). `unknown` means the runtime gave no structured evidence. */
-export declare const RuntimeFailureClassSchema: z.ZodEnum<{
-    auth: "auth";
-    billing: "billing";
-    input_too_large: "input_too_large";
-    invalid_request: "invalid_request";
-    limit_reached: "limit_reached";
-    model_unavailable: "model_unavailable";
-    output_schema: "output_schema";
-    overloaded: "overloaded";
-    provider: "provider";
-    quota: "quota";
-    rate_limited: "rate_limited";
-    runtime_exited: "runtime_exited";
-    unknown: "unknown";
-}>;
-export type RuntimeFailureClass = z.infer<typeof RuntimeFailureClassSchema>;
-/**
- * The machine-readable failure of a `task.fail` (#869); `reason` stays display
- * text. `resetsAt` (ISO 8601 UTC) exists only on `quota`, and only when the
- * runtime reported when the limit resets.
- */
-export declare const TaskFailureSchema: z.ZodUnion<readonly [z.ZodObject<{
-    class: z.ZodLiteral<"quota">;
-    resetsAt: z.ZodOptional<z.ZodISODateTime>;
-}, z.core.$strict>, z.ZodObject<{
-    class: z.ZodEnum<{
-        auth: "auth";
-        billing: "billing";
-        input_too_large: "input_too_large";
-        invalid_request: "invalid_request";
-        limit_reached: "limit_reached";
-        model_unavailable: "model_unavailable";
-        output_schema: "output_schema";
-        overloaded: "overloaded";
-        provider: "provider";
-        rate_limited: "rate_limited";
-        runtime_exited: "runtime_exited";
-        unknown: "unknown";
-    }>;
-}, z.core.$strict>]>;
-export type TaskFailure = z.infer<typeof TaskFailureSchema>;
-/** daemon -> server: task failed. */
-export declare const TaskFailPayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
+    sealed: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
+        category: z.ZodLiteral<"task-output">;
+        scope: z.ZodObject<{
+            id: z.ZodString;
+            epoch: z.ZodNumber;
+            keyId: z.ZodString;
+        }, z.core.$strict>;
+        chainHead: z.ZodObject<{
+            seq: z.ZodNumber;
+            hash: z.ZodString;
+        }, z.core.$strict>;
+        sender: z.ZodString;
+        salt: z.ZodString;
+        nonce: z.ZodString;
+        paddedLength: z.ZodNumber;
+        contentMac: z.ZodString;
+        ciphertext: z.ZodOptional<z.ZodString>;
+        ciphertextRef: z.ZodOptional<z.ZodObject<{
+            blobId: z.ZodString;
+            contentHash: z.ZodString;
+            size: z.ZodNumber;
+            contentType: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TaskCompleteSealedPayload = z.infer<typeof TaskCompleteSealedPayloadSchema>;
+/** daemon -> server: `task.fail` of a sealed task. `reason` is sealed; `preparedObservation` is not carried in v1. */
+export declare const TaskFailSealedPayloadSchema: z.ZodObject<{
     sealing: z.ZodOptional<z.ZodNever>;
     recovery: z.ZodOptional<z.ZodObject<{
         kind: z.ZodLiteral<"daemon_interrupted">;
         offerId: z.ZodUUID;
     }, z.core.$strict>>;
     harnessId: z.ZodOptional<z.ZodString>;
-    reason: z.ZodString;
     retryable: z.ZodOptional<z.ZodBoolean>;
     failure: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         class: z.ZodLiteral<"quota">;
@@ -1811,11 +1721,6 @@ export declare const TaskFailPayloadSchema: z.ZodObject<{
         clientVersion: z.ZodString;
         reportedAt: z.ZodISODateTime;
     }, z.core.$strip>>;
-    preparedObservation: z.ZodOptional<z.ZodObject<{
-        requestDigest: z.ZodString;
-        initialPromptTokens: z.ZodNumber;
-        maxPromptTokens: z.ZodNumber;
-    }, z.core.$strict>>;
     agentRef: z.ZodOptional<z.ZodObject<{
         agentId: z.ZodString;
         profileRevision: z.ZodString;
@@ -1835,176 +1740,159 @@ export declare const TaskFailPayloadSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         outcome: z.ZodLiteral<"unmeasured">;
     }, z.core.$strict>], "outcome">>;
-}, z.core.$strip>;
-export type TaskFailPayload = z.infer<typeof TaskFailPayloadSchema>;
+    sealed: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
+        category: z.ZodLiteral<"task-output">;
+        scope: z.ZodObject<{
+            id: z.ZodString;
+            epoch: z.ZodNumber;
+            keyId: z.ZodString;
+        }, z.core.$strict>;
+        chainHead: z.ZodObject<{
+            seq: z.ZodNumber;
+            hash: z.ZodString;
+        }, z.core.$strict>;
+        sender: z.ZodString;
+        salt: z.ZodString;
+        nonce: z.ZodString;
+        paddedLength: z.ZodNumber;
+        contentMac: z.ZodString;
+        ciphertext: z.ZodOptional<z.ZodString>;
+        ciphertextRef: z.ZodOptional<z.ZodObject<{
+            blobId: z.ZodString;
+            contentHash: z.ZodString;
+            size: z.ZodNumber;
+            contentType: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TaskFailSealedPayload = z.infer<typeof TaskFailSealedPayloadSchema>;
 /**
- * daemon -> server: task ended in the `Cancelled` state (M1 gap #6) — either
- * in response to a server-sent `task.cancel`, or a cancellation the daemon
- * observed/decided locally (e.g. a local stop action) that the server didn't
- * initiate. This is the canonical way to report a `Cancelled` outcome; it
- * supersedes the M0 convention of `task.fail({ reason: 'cancelled' })`.
- *
- * This is deliberately its own message rather than folded into `task.fail`
- * (decision: prefer the explicit message — see docs/protocol.md) because
- * `Cancelled` is semantically distinct from `Failed`: one is an intentional
- * stop, the other an error. Overloading `task.fail` with a magic
- * `reason: 'cancelled'` string convention hid that distinction on the wire.
- *
- * Dual-purpose on receipt: if the server already moved its own record to
- * `Cancelled` (it initiated the cancel — M1 gap #3's "server state is
- * authoritative" rule), this is an idempotent no-op ack. If the server
- * hasn't yet (a locally-observed cancellation), this is the authoritative
- * trigger that moves `Claimed`/`Running`/`AwaitApproval -> Cancelled`.
+ * daemon -> server: `task.decline` of a sealed task with a sealed `reason`.
+ * The sealed decline codes go only on the plaintext branch: a device that
+ * cannot open or use the scope key often cannot seal a reply either.
  */
-export declare const TaskCancelledPayloadSchema: z.ZodObject<{
-    sealed: z.ZodOptional<z.ZodNever>;
+export declare const TaskDeclineSealedPayloadSchema: z.ZodObject<{
     sealing: z.ZodOptional<z.ZodNever>;
-    harnessId: z.ZodOptional<z.ZodString>;
-    reason: z.ZodOptional<z.ZodString>;
-    usage: z.ZodOptional<z.ZodObject<{
-        runtime: z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-            pi: "pi";
-        }>;
-        provider: z.ZodOptional<z.ZodString>;
-        model: z.ZodOptional<z.ZodString>;
-        promptTokens: z.ZodOptional<z.ZodNumber>;
-        completionTokens: z.ZodOptional<z.ZodNumber>;
-        durationMs: z.ZodOptional<z.ZodNumber>;
-        clientVersion: z.ZodString;
-        reportedAt: z.ZodISODateTime;
-    }, z.core.$strip>>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
     agentRef: z.ZodOptional<z.ZodObject<{
         agentId: z.ZodString;
         profileRevision: z.ZodString;
     }, z.core.$strict>>;
-    agentHomeProjection: z.ZodOptional<z.ZodObject<{
-        profileRevision: z.ZodString;
-        projectionHash: z.ZodString;
+    admission: z.ZodOptional<z.ZodObject<{
+        totalMs: z.ZodNumber;
+        agentHomeWaitMs: z.ZodOptional<z.ZodNumber>;
+        messageHelperPreflightMs: z.ZodOptional<z.ZodNumber>;
+        resultHelperPreflightMs: z.ZodOptional<z.ZodNumber>;
+        toolsetProbeMs: z.ZodOptional<z.ZodNumber>;
+        runtimeLaunchMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
-    agentHomeMemoryChange: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        outcome: z.ZodLiteral<"unchanged">;
-    }, z.core.$strict>, z.ZodObject<{
-        outcome: z.ZodLiteral<"reader-attributed">;
-        paths: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        outcome: z.ZodLiteral<"unattributed">;
-        paths: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        outcome: z.ZodLiteral<"unmeasured">;
-    }, z.core.$strict>], "outcome">>;
-}, z.core.$strip>;
-export type TaskCancelledPayload = z.infer<typeof TaskCancelledPayloadSchema>;
-/**
- * daemon -> server: a pending `task.await_approval` was resolved entirely
- * LOCALLY on the device — the local control-socket `approvals.resolve` RPC,
- * a fail-closed `requestApproval` timeout, or a fail-closed eviction/finish
- * rejection (see `packages/client`'s `task-runner.ts`/`approvals.ts`) —
- * *without* a wire `task.approve`/`task.reject` ever having been exchanged
- * for it. This is the additive-minor answer to a gap the M4 Phase 3 approval
- * work left open (see the "Deferred additive candidate" note this schema
- * resolves, `docs/protocol.md`): today the server only learns of a local
- * resolution IMPLICITLY, after the fact, once the daemon's next
- * `task.progress`/`task.artifact`/`task.complete` proves the task already
- * moved on (`ConnectionHub.resumeIfImplicitlyApproved`,
- * `packages/server/src/hub.ts`) — a window in which a SaaS-side
- * `TaskHandle.approve()`/`.reject()` can independently decide (and win) the
- * server's own authoritative record before that evidence ever arrives. This
- * message lets the daemon report the local resolution explicitly and
- * immediately, narrowing that window from "until the next progress message"
- * down to ordinary network latency; the implicit-inference path stays as-is,
- * unconditionally, as the compatibility fallback for an old server that
- * never advertises the `approval_resolved` capability flag (`version.ts`) or
- * an old daemon that predates this message entirely.
- *
- * Observability-class tolerance applies (not control/security — see the
- * freeze rule's asymmetry, `docs/protocol.md`): this is a daemon reporting
- * what it already did locally, not a payload that grants/denies anything on
- * its own — the receiving server's own state machine (`TASK_TRANSITIONS`,
- * `task-state.ts`) is still what decides whether the reported resolution is
- * legal to apply. Plain `z.object()` (not `.strict()`), same as every other
- * non-control payload in this file.
- *
- * `resolvedBy` is a single-value enum (`'local'`) rather than a bare string:
- * deliberately future-proof (a later wave could add e.g. `'operator-cli'` as
- * a DISTINCT value without a version bump — a new enum member is additive,
- * same as a new message type or capability flag), while still being a closed,
- * typed shape today rather than an open string a typo could silently widen.
- */
-export declare const TaskApprovalResolvedPayloadSchema: z.ZodObject<{
-    approvalId: z.ZodString;
-    decision: z.ZodEnum<{
-        approve: "approve";
-        reject: "reject";
-    }>;
-    resolvedBy: z.ZodEnum<{
-        local: "local";
-    }>;
-    at: z.ZodISODateTime;
-}, z.core.$strip>;
-export type TaskApprovalResolvedPayload = z.infer<typeof TaskApprovalResolvedPayloadSchema>;
-/** server -> daemon: `task.offer` of a sealed task. */
-export declare const TaskOfferSealedPayloadSchema: z.ZodObject<{
-    runtime: z.ZodOptional<z.ZodEnum<{
-        claude: "claude";
-        codex: "codex";
-        pi: "pi";
+    code: z.ZodOptional<z.ZodEnum<{
+        agent_home_reader_busy: "agent_home_reader_busy";
+        agent_home_writer_busy: "agent_home_writer_busy";
     }>>;
+    sealed: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
+        category: z.ZodLiteral<"task-output">;
+        scope: z.ZodObject<{
+            id: z.ZodString;
+            epoch: z.ZodNumber;
+            keyId: z.ZodString;
+        }, z.core.$strict>;
+        chainHead: z.ZodObject<{
+            seq: z.ZodNumber;
+            hash: z.ZodString;
+        }, z.core.$strict>;
+        sender: z.ZodString;
+        salt: z.ZodString;
+        nonce: z.ZodString;
+        paddedLength: z.ZodNumber;
+        contentMac: z.ZodString;
+        ciphertext: z.ZodOptional<z.ZodString>;
+        ciphertextRef: z.ZodOptional<z.ZodObject<{
+            blobId: z.ZodString;
+            contentHash: z.ZodString;
+            size: z.ZodNumber;
+            contentType: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TaskDeclineSealedPayload = z.infer<typeof TaskDeclineSealedPayloadSchema>;
+/** daemon -> server: `task.cancelled` of a sealed task. `reason` is sealed. */
+export declare const TaskCancelledSealedPayloadSchema: z.ZodObject<{
+    sealing: z.ZodOptional<z.ZodNever>;
     harnessId: z.ZodOptional<z.ZodString>;
-    dispatchSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        lane: z.ZodLiteral<"subscription">;
-        runtimeId: z.ZodEnum<{
+    usage: z.ZodOptional<z.ZodObject<{
+        runtime: z.ZodEnum<{
             claude: "claude";
             codex: "codex";
+            pi: "pi";
         }>;
-        providerId: z.ZodNull;
-        modelId: z.ZodString;
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        promptTokens: z.ZodOptional<z.ZodNumber>;
+        completionTokens: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        clientVersion: z.ZodString;
+        reportedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    agentRef: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
+    }, z.core.$strict>>;
+    agentHomeProjection: z.ZodOptional<z.ZodObject<{
+        profileRevision: z.ZodString;
+        projectionHash: z.ZodString;
+    }, z.core.$strict>>;
+    agentHomeMemoryChange: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        outcome: z.ZodLiteral<"unchanged">;
     }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerId: z.ZodString;
-        modelId: z.ZodString;
+        outcome: z.ZodLiteral<"reader-attributed">;
+        paths: z.ZodArray<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok-profile">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerProfile: z.ZodObject<{
-            profileRef: z.ZodString;
-            profileRevision: z.ZodString;
-            profileHash: z.ZodString;
-            modelId: z.ZodString;
-            requiredCapabilities: z.ZodArray<z.ZodEnum<{
-                "image-input": "image-input";
-            }>>;
+        outcome: z.ZodLiteral<"unattributed">;
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"unmeasured">;
+    }, z.core.$strict>], "outcome">>;
+    sealed: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
+        category: z.ZodLiteral<"task-output">;
+        scope: z.ZodObject<{
+            id: z.ZodString;
+            epoch: z.ZodNumber;
+            keyId: z.ZodString;
         }, z.core.$strict>;
-    }, z.core.$strict>], "lane">>;
-    sessionRef: z.ZodOptional<z.ZodString>;
-    workspaceHint: z.ZodOptional<z.ZodString>;
-    limits: z.ZodOptional<z.ZodObject<{
-        maxDurationMs: z.ZodOptional<z.ZodNumber>;
-        maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    instruction: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        blobRef: z.ZodObject<{
+        chainHead: z.ZodObject<{
+            seq: z.ZodNumber;
+            hash: z.ZodString;
+        }, z.core.$strict>;
+        sender: z.ZodString;
+        salt: z.ZodString;
+        nonce: z.ZodString;
+        paddedLength: z.ZodNumber;
+        contentMac: z.ZodString;
+        ciphertext: z.ZodOptional<z.ZodString>;
+        ciphertextRef: z.ZodOptional<z.ZodObject<{
             blobId: z.ZodString;
             contentHash: z.ZodString;
             size: z.ZodNumber;
             contentType: z.ZodString;
-            url: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strict>]>>;
-    sealing: z.ZodObject<{
-        scopeId: z.ZodString;
-        epoch: z.ZodNumber;
-        categories: z.ZodArray<z.ZodEnum<{
-            "task-input": "task-input";
-            "task-output": "task-output";
-        }>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
-    sealed: z.ZodOptional<z.ZodObject<{
+}, z.core.$strict>;
+export type TaskCancelledSealedPayload = z.infer<typeof TaskCancelledSealedPayloadSchema>;
+/** daemon -> server: `task.progress` of a sealed task. `events` is sealed; `seq` names the batch. */
+export declare const TaskProgressSealedPayloadSchema: z.ZodObject<{
+    sealing: z.ZodOptional<z.ZodNever>;
+    seq: z.ZodNumber;
+    sealed: z.ZodObject<{
         v: z.ZodLiteral<1>;
         suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
-        category: z.ZodLiteral<"task-input">;
+        category: z.ZodLiteral<"task-output">;
         scope: z.ZodObject<{
             id: z.ZodString;
             epoch: z.ZodNumber;
@@ -2026,71 +1914,55 @@ export declare const TaskOfferSealedPayloadSchema: z.ZodObject<{
             size: z.ZodNumber;
             contentType: z.ZodString;
         }, z.core.$strict>>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>;
 }, z.core.$strict>;
-export type TaskOfferSealedPayload = z.infer<typeof TaskOfferSealedPayloadSchema>;
-/** server -> daemon: `task.offer_with_toolsets` of a sealed task. */
-export declare const TaskOfferWithToolsetsSealedPayloadSchema: z.ZodObject<{
-    runtime: z.ZodOptional<z.ZodEnum<{
-        claude: "claude";
-        codex: "codex";
-        pi: "pi";
-    }>>;
-    harnessId: z.ZodOptional<z.ZodString>;
-    dispatchSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        lane: z.ZodLiteral<"subscription">;
-        runtimeId: z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-        }>;
-        providerId: z.ZodNull;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerId: z.ZodString;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok-profile">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerProfile: z.ZodObject<{
-            profileRef: z.ZodString;
-            profileRevision: z.ZodString;
-            profileHash: z.ZodString;
-            modelId: z.ZodString;
-            requiredCapabilities: z.ZodArray<z.ZodEnum<{
-                "image-input": "image-input";
-            }>>;
+export type TaskProgressSealedPayload = z.infer<typeof TaskProgressSealedPayloadSchema>;
+/**
+ * daemon -> server: an inline artifact of a sealed task. `inline` is sealed; a
+ * blob artifact is not carried in v1. `artifactId` names the write in the AAD
+ * and the content MAC, because two artifacts of one task may share a `name`.
+ */
+export declare const TaskArtifactSealedPayloadSchema: z.ZodObject<{
+    sealing: z.ZodOptional<z.ZodNever>;
+    name: z.ZodString;
+    contentType: z.ZodString;
+    artifactId: z.ZodUUID;
+    sealed: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
+        category: z.ZodLiteral<"task-output">;
+        scope: z.ZodObject<{
+            id: z.ZodString;
+            epoch: z.ZodNumber;
+            keyId: z.ZodString;
         }, z.core.$strict>;
-    }, z.core.$strict>], "lane">>;
-    sessionRef: z.ZodOptional<z.ZodString>;
-    workspaceHint: z.ZodOptional<z.ZodString>;
-    limits: z.ZodOptional<z.ZodObject<{
-        maxDurationMs: z.ZodOptional<z.ZodNumber>;
-        maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    requiredToolsets: z.ZodArray<z.ZodString>;
-    instruction: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        blobRef: z.ZodObject<{
+        chainHead: z.ZodObject<{
+            seq: z.ZodNumber;
+            hash: z.ZodString;
+        }, z.core.$strict>;
+        sender: z.ZodString;
+        salt: z.ZodString;
+        nonce: z.ZodString;
+        paddedLength: z.ZodNumber;
+        contentMac: z.ZodString;
+        ciphertext: z.ZodOptional<z.ZodString>;
+        ciphertextRef: z.ZodOptional<z.ZodObject<{
             blobId: z.ZodString;
             contentHash: z.ZodString;
             size: z.ZodNumber;
             contentType: z.ZodString;
-            url: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strict>]>>;
-    sealing: z.ZodObject<{
-        scopeId: z.ZodString;
-        epoch: z.ZodNumber;
-        categories: z.ZodArray<z.ZodEnum<{
-            "task-input": "task-input";
-            "task-output": "task-output";
-        }>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
-    sealed: z.ZodOptional<z.ZodObject<{
+}, z.core.$strict>;
+export type TaskArtifactSealedPayload = z.infer<typeof TaskArtifactSealedPayloadSchema>;
+/** daemon -> server: `task.await_approval` of a sealed task. `summary` is sealed; `approvalId` is required. */
+export declare const TaskAwaitApprovalSealedPayloadSchema: z.ZodObject<{
+    sealing: z.ZodOptional<z.ZodNever>;
+    approvalId: z.ZodString;
+    sealed: z.ZodObject<{
         v: z.ZodLiteral<1>;
         suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
-        category: z.ZodLiteral<"task-input">;
+        category: z.ZodLiteral<"task-output">;
         scope: z.ZodObject<{
             id: z.ZodString;
             epoch: z.ZodNumber;
@@ -2112,86 +1984,16 @@ export declare const TaskOfferWithToolsetsSealedPayloadSchema: z.ZodObject<{
             size: z.ZodNumber;
             contentType: z.ZodString;
         }, z.core.$strict>>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>;
 }, z.core.$strict>;
-export type TaskOfferWithToolsetsSealedPayload = z.infer<typeof TaskOfferWithToolsetsSealedPayloadSchema>;
-/** server -> daemon: `task.offer_for_agent` of a sealed task. */
-export declare const TaskOfferForAgentSealedPayloadSchema: z.ZodObject<{
-    agentRef: z.ZodObject<{
-        agentId: z.ZodString;
-        profileRevision: z.ZodString;
-    }, z.core.$strict>;
-    homeAccess: z.ZodOptional<z.ZodLiteral<"memory-reader">>;
-    agentMemory: z.ZodOptional<z.ZodEnum<{
-        none: "none";
-        read: "read";
-        "read-if-admitted": "read-if-admitted";
-        "read-write": "read-write";
-        "read-write-if-admitted": "read-write-if-admitted";
-    }>>;
-    requiredToolsets: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    runtime: z.ZodOptional<z.ZodEnum<{
-        claude: "claude";
-        codex: "codex";
-        pi: "pi";
-    }>>;
-    harnessId: z.ZodOptional<z.ZodString>;
-    dispatchSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        lane: z.ZodLiteral<"subscription">;
-        runtimeId: z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-        }>;
-        providerId: z.ZodNull;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerId: z.ZodString;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok-profile">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerProfile: z.ZodObject<{
-            profileRef: z.ZodString;
-            profileRevision: z.ZodString;
-            profileHash: z.ZodString;
-            modelId: z.ZodString;
-            requiredCapabilities: z.ZodArray<z.ZodEnum<{
-                "image-input": "image-input";
-            }>>;
-        }, z.core.$strict>;
-    }, z.core.$strict>], "lane">>;
-    terminalProjection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        mode: z.ZodLiteral<"none">;
-    }, z.core.$strict>, z.ZodObject<{
-        mode: z.ZodLiteral<"result-document">;
-        contract: z.ZodString;
-        schema: z.ZodCustom<import("./result-schema").ResultSchema, import("./result-schema").ResultSchema>;
-    }, z.core.$strict>], "mode">>;
-    sessionRef: z.ZodOptional<z.ZodString>;
-    limits: z.ZodOptional<z.ZodObject<{
-        maxDurationMs: z.ZodOptional<z.ZodNumber>;
-        maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    instruction: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        blobRef: z.ZodObject<{
-            blobId: z.ZodString;
-            contentHash: z.ZodString;
-            size: z.ZodNumber;
-            contentType: z.ZodString;
-            url: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strict>]>>;
-    sealing: z.ZodObject<{
-        scopeId: z.ZodString;
-        epoch: z.ZodNumber;
-        categories: z.ZodArray<z.ZodEnum<{
-            "task-input": "task-input";
-            "task-output": "task-output";
-        }>>;
-    }, z.core.$strict>;
-    sealed: z.ZodOptional<z.ZodObject<{
+export type TaskAwaitApprovalSealedPayload = z.infer<typeof TaskAwaitApprovalSealedPayloadSchema>;
+export declare const TaskSteerPayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
+    sealed: z.ZodOptional<z.ZodNever>;
+    sealing: z.ZodOptional<z.ZodNever>;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    steerId: z.ZodUUID;
+    sealed: z.ZodObject<{
         v: z.ZodLiteral<1>;
         suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
         category: z.ZodLiteral<"task-input">;
@@ -2216,125 +2018,220 @@ export declare const TaskOfferForAgentSealedPayloadSchema: z.ZodObject<{
             size: z.ZodNumber;
             contentType: z.ZodString;
         }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type TaskOfferForAgentSealedPayload = z.infer<typeof TaskOfferForAgentSealedPayloadSchema>;
-/** server -> daemon: `task.offer_for_agent_with_egress` of a sealed task. */
-export declare const TaskOfferForAgentWithEgressSealedPayloadSchema: z.ZodObject<{
-    agentRef: z.ZodObject<{
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type TaskSteerPayload = z.infer<typeof TaskSteerPayloadSchema>;
+export declare const TaskDeclinePayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
+    sealed: z.ZodOptional<z.ZodNever>;
+    sealing: z.ZodOptional<z.ZodNever>;
+    reason: z.ZodString;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    agentRef: z.ZodOptional<z.ZodObject<{
         agentId: z.ZodString;
         profileRevision: z.ZodString;
-    }, z.core.$strict>;
-    homeAccess: z.ZodOptional<z.ZodLiteral<"memory-reader">>;
-    agentMemory: z.ZodOptional<z.ZodEnum<{
-        none: "none";
-        read: "read";
-        "read-if-admitted": "read-if-admitted";
-        "read-write": "read-write";
-        "read-write-if-admitted": "read-write-if-admitted";
+    }, z.core.$strict>>;
+    code: z.ZodOptional<z.ZodEnum<{
+        agent_home_reader_busy: "agent_home_reader_busy";
+        agent_home_writer_busy: "agent_home_writer_busy";
+        sealed_content_mac_mismatch: "sealed_content_mac_mismatch";
+        sealed_key_unavailable: "sealed_key_unavailable";
+        sealed_open_failed: "sealed_open_failed";
+        sealing_policy_mismatch: "sealing_policy_mismatch";
     }>>;
-    requiredToolsets: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    runtime: z.ZodOptional<z.ZodEnum<{
-        claude: "claude";
-        codex: "codex";
-        pi: "pi";
+    admission: z.ZodOptional<z.ZodObject<{
+        totalMs: z.ZodNumber;
+        agentHomeWaitMs: z.ZodOptional<z.ZodNumber>;
+        messageHelperPreflightMs: z.ZodOptional<z.ZodNumber>;
+        resultHelperPreflightMs: z.ZodOptional<z.ZodNumber>;
+        toolsetProbeMs: z.ZodOptional<z.ZodNumber>;
+        runtimeLaunchMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strip>, z.ZodObject<{
+    sealing: z.ZodOptional<z.ZodNever>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    agentRef: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
+    }, z.core.$strict>>;
+    admission: z.ZodOptional<z.ZodObject<{
+        totalMs: z.ZodNumber;
+        agentHomeWaitMs: z.ZodOptional<z.ZodNumber>;
+        messageHelperPreflightMs: z.ZodOptional<z.ZodNumber>;
+        resultHelperPreflightMs: z.ZodOptional<z.ZodNumber>;
+        toolsetProbeMs: z.ZodOptional<z.ZodNumber>;
+        runtimeLaunchMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    code: z.ZodOptional<z.ZodEnum<{
+        agent_home_reader_busy: "agent_home_reader_busy";
+        agent_home_writer_busy: "agent_home_writer_busy";
     }>>;
-    harnessId: z.ZodOptional<z.ZodString>;
-    dispatchSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        lane: z.ZodLiteral<"subscription">;
-        runtimeId: z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-        }>;
-        providerId: z.ZodNull;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerId: z.ZodString;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok-profile">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerProfile: z.ZodObject<{
-            profileRef: z.ZodString;
-            profileRevision: z.ZodString;
-            profileHash: z.ZodString;
-            modelId: z.ZodString;
-            requiredCapabilities: z.ZodArray<z.ZodEnum<{
-                "image-input": "image-input";
-            }>>;
+    sealed: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
+        category: z.ZodLiteral<"task-output">;
+        scope: z.ZodObject<{
+            id: z.ZodString;
+            epoch: z.ZodNumber;
+            keyId: z.ZodString;
         }, z.core.$strict>;
-    }, z.core.$strict>], "lane">>;
-    terminalProjection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        mode: z.ZodLiteral<"none">;
-    }, z.core.$strict>, z.ZodObject<{
-        mode: z.ZodLiteral<"result-document">;
-        contract: z.ZodString;
-        schema: z.ZodCustom<import("./result-schema").ResultSchema, import("./result-schema").ResultSchema>;
-    }, z.core.$strict>], "mode">>;
-    limits: z.ZodOptional<z.ZodObject<{
-        maxDurationMs: z.ZodOptional<z.ZodNumber>;
-        maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    sessionRef: z.ZodString;
-    egressPolicy: z.ZodObject<{
-        policyRevision: z.ZodString;
-        activity: z.ZodObject<{
-            delivery: z.ZodLiteral<"latest-value">;
-            maxCoalesceMs: z.ZodNumber;
-            maxEventBytes: z.ZodNumber;
+        chainHead: z.ZodObject<{
+            seq: z.ZodNumber;
+            hash: z.ZodString;
         }, z.core.$strict>;
-        reliable: z.ZodObject<{
-            maxPendingEventsPerAgent: z.ZodNumber;
-            maxPendingBytesPerAgent: z.ZodNumber;
-            maxPendingBytesPerTenant: z.ZodNumber;
+        sender: z.ZodString;
+        salt: z.ZodString;
+        nonce: z.ZodString;
+        paddedLength: z.ZodNumber;
+        contentMac: z.ZodString;
+        ciphertext: z.ZodOptional<z.ZodString>;
+        ciphertextRef: z.ZodOptional<z.ZodObject<{
+            blobId: z.ZodString;
+            contentHash: z.ZodString;
+            size: z.ZodNumber;
+            contentType: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type TaskDeclinePayload = z.infer<typeof TaskDeclinePayloadSchema>;
+export declare const TaskProgressPayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
+    sealed: z.ZodOptional<z.ZodNever>;
+    sealing: z.ZodOptional<z.ZodNever>;
+    seq: z.ZodNumber;
+    events: z.ZodArray<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"progress">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        tool: z.ZodString;
+        mcp: z.ZodOptional<z.ZodObject<{
+            server: z.ZodString;
+            tool: z.ZodString;
+        }, z.core.$strict>>;
+        input: z.ZodOptional<z.ZodUnknown>;
+        toolCallId: z.ZodOptional<z.ZodString>;
+        spill: z.ZodOptional<z.ZodObject<{
+            field: z.ZodEnum<{
+                input: "input";
+                output: "output";
+            }>;
+            totalBytes: z.ZodNumber;
+            omittedBytes: z.ZodNumber;
+            contentType: z.ZodLiteral<"application/json">;
+            blob: z.ZodOptional<z.ZodObject<{
+                blobId: z.ZodString;
+                contentHash: z.ZodString;
+                size: z.ZodNumber;
+                contentType: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            unstoredReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_result">;
+        tool: z.ZodString;
+        mcp: z.ZodOptional<z.ZodObject<{
+            server: z.ZodString;
+            tool: z.ZodString;
+        }, z.core.$strict>>;
+        output: z.ZodOptional<z.ZodUnknown>;
+        toolCallId: z.ZodOptional<z.ZodString>;
+        isError: z.ZodOptional<z.ZodBoolean>;
+        spill: z.ZodOptional<z.ZodObject<{
+            field: z.ZodEnum<{
+                input: "input";
+                output: "output";
+            }>;
+            totalBytes: z.ZodNumber;
+            omittedBytes: z.ZodNumber;
+            contentType: z.ZodLiteral<"application/json">;
+            blob: z.ZodOptional<z.ZodObject<{
+                blobId: z.ZodString;
+                contentHash: z.ZodString;
+                size: z.ZodNumber;
+                contentType: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            unstoredReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"artifact">;
+        name: z.ZodString;
+        contentType: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"turn_end">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"usage">;
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        reasoningTokens: z.ZodOptional<z.ZodNumber>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+        contextTokens: z.ZodOptional<z.ZodNumber>;
+        contextWindow: z.ZodOptional<z.ZodNumber>;
+        contextSource: z.ZodOptional<z.ZodEnum<{
+            estimate: "estimate";
+            provider: "provider";
+        }>>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">, z.ZodObject<{
+        type: z.ZodString;
+    }, z.core.$loose>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    sealing: z.ZodOptional<z.ZodNever>;
+    seq: z.ZodNumber;
+    sealed: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
+        category: z.ZodLiteral<"task-output">;
+        scope: z.ZodObject<{
+            id: z.ZodString;
+            epoch: z.ZodNumber;
+            keyId: z.ZodString;
         }, z.core.$strict>;
-        transfers: z.ZodObject<{
-            workspace: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
-                maxBytes: z.ZodNumber;
-                allowedMimeTypes: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>]>;
-            transcript: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
-                maxBytes: z.ZodNumber;
-                allowedMimeTypes: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>]>;
-            artifact: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
-                maxBytes: z.ZodNumber;
-                allowedMimeTypes: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>]>;
+        chainHead: z.ZodObject<{
+            seq: z.ZodNumber;
+            hash: z.ZodString;
         }, z.core.$strict>;
-    }, z.core.$strict>;
-    messageEgress: z.ZodOptional<z.ZodObject<{
-        mode: z.ZodLiteral<"required">;
-        contract: z.ZodString;
-        contentType: z.ZodEnum<{
-            "text/markdown": "text/markdown";
-            "text/plain": "text/plain";
-        }>;
-        maxBytes: z.ZodNumber;
-    }, z.core.$strict>>;
-    instruction: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        blobRef: z.ZodObject<{
+        sender: z.ZodString;
+        salt: z.ZodString;
+        nonce: z.ZodString;
+        paddedLength: z.ZodNumber;
+        contentMac: z.ZodString;
+        ciphertext: z.ZodOptional<z.ZodString>;
+        ciphertextRef: z.ZodOptional<z.ZodObject<{
             blobId: z.ZodString;
             contentHash: z.ZodString;
             size: z.ZodNumber;
             contentType: z.ZodString;
-            url: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strict>]>>;
-    sealing: z.ZodObject<{
-        scopeId: z.ZodString;
-        epoch: z.ZodNumber;
-        categories: z.ZodArray<z.ZodEnum<{
-            "task-input": "task-input";
-            "task-output": "task-output";
-        }>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
-    sealed: z.ZodOptional<z.ZodObject<{
+}, z.core.$strict>]>;
+export type TaskProgressPayload = z.infer<typeof TaskProgressPayloadSchema>;
+export declare const TaskArtifactPayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
+    sealed: z.ZodOptional<z.ZodNever>;
+    sealing: z.ZodOptional<z.ZodNever>;
+    name: z.ZodString;
+    contentType: z.ZodString;
+    inline: z.ZodOptional<z.ZodString>;
+    blobRef: z.ZodOptional<z.ZodObject<{
+        blobId: z.ZodString;
+        contentHash: z.ZodString;
+        size: z.ZodNumber;
+        contentType: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    sealing: z.ZodOptional<z.ZodNever>;
+    name: z.ZodString;
+    contentType: z.ZodString;
+    artifactId: z.ZodUUID;
+    sealed: z.ZodObject<{
         v: z.ZodLiteral<1>;
         suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
-        category: z.ZodLiteral<"task-input">;
+        category: z.ZodLiteral<"task-output">;
         scope: z.ZodObject<{
             id: z.ZodString;
             epoch: z.ZodNumber;
@@ -2356,127 +2253,21 @@ export declare const TaskOfferForAgentWithEgressSealedPayloadSchema: z.ZodObject
             size: z.ZodNumber;
             contentType: z.ZodString;
         }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type TaskOfferForAgentWithEgressSealedPayload = z.infer<typeof TaskOfferForAgentWithEgressSealedPayloadSchema>;
-/**
- * server -> daemon: `task.offer_for_agent_with_egress_fresh` of a sealed task.
- * Only this type takes `routineRef`: a routine occurrence is an execution.
- */
-export declare const TaskOfferForAgentWithEgressFreshSealedPayloadSchema: z.ZodObject<{
-    agentRef: z.ZodObject<{
-        agentId: z.ZodString;
-        profileRevision: z.ZodString;
-    }, z.core.$strict>;
-    homeAccess: z.ZodOptional<z.ZodLiteral<"memory-reader">>;
-    agentMemory: z.ZodOptional<z.ZodEnum<{
-        none: "none";
-        read: "read";
-        "read-if-admitted": "read-if-admitted";
-        "read-write": "read-write";
-        "read-write-if-admitted": "read-write-if-admitted";
-    }>>;
-    requiredToolsets: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    runtime: z.ZodOptional<z.ZodEnum<{
-        claude: "claude";
-        codex: "codex";
-        pi: "pi";
-    }>>;
-    harnessId: z.ZodOptional<z.ZodString>;
-    dispatchSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        lane: z.ZodLiteral<"subscription">;
-        runtimeId: z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-        }>;
-        providerId: z.ZodNull;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerId: z.ZodString;
-        modelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        lane: z.ZodLiteral<"byok-profile">;
-        runtimeId: z.ZodLiteral<"pi">;
-        providerProfile: z.ZodObject<{
-            profileRef: z.ZodString;
-            profileRevision: z.ZodString;
-            profileHash: z.ZodString;
-            modelId: z.ZodString;
-            requiredCapabilities: z.ZodArray<z.ZodEnum<{
-                "image-input": "image-input";
-            }>>;
-        }, z.core.$strict>;
-    }, z.core.$strict>], "lane">>;
-    terminalProjection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        mode: z.ZodLiteral<"none">;
-    }, z.core.$strict>, z.ZodObject<{
-        mode: z.ZodLiteral<"result-document">;
-        contract: z.ZodString;
-        schema: z.ZodCustom<import("./result-schema").ResultSchema, import("./result-schema").ResultSchema>;
-    }, z.core.$strict>], "mode">>;
-    limits: z.ZodOptional<z.ZodObject<{
-        maxDurationMs: z.ZodOptional<z.ZodNumber>;
-        maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    egressPolicy: z.ZodObject<{
-        policyRevision: z.ZodString;
-        activity: z.ZodObject<{
-            delivery: z.ZodLiteral<"latest-value">;
-            maxCoalesceMs: z.ZodNumber;
-            maxEventBytes: z.ZodNumber;
-        }, z.core.$strict>;
-        reliable: z.ZodObject<{
-            maxPendingEventsPerAgent: z.ZodNumber;
-            maxPendingBytesPerAgent: z.ZodNumber;
-            maxPendingBytesPerTenant: z.ZodNumber;
-        }, z.core.$strict>;
-        transfers: z.ZodObject<{
-            workspace: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
-                maxBytes: z.ZodNumber;
-                allowedMimeTypes: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>]>;
-            transcript: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
-                maxBytes: z.ZodNumber;
-                allowedMimeTypes: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>]>;
-            artifact: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
-                maxBytes: z.ZodNumber;
-                allowedMimeTypes: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>]>;
-        }, z.core.$strict>;
-    }, z.core.$strict>;
-    messageEgress: z.ZodOptional<z.ZodObject<{
-        mode: z.ZodLiteral<"required">;
-        contract: z.ZodString;
-        contentType: z.ZodEnum<{
-            "text/markdown": "text/markdown";
-            "text/plain": "text/plain";
-        }>;
-        maxBytes: z.ZodNumber;
-    }, z.core.$strict>>;
-    instruction: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        blobRef: z.ZodObject<{
-            blobId: z.ZodString;
-            contentHash: z.ZodString;
-            size: z.ZodNumber;
-            contentType: z.ZodString;
-            url: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strict>]>>;
-    sealing: z.ZodObject<{
-        scopeId: z.ZodString;
-        epoch: z.ZodNumber;
-        categories: z.ZodArray<z.ZodEnum<{
-            "task-input": "task-input";
-            "task-output": "task-output";
-        }>>;
     }, z.core.$strict>;
-    sealed: z.ZodOptional<z.ZodObject<{
+}, z.core.$strict>]>;
+export type TaskArtifactPayload = z.infer<typeof TaskArtifactPayloadSchema>;
+export declare const TaskAwaitApprovalPayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
+    sealed: z.ZodOptional<z.ZodNever>;
+    sealing: z.ZodOptional<z.ZodNever>;
+    summary: z.ZodString;
+    approvalId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    sealing: z.ZodOptional<z.ZodNever>;
+    approvalId: z.ZodString;
+    sealed: z.ZodObject<{
         v: z.ZodLiteral<1>;
         suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
-        category: z.ZodLiteral<"task-input">;
+        category: z.ZodLiteral<"task-output">;
         scope: z.ZodObject<{
             id: z.ZodString;
             epoch: z.ZodNumber;
@@ -2498,25 +2289,103 @@ export declare const TaskOfferForAgentWithEgressFreshSealedPayloadSchema: z.ZodO
             size: z.ZodNumber;
             contentType: z.ZodString;
         }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type TaskAwaitApprovalPayload = z.infer<typeof TaskAwaitApprovalPayloadSchema>;
+export declare const TaskCompletePayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
+    sealed: z.ZodOptional<z.ZodNever>;
+    sealing: z.ZodOptional<z.ZodNever>;
+    harnessId: z.ZodOptional<z.ZodString>;
+    summary: z.ZodString;
+    finalMessage: z.ZodOptional<z.ZodString>;
+    sessionRef: z.ZodString;
+    artifactRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        blobId: z.ZodString;
+        contentHash: z.ZodString;
+        size: z.ZodNumber;
+        contentType: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    document: z.ZodOptional<z.ZodUnknown>;
+    usage: z.ZodOptional<z.ZodObject<{
+        runtime: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            pi: "pi";
+        }>;
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        promptTokens: z.ZodOptional<z.ZodNumber>;
+        completionTokens: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        clientVersion: z.ZodString;
+        reportedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    preparedObservation: z.ZodOptional<z.ZodObject<{
+        requestDigest: z.ZodString;
+        initialPromptTokens: z.ZodNumber;
+        maxPromptTokens: z.ZodNumber;
     }, z.core.$strict>>;
-    routineRef: z.ZodOptional<z.ZodObject<{
-        routineId: z.ZodString;
-        definitionVersion: z.ZodNumber;
-        notAfter: z.ZodString;
+    agentRef: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
     }, z.core.$strict>>;
-}, z.core.$strict>;
-export type TaskOfferForAgentWithEgressFreshSealedPayload = z.infer<typeof TaskOfferForAgentWithEgressFreshSealedPayloadSchema>;
-/**
- * server -> daemon: sealed steering text. `steerId` names this steer in the
- * AAD and the content MAC, so the Host cannot replay an earlier steer of the
- * same task as a new one.
- */
-export declare const TaskSteerSealedPayloadSchema: z.ZodObject<{
-    steerId: z.ZodUUID;
+    agentHomeProjection: z.ZodOptional<z.ZodObject<{
+        profileRevision: z.ZodString;
+        projectionHash: z.ZodString;
+    }, z.core.$strict>>;
+    agentHomeMemoryChange: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        outcome: z.ZodLiteral<"unchanged">;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"reader-attributed">;
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"unattributed">;
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"unmeasured">;
+    }, z.core.$strict>], "outcome">>;
+}, z.core.$strip>, z.ZodObject<{
+    sealing: z.ZodOptional<z.ZodNever>;
+    harnessId: z.ZodOptional<z.ZodString>;
+    sessionRef: z.ZodString;
+    usage: z.ZodOptional<z.ZodObject<{
+        runtime: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            pi: "pi";
+        }>;
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        promptTokens: z.ZodOptional<z.ZodNumber>;
+        completionTokens: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        clientVersion: z.ZodString;
+        reportedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    agentRef: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
+    }, z.core.$strict>>;
+    agentHomeProjection: z.ZodOptional<z.ZodObject<{
+        profileRevision: z.ZodString;
+        projectionHash: z.ZodString;
+    }, z.core.$strict>>;
+    agentHomeMemoryChange: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        outcome: z.ZodLiteral<"unchanged">;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"reader-attributed">;
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"unattributed">;
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"unmeasured">;
+    }, z.core.$strict>], "outcome">>;
     sealed: z.ZodObject<{
         v: z.ZodLiteral<1>;
         suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
-        category: z.ZodLiteral<"task-input">;
+        category: z.ZodLiteral<"task-output">;
         scope: z.ZodObject<{
             id: z.ZodString;
             epoch: z.ZodNumber;
@@ -2539,17 +2408,37 @@ export declare const TaskSteerSealedPayloadSchema: z.ZodObject<{
             contentType: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
-}, z.core.$strict>;
-export type TaskSteerSealedPayload = z.infer<typeof TaskSteerSealedPayloadSchema>;
-/**
- * daemon -> server: `task.complete` of a sealed task. `summary`,
- * `finalMessage` and `document` are sealed. `artifactRefs` and
- * `preparedObservation` are not carried in v1.
- */
-export declare const TaskCompleteSealedPayloadSchema: z.ZodObject<{
+}, z.core.$strict>]>;
+export type TaskCompletePayload = z.infer<typeof TaskCompletePayloadSchema>;
+export declare const TaskFailPayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
+    sealed: z.ZodOptional<z.ZodNever>;
     sealing: z.ZodOptional<z.ZodNever>;
+    recovery: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"daemon_interrupted">;
+        offerId: z.ZodUUID;
+    }, z.core.$strict>>;
     harnessId: z.ZodOptional<z.ZodString>;
-    sessionRef: z.ZodString;
+    reason: z.ZodString;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    failure: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        class: z.ZodLiteral<"quota">;
+        resetsAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>, z.ZodObject<{
+        class: z.ZodEnum<{
+            auth: "auth";
+            billing: "billing";
+            input_too_large: "input_too_large";
+            invalid_request: "invalid_request";
+            limit_reached: "limit_reached";
+            model_unavailable: "model_unavailable";
+            output_schema: "output_schema";
+            overloaded: "overloaded";
+            provider: "provider";
+            rate_limited: "rate_limited";
+            runtime_exited: "runtime_exited";
+            unknown: "unknown";
+        }>;
+    }, z.core.$strict>]>>;
     usage: z.ZodOptional<z.ZodObject<{
         runtime: z.ZodEnum<{
             claude: "claude";
@@ -2564,6 +2453,11 @@ export declare const TaskCompleteSealedPayloadSchema: z.ZodObject<{
         clientVersion: z.ZodString;
         reportedAt: z.ZodISODateTime;
     }, z.core.$strip>>;
+    preparedObservation: z.ZodOptional<z.ZodObject<{
+        requestDigest: z.ZodString;
+        initialPromptTokens: z.ZodNumber;
+        maxPromptTokens: z.ZodNumber;
+    }, z.core.$strict>>;
     agentRef: z.ZodOptional<z.ZodObject<{
         agentId: z.ZodString;
         profileRevision: z.ZodString;
@@ -2583,36 +2477,7 @@ export declare const TaskCompleteSealedPayloadSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         outcome: z.ZodLiteral<"unmeasured">;
     }, z.core.$strict>], "outcome">>;
-    sealed: z.ZodObject<{
-        v: z.ZodLiteral<1>;
-        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
-        category: z.ZodLiteral<"task-output">;
-        scope: z.ZodObject<{
-            id: z.ZodString;
-            epoch: z.ZodNumber;
-            keyId: z.ZodString;
-        }, z.core.$strict>;
-        chainHead: z.ZodObject<{
-            seq: z.ZodNumber;
-            hash: z.ZodString;
-        }, z.core.$strict>;
-        sender: z.ZodString;
-        salt: z.ZodString;
-        nonce: z.ZodString;
-        paddedLength: z.ZodNumber;
-        contentMac: z.ZodString;
-        ciphertext: z.ZodOptional<z.ZodString>;
-        ciphertextRef: z.ZodOptional<z.ZodObject<{
-            blobId: z.ZodString;
-            contentHash: z.ZodString;
-            size: z.ZodNumber;
-            contentType: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type TaskCompleteSealedPayload = z.infer<typeof TaskCompleteSealedPayloadSchema>;
-/** daemon -> server: `task.fail` of a sealed task. `reason` is sealed; `preparedObservation` is not carried in v1. */
-export declare const TaskFailSealedPayloadSchema: z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     sealing: z.ZodOptional<z.ZodNever>;
     recovery: z.ZodOptional<z.ZodObject<{
         kind: z.ZodLiteral<"daemon_interrupted">;
@@ -2698,54 +2563,47 @@ export declare const TaskFailSealedPayloadSchema: z.ZodObject<{
             contentType: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
-}, z.core.$strict>;
-export type TaskFailSealedPayload = z.infer<typeof TaskFailSealedPayloadSchema>;
-/**
- * daemon -> server: `task.decline` of a sealed task with a sealed `reason`.
- * The sealed decline codes go only on the plaintext `task.decline`: a device
- * that cannot open or use the scope key often cannot seal a reply either.
- */
-export declare const TaskDeclineSealedPayloadSchema: z.ZodObject<{
+}, z.core.$strict>]>;
+export type TaskFailPayload = z.infer<typeof TaskFailPayloadSchema>;
+export declare const TaskCancelledPayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
+    sealed: z.ZodOptional<z.ZodNever>;
     sealing: z.ZodOptional<z.ZodNever>;
-    retryable: z.ZodOptional<z.ZodBoolean>;
+    harnessId: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    usage: z.ZodOptional<z.ZodObject<{
+        runtime: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            pi: "pi";
+        }>;
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        promptTokens: z.ZodOptional<z.ZodNumber>;
+        completionTokens: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        clientVersion: z.ZodString;
+        reportedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
     agentRef: z.ZodOptional<z.ZodObject<{
         agentId: z.ZodString;
         profileRevision: z.ZodString;
     }, z.core.$strict>>;
-    code: z.ZodOptional<z.ZodEnum<{
-        agent_home_reader_busy: "agent_home_reader_busy";
-        agent_home_writer_busy: "agent_home_writer_busy";
-    }>>;
-    sealed: z.ZodObject<{
-        v: z.ZodLiteral<1>;
-        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
-        category: z.ZodLiteral<"task-output">;
-        scope: z.ZodObject<{
-            id: z.ZodString;
-            epoch: z.ZodNumber;
-            keyId: z.ZodString;
-        }, z.core.$strict>;
-        chainHead: z.ZodObject<{
-            seq: z.ZodNumber;
-            hash: z.ZodString;
-        }, z.core.$strict>;
-        sender: z.ZodString;
-        salt: z.ZodString;
-        nonce: z.ZodString;
-        paddedLength: z.ZodNumber;
-        contentMac: z.ZodString;
-        ciphertext: z.ZodOptional<z.ZodString>;
-        ciphertextRef: z.ZodOptional<z.ZodObject<{
-            blobId: z.ZodString;
-            contentHash: z.ZodString;
-            size: z.ZodNumber;
-            contentType: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type TaskDeclineSealedPayload = z.infer<typeof TaskDeclineSealedPayloadSchema>;
-/** daemon -> server: `task.cancelled` of a sealed task. `reason` is sealed. */
-export declare const TaskCancelledSealedPayloadSchema: z.ZodObject<{
+    agentHomeProjection: z.ZodOptional<z.ZodObject<{
+        profileRevision: z.ZodString;
+        projectionHash: z.ZodString;
+    }, z.core.$strict>>;
+    agentHomeMemoryChange: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        outcome: z.ZodLiteral<"unchanged">;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"reader-attributed">;
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"unattributed">;
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"unmeasured">;
+    }, z.core.$strict>], "outcome">>;
+}, z.core.$strip>, z.ZodObject<{
     sealing: z.ZodOptional<z.ZodNever>;
     harnessId: z.ZodOptional<z.ZodString>;
     usage: z.ZodOptional<z.ZodObject<{
@@ -2807,156 +2665,20 @@ export declare const TaskCancelledSealedPayloadSchema: z.ZodObject<{
             contentType: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
-}, z.core.$strict>;
-export type TaskCancelledSealedPayload = z.infer<typeof TaskCancelledSealedPayloadSchema>;
-/** daemon -> server: `task.progress` of a sealed task. `events` is sealed; `seq` names the batch. */
-export declare const TaskProgressSealedPayloadSchema: z.ZodObject<{
-    sealing: z.ZodOptional<z.ZodNever>;
-    seq: z.ZodNumber;
-    sealed: z.ZodObject<{
-        v: z.ZodLiteral<1>;
-        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
-        category: z.ZodLiteral<"task-output">;
-        scope: z.ZodObject<{
-            id: z.ZodString;
-            epoch: z.ZodNumber;
-            keyId: z.ZodString;
-        }, z.core.$strict>;
-        chainHead: z.ZodObject<{
-            seq: z.ZodNumber;
-            hash: z.ZodString;
-        }, z.core.$strict>;
-        sender: z.ZodString;
-        salt: z.ZodString;
-        nonce: z.ZodString;
-        paddedLength: z.ZodNumber;
-        contentMac: z.ZodString;
-        ciphertext: z.ZodOptional<z.ZodString>;
-        ciphertextRef: z.ZodOptional<z.ZodObject<{
-            blobId: z.ZodString;
-            contentHash: z.ZodString;
-            size: z.ZodNumber;
-            contentType: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type TaskProgressSealedPayload = z.infer<typeof TaskProgressSealedPayloadSchema>;
-/**
- * daemon -> server: an inline artifact of a sealed task. `inline` is sealed; a
- * blob artifact is not carried in v1. `artifactId` names the write in the AAD
- * and the content MAC, because two artifacts of one task may share a `name`.
- */
-export declare const TaskArtifactSealedPayloadSchema: z.ZodObject<{
-    sealing: z.ZodOptional<z.ZodNever>;
-    name: z.ZodString;
-    contentType: z.ZodString;
-    artifactId: z.ZodUUID;
-    sealed: z.ZodObject<{
-        v: z.ZodLiteral<1>;
-        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
-        category: z.ZodLiteral<"task-output">;
-        scope: z.ZodObject<{
-            id: z.ZodString;
-            epoch: z.ZodNumber;
-            keyId: z.ZodString;
-        }, z.core.$strict>;
-        chainHead: z.ZodObject<{
-            seq: z.ZodNumber;
-            hash: z.ZodString;
-        }, z.core.$strict>;
-        sender: z.ZodString;
-        salt: z.ZodString;
-        nonce: z.ZodString;
-        paddedLength: z.ZodNumber;
-        contentMac: z.ZodString;
-        ciphertext: z.ZodOptional<z.ZodString>;
-        ciphertextRef: z.ZodOptional<z.ZodObject<{
-            blobId: z.ZodString;
-            contentHash: z.ZodString;
-            size: z.ZodNumber;
-            contentType: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type TaskArtifactSealedPayload = z.infer<typeof TaskArtifactSealedPayloadSchema>;
-/** daemon -> server: `task.await_approval` of a sealed task. `summary` is sealed; `approvalId` is required. */
-export declare const TaskAwaitApprovalSealedPayloadSchema: z.ZodObject<{
-    sealing: z.ZodOptional<z.ZodNever>;
-    approvalId: z.ZodString;
-    sealed: z.ZodObject<{
-        v: z.ZodLiteral<1>;
-        suite: z.ZodLiteral<"byok-sealed-v1.hkdf-sha256.aes-256-gcm">;
-        category: z.ZodLiteral<"task-output">;
-        scope: z.ZodObject<{
-            id: z.ZodString;
-            epoch: z.ZodNumber;
-            keyId: z.ZodString;
-        }, z.core.$strict>;
-        chainHead: z.ZodObject<{
-            seq: z.ZodNumber;
-            hash: z.ZodString;
-        }, z.core.$strict>;
-        sender: z.ZodString;
-        salt: z.ZodString;
-        nonce: z.ZodString;
-        paddedLength: z.ZodNumber;
-        contentMac: z.ZodString;
-        ciphertext: z.ZodOptional<z.ZodString>;
-        ciphertextRef: z.ZodOptional<z.ZodObject<{
-            blobId: z.ZodString;
-            contentHash: z.ZodString;
-            size: z.ZodNumber;
-            contentType: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type TaskAwaitApprovalSealedPayload = z.infer<typeof TaskAwaitApprovalSealedPayloadSchema>;
+}, z.core.$strict>]>;
+export type TaskCancelledPayload = z.infer<typeof TaskCancelledPayloadSchema>;
 /**
- * Protocol-owned task-opening family; the wire registry consumes these same entries.
- *
- * Each value is written `X as typeof X`, here and in `MESSAGE_PAYLOAD_SCHEMAS`.
- * The assertion is type-only (no runtime code). It makes declaration emit
- * name each schema (`typeof X`) instead of copying its full type, which keeps
- * the published `.d.ts` small. Every new entry follows this rule.
+ * Each value is written `X as typeof X`. The assertion is type-only (no
+ * runtime code). It makes declaration emit name each schema (`typeof X`)
+ * instead of copying its full type, which keeps the published `.d.ts` small.
+ * Every new entry follows this rule. Entries are grouped by direction.
  */
-declare const TASK_OFFER_PAYLOAD_SCHEMAS: {
-    readonly 'task.offer': typeof TaskOfferPayloadSchema;
-    readonly 'task.offer_with_toolsets': typeof TaskOfferWithToolsetsPayloadSchema;
-    readonly 'task.offer_for_agent': typeof TaskOfferForAgentPayloadSchema;
-    readonly 'task.offer_for_agent_with_egress': typeof TaskOfferForAgentWithEgressPayloadSchema;
-    readonly 'task.offer_for_agent_with_egress_fresh': typeof TaskOfferForAgentWithEgressFreshPayloadSchema;
-    readonly 'task.offer_prepared': typeof TaskOfferPreparedPayloadSchema;
-    readonly 'task.offer_sealed': typeof TaskOfferSealedPayloadSchema;
-    readonly 'task.offer_with_toolsets_sealed': typeof TaskOfferWithToolsetsSealedPayloadSchema;
-    readonly 'task.offer_for_agent_sealed': typeof TaskOfferForAgentSealedPayloadSchema;
-    readonly 'task.offer_for_agent_with_egress_sealed': typeof TaskOfferForAgentWithEgressSealedPayloadSchema;
-    readonly 'task.offer_for_agent_with_egress_fresh_sealed': typeof TaskOfferForAgentWithEgressFreshSealedPayloadSchema;
-};
-export type TaskOfferType = keyof typeof TASK_OFFER_PAYLOAD_SCHEMAS;
-export declare const TASK_OFFER_TYPES: readonly TaskOfferType[];
-/** Classify task-opening offers without duplicating the protocol registry in consumers. */
-export declare function isTaskOfferType(type: string): type is TaskOfferType;
 export declare const MESSAGE_PAYLOAD_SCHEMAS: {
-    readonly 'task.offer': typeof TaskOfferPayloadSchema;
-    readonly 'task.offer_with_toolsets': typeof TaskOfferWithToolsetsPayloadSchema;
-    readonly 'task.offer_for_agent': typeof TaskOfferForAgentPayloadSchema;
-    readonly 'task.offer_for_agent_with_egress': typeof TaskOfferForAgentWithEgressPayloadSchema;
-    readonly 'task.offer_for_agent_with_egress_fresh': typeof TaskOfferForAgentWithEgressFreshPayloadSchema;
-    readonly 'task.offer_prepared': typeof TaskOfferPreparedPayloadSchema;
-    readonly 'task.offer_sealed': typeof TaskOfferSealedPayloadSchema;
-    readonly 'task.offer_with_toolsets_sealed': typeof TaskOfferWithToolsetsSealedPayloadSchema;
-    readonly 'task.offer_for_agent_sealed': typeof TaskOfferForAgentSealedPayloadSchema;
-    readonly 'task.offer_for_agent_with_egress_sealed': typeof TaskOfferForAgentWithEgressSealedPayloadSchema;
-    readonly 'task.offer_for_agent_with_egress_fresh_sealed': typeof TaskOfferForAgentWithEgressFreshSealedPayloadSchema;
     readonly 'conn.hello': typeof ConnHelloPayloadSchema;
-    readonly 'conn.ack': typeof ConnAckPayloadSchema;
-    readonly 'agent.egress.reliable': typeof AgentEgressReliablePayloadSchema;
+    readonly 'task.offer': typeof TaskOfferPayloadSchema;
     readonly 'agent.egress.ack': typeof AgentEgressAckPayloadSchema;
-    readonly 'agent.message.draft': typeof AgentMessageDraftPayloadSchema;
-    readonly 'agent.message.publish': typeof AgentMessagePublishPayloadSchema;
     readonly 'agent.message.disposition': typeof AgentMessageDispositionPayloadSchema;
     readonly 'agent.content.read': typeof AgentContentReadPayloadSchema;
-    readonly 'agent.content.receipt': typeof AgentContentReceiptPayloadSchema;
     readonly 'agent.home.projection': typeof AgentHomeProjectionPayloadSchema;
     readonly 'agent.input.preparation': typeof AgentInputPreparationPayloadSchema;
     readonly 'provider.provisioning.available': typeof ProviderProvisioningAvailablePayloadSchema;
@@ -2965,6 +2687,7 @@ export declare const MESSAGE_PAYLOAD_SCHEMAS: {
     readonly 'task.reject': typeof TaskRejectPayloadSchema;
     readonly 'task.cancel': typeof TaskCancelPayloadSchema;
     readonly 'task.steer': typeof TaskSteerPayloadSchema;
+    readonly 'e2ee.key_package.available': typeof E2eeKeyPackageAvailablePayloadSchema;
     readonly 'task.claim': typeof TaskClaimPayloadSchema;
     readonly 'task.started': typeof TaskStartedPayloadSchema;
     readonly 'task.decline': typeof TaskDeclinePayloadSchema;
@@ -2975,15 +2698,10 @@ export declare const MESSAGE_PAYLOAD_SCHEMAS: {
     readonly 'task.fail': typeof TaskFailPayloadSchema;
     readonly 'task.cancelled': typeof TaskCancelledPayloadSchema;
     readonly 'task.approval_resolved': typeof TaskApprovalResolvedPayloadSchema;
-    readonly 'task.steer_sealed': typeof TaskSteerSealedPayloadSchema;
-    readonly 'task.complete_sealed': typeof TaskCompleteSealedPayloadSchema;
-    readonly 'task.fail_sealed': typeof TaskFailSealedPayloadSchema;
-    readonly 'task.decline_sealed': typeof TaskDeclineSealedPayloadSchema;
-    readonly 'task.cancelled_sealed': typeof TaskCancelledSealedPayloadSchema;
-    readonly 'task.progress_sealed': typeof TaskProgressSealedPayloadSchema;
-    readonly 'task.artifact_sealed': typeof TaskArtifactSealedPayloadSchema;
-    readonly 'task.await_approval_sealed': typeof TaskAwaitApprovalSealedPayloadSchema;
-    readonly 'e2ee.key_package.available': typeof E2eeKeyPackageAvailablePayloadSchema;
+    readonly 'agent.egress.reliable': typeof AgentEgressReliablePayloadSchema;
+    readonly 'agent.message.draft': typeof AgentMessageDraftPayloadSchema;
+    readonly 'agent.message.publish': typeof AgentMessagePublishPayloadSchema;
+    readonly 'agent.content.receipt': typeof AgentContentReceiptPayloadSchema;
 };
 export type MessageType = keyof typeof MESSAGE_PAYLOAD_SCHEMAS;
 export declare const MESSAGE_TYPES: MessageType[];
@@ -2992,18 +2710,17 @@ export declare const MESSAGE_TYPES: MessageType[];
  * (`envelope.ts`) to decide which branches require envelope `seq` (M1
  * redelivery cursor).
  */
-export declare const SERVER_TO_DAEMON_TYPES: readonly ["conn.ack", "task.offer", "task.offer_with_toolsets", "task.offer_for_agent", "task.offer_for_agent_with_egress", "task.offer_for_agent_with_egress_fresh", "task.offer_prepared", "agent.egress.ack", "agent.message.disposition", "agent.content.read", "agent.home.projection", "agent.input.preparation", "provider.provisioning.available", "agent.memory.intent.available", "task.approve", "task.reject", "task.cancel", "task.steer", "task.offer_sealed", "task.offer_with_toolsets_sealed", "task.offer_for_agent_sealed", "task.offer_for_agent_with_egress_sealed", "task.offer_for_agent_with_egress_fresh_sealed", "task.steer_sealed", "e2ee.key_package.available"];
+export declare const SERVER_TO_DAEMON_TYPES: readonly ["task.offer", "agent.egress.ack", "agent.message.disposition", "agent.content.read", "agent.home.projection", "agent.input.preparation", "provider.provisioning.available", "agent.memory.intent.available", "task.approve", "task.reject", "task.cancel", "task.steer", "e2ee.key_package.available"];
 /**
  * Message types the daemon sends to the server — the flip side of
- * {@link SERVER_TO_DAEMON_TYPES}. `conn.hello` is deliberately excluded: it's
- * only ever valid as the first frame of a WS handshake (`ws-server.ts`), not
- * as ongoing inbound traffic through `ConnectionHub.handleInbound`.
+ * {@link SERVER_TO_DAEMON_TYPES}. `conn.hello` is deliberately excluded: the
+ * inbound gate handles a bearer-authenticated `conn.hello` as a capability
+ * snapshot on its own, before the type-allow check.
  *
- * Used by `handleInbound` (`@byok-sdk/server`'s `hub.ts`) as the type-allow gate
- * for every inbound envelope, WS and `POST /byok/messages` alike (finding
+ * Used by `handleInboundEnvelope` (`@byok-sdk/cloud`'s `inbound.ts`) as the
+ * type-allow gate for every inbound `POST /byok/messages` envelope (finding
  * P2): a `type` outside this set — a server -> daemon type arriving inbound,
  * or anything unrecognized — is rejected before it's dispatched to any
  * handler or counted `accepted` on the `/byok/messages` wire.
  */
-export declare const DAEMON_TO_SERVER_TYPES: readonly ["task.claim", "task.started", "task.decline", "task.progress", "task.artifact", "task.await_approval", "task.complete", "task.fail", "task.cancelled", "task.approval_resolved", "agent.egress.reliable", "agent.message.draft", "agent.message.publish", "agent.content.receipt", "task.complete_sealed", "task.fail_sealed", "task.decline_sealed", "task.cancelled_sealed", "task.progress_sealed", "task.artifact_sealed", "task.await_approval_sealed"];
-export {};
+export declare const DAEMON_TO_SERVER_TYPES: readonly ["task.claim", "task.started", "task.decline", "task.progress", "task.artifact", "task.await_approval", "task.complete", "task.fail", "task.cancelled", "task.approval_resolved", "agent.egress.reliable", "agent.message.draft", "agent.message.publish", "agent.content.receipt"];