@byok-sdk/protocol 0.18.0 → 0.20.0

package/dist/messages.d.ts

@@ -651,6 +651,94 @@ export declare const TaskOfferForAgentWithEgressFreshPayloadSchema: z.ZodObject<
     }, 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: an older daemon skips a message type it does not know
+ * (`UnknownMessageTypeError`, and the long-poll transport skips that entry
+ * whole), whereas it would legally STRIP an unknown optional field and run the
+ * task as an ordinary instruction offer — compiling a request of its own
+ * against tokens that were already counted for a different one.
+ *
+ * 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<{
+    policy: z.ZodObject<{
+        mode: z.ZodEnum<{
+            auto: "auto";
+            confirm: "confirm";
+            plan: "plan";
+            readonly: "readonly";
+        }>;
+        allowTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        denyTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        workspaceRoot: z.ZodOptional<z.ZodString>;
+        network: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    agentRef: z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
+    }, z.core.$strict>;
+    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;
+    }, z.core.$strict>], "mode">>;
+    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>;
+}, z.core.$strict>;
+export type TaskOfferPreparedPayload = z.infer<typeof TaskOfferPreparedPayloadSchema>;
 /** Daemon -> cloud: one durable reliable-lane item after local sanitization. */
 export declare const AgentEgressReliablePayloadSchema: z.ZodObject<{
     agentRef: z.ZodObject<{
@@ -880,6 +968,153 @@ export declare const AgentHomeProjectionPayloadSchema: z.ZodObject<{
     projection: z.ZodType<import("./agent-home-projection").AgentHomeProjectionValue, unknown, z.core.$ZodTypeInternals<import("./agent-home-projection").AgentHomeProjectionValue, unknown>>;
 }, z.core.$strict>;
 export type AgentHomeProjectionPayload = z.infer<typeof AgentHomeProjectionPayloadSchema>;
+/**
+ * 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: a daemon that predates
+ * this contract SKIPS an unknown type outright (`parseMessage` ->
+ * `UnknownMessageTypeError`), whereas it would legally STRIP an unknown
+ * optional field and then answer as though a preparation it never performed
+ * had somehow been handled.
+ *
+ * What is deliberately NOT here (§17 B): `tools`, `toolExecutors`, runtime or
+ * compiler identity, `tenantId` and `deviceId`. The first three are local
+ * observations; the last two come from the device's own authenticated record,
+ * never from the payload — a sender that could name them could redirect a
+ * preparation's binding to a device it does not own.
+ *
+ * `deadlineAt` may only ever be TIGHTENED locally: the device clamps to
+ * `min(deadlineAt - now, limits.preparationDeadlineMs)`, so a generous Host
+ * deadline cannot enlarge a configured local bound.
+ *
+ * `permissionMode` is DECLARED by the requester and validated by the device;
+ * the device never infers it. A preparation counts tokens for one concrete
+ * tool manifest, and that manifest is the policy-filtered set for exactly one
+ * mode (`mcp/projection.ts`'s `filterMcpObservationForPolicy`) — so a
+ * preparation whose mode is unstated is a count of a manifest nobody named.
+ * The device applies the declared mode to its own observation and records it
+ * in the artifact binding; it is not a grant, and it authorizes nothing.
+ */
+export declare const AgentInputPreparationPayloadSchema: z.ZodObject<{
+    requestId: z.ZodUUID;
+    agentRef: z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
+    }, z.core.$strict>;
+    profileId: z.ZodString;
+    policyRevision: z.ZodString;
+    source: z.ZodObject<{
+        revision: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>;
+    selection: z.ZodObject<{
+        model: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            api: z.ZodLiteral<"openai-completions">;
+            provider: z.ZodString;
+            baseUrl: z.ZodString;
+            reasoning: z.ZodBoolean;
+            input: z.ZodArray<z.ZodEnum<{
+                image: "image";
+                text: "text";
+            }>>;
+            cost: z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheWrite: z.ZodNumber;
+            }, z.core.$strict>;
+            contextWindow: z.ZodNumber;
+            maxTokens: z.ZodNumber;
+            thinkingLevelMap: z.ZodOptional<z.ZodObject<{
+                off: z.ZodNullable<z.ZodString>;
+                minimal: z.ZodNullable<z.ZodString>;
+                low: z.ZodNullable<z.ZodString>;
+                medium: z.ZodNullable<z.ZodString>;
+                high: z.ZodNullable<z.ZodString>;
+                xhigh: z.ZodNullable<z.ZodString>;
+                max: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            compat: z.ZodOptional<z.ZodObject<{
+                supportsStore: z.ZodOptional<z.ZodBoolean>;
+                supportsDeveloperRole: z.ZodOptional<z.ZodBoolean>;
+                supportsReasoningEffort: z.ZodOptional<z.ZodBoolean>;
+                supportsUsageInStreaming: z.ZodOptional<z.ZodBoolean>;
+                maxTokensField: z.ZodOptional<z.ZodEnum<{
+                    max_completion_tokens: "max_completion_tokens";
+                    max_tokens: "max_tokens";
+                }>>;
+                thinkingFormat: z.ZodOptional<z.ZodEnum<{
+                    "ant-ling": "ant-ling";
+                    baseten: "baseten";
+                    "chat-template": "chat-template";
+                    deepseek: "deepseek";
+                    openai: "openai";
+                    openrouter: "openrouter";
+                    qwen: "qwen";
+                    "qwen-chat-template": "qwen-chat-template";
+                    "string-thinking": "string-thinking";
+                    together: "together";
+                    zai: "zai";
+                }>>;
+                zaiToolStream: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        options: z.ZodObject<{
+            cacheRetention: z.ZodEnum<{
+                long: "long";
+                none: "none";
+                short: "short";
+            }>;
+            maxTokens: z.ZodNumber;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            toolChoice: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                none: "none";
+            }>>;
+            reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                xhigh: "xhigh";
+            }>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    deadlineAt: z.ZodISODateTime;
+    context: z.ZodUnion<readonly [z.ZodObject<{
+        inline: z.ZodString;
+    }, z.core.$strict>, 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>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>]>;
+    requiredToolsets: z.ZodArray<z.ZodString>;
+    permissionMode: z.ZodEnum<{
+        auto: "auto";
+        confirm: "confirm";
+        plan: "plan";
+        readonly: "readonly";
+    }>;
+    accountingPolicyRef: z.ZodOptional<z.ZodObject<{
+        revision: z.ZodString;
+        ruledRuntime: z.ZodString;
+        ruledTarget: z.ZodObject<{
+            endpoint: z.ZodString;
+            modelId: z.ZodString;
+        }, z.core.$strict>;
+        ruledResidualKeys: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AgentInputPreparationPayload = z.infer<typeof AgentInputPreparationPayloadSchema>;
 /**
  * server -> daemon: approve a pending `task.await_approval` request.
  *
@@ -1274,6 +1509,34 @@ export declare const TerminalInferenceUsageSchema: z.ZodObject<{
     reportedAt: z.ZodISODateTime;
 }, z.core.$strip>;
 export type TerminalInferenceUsage = z.infer<typeof TerminalInferenceUsageSchema>;
+/**
+ * The prepared-only terminal observation: what the runtime reported about the
+ * provider calls of ONE prepared Execution, bound to the frozen request it
+ * launched.
+ *
+ * - `requestDigest` — the frozen artifact's own request digest
+ *   (`InputPreparationArtifactSummarySchema.requestDigest`), so the Host
+ *   compares these numbers against exactly the D whose `requestBytes` it
+ *   ruled on.
+ * - `initialPromptTokens` — the prompt tokens of the FIRST provider call. It
+ *   is the only call whose request is D; every later call is an ordinary tool
+ *   continuation. Prompt tokens are the provider's whole prompt, cache reads
+ *   and writes included.
+ * - `maxPromptTokens` — the largest prompt of any provider call of the
+ *   Execution, so `maxPromptTokens >= initialPromptTokens`.
+ *
+ * A separate field, deliberately NOT {@link TerminalInferenceUsageSchema}:
+ * that one is telemetry and never task-state authority, while this one is the
+ * evidence a Host checks its own budget ruling against. The device performs no
+ * budget arithmetic over it. Strict, like every other control shape: an
+ * unrecognized field is rejected, not stripped.
+ */
+export declare const TerminalPreparedObservationSchema: z.ZodObject<{
+    requestDigest: z.ZodString;
+    initialPromptTokens: z.ZodNumber;
+    maxPromptTokens: z.ZodNumber;
+}, z.core.$strict>;
+export type TerminalPreparedObservation = z.infer<typeof TerminalPreparedObservationSchema>;
 /**
  * daemon -> server: task finished successfully.
  *
@@ -1326,6 +1589,11 @@ 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;
@@ -1355,6 +1623,11 @@ 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;
@@ -1868,6 +2141,72 @@ declare const TASK_OFFER_PAYLOAD_SCHEMAS: {
             maxBytes: z.ZodNumber;
         }, z.core.$strict>>;
     }, z.core.$strict>;
+    readonly 'task.offer_prepared': z.ZodObject<{
+        policy: z.ZodObject<{
+            mode: z.ZodEnum<{
+                auto: "auto";
+                confirm: "confirm";
+                plan: "plan";
+                readonly: "readonly";
+            }>;
+            allowTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            denyTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            workspaceRoot: z.ZodOptional<z.ZodString>;
+            network: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        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;
+        }, z.core.$strict>], "mode">>;
+        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>;
+    }, z.core.$strict>;
 };
 export type TaskOfferType = keyof typeof TASK_OFFER_PAYLOAD_SCHEMAS;
 export declare const TASK_OFFER_TYPES: readonly TaskOfferType[];
@@ -2289,6 +2628,72 @@ export declare const MESSAGE_PAYLOAD_SCHEMAS: {
             maxBytes: z.ZodNumber;
         }, z.core.$strict>>;
     }, z.core.$strict>;
+    readonly 'task.offer_prepared': z.ZodObject<{
+        policy: z.ZodObject<{
+            mode: z.ZodEnum<{
+                auto: "auto";
+                confirm: "confirm";
+                plan: "plan";
+                readonly: "readonly";
+            }>;
+            allowTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            denyTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            workspaceRoot: z.ZodOptional<z.ZodString>;
+            network: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        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;
+        }, z.core.$strict>], "mode">>;
+        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>;
+    }, z.core.$strict>;
     readonly 'conn.hello': z.ZodObject<{
         protocolVersions: z.ZodArray<z.ZodNumber>;
         capabilities: z.ZodArray<z.ZodString>;
@@ -2540,6 +2945,124 @@ export declare const MESSAGE_PAYLOAD_SCHEMAS: {
         projectionHash: z.ZodString;
         projection: z.ZodType<import("./agent-home-projection").AgentHomeProjectionValue, unknown, z.core.$ZodTypeInternals<import("./agent-home-projection").AgentHomeProjectionValue, unknown>>;
     }, z.core.$strict>;
+    readonly 'agent.input.preparation': z.ZodObject<{
+        requestId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        profileId: z.ZodString;
+        policyRevision: z.ZodString;
+        source: z.ZodObject<{
+            revision: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        selection: z.ZodObject<{
+            model: z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                api: z.ZodLiteral<"openai-completions">;
+                provider: z.ZodString;
+                baseUrl: z.ZodString;
+                reasoning: z.ZodBoolean;
+                input: z.ZodArray<z.ZodEnum<{
+                    image: "image";
+                    text: "text";
+                }>>;
+                cost: z.ZodObject<{
+                    input: z.ZodNumber;
+                    output: z.ZodNumber;
+                    cacheRead: z.ZodNumber;
+                    cacheWrite: z.ZodNumber;
+                }, z.core.$strict>;
+                contextWindow: z.ZodNumber;
+                maxTokens: z.ZodNumber;
+                thinkingLevelMap: z.ZodOptional<z.ZodObject<{
+                    off: z.ZodNullable<z.ZodString>;
+                    minimal: z.ZodNullable<z.ZodString>;
+                    low: z.ZodNullable<z.ZodString>;
+                    medium: z.ZodNullable<z.ZodString>;
+                    high: z.ZodNullable<z.ZodString>;
+                    xhigh: z.ZodNullable<z.ZodString>;
+                    max: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                compat: z.ZodOptional<z.ZodObject<{
+                    supportsStore: z.ZodOptional<z.ZodBoolean>;
+                    supportsDeveloperRole: z.ZodOptional<z.ZodBoolean>;
+                    supportsReasoningEffort: z.ZodOptional<z.ZodBoolean>;
+                    supportsUsageInStreaming: z.ZodOptional<z.ZodBoolean>;
+                    maxTokensField: z.ZodOptional<z.ZodEnum<{
+                        max_completion_tokens: "max_completion_tokens";
+                        max_tokens: "max_tokens";
+                    }>>;
+                    thinkingFormat: z.ZodOptional<z.ZodEnum<{
+                        "ant-ling": "ant-ling";
+                        baseten: "baseten";
+                        "chat-template": "chat-template";
+                        deepseek: "deepseek";
+                        openai: "openai";
+                        openrouter: "openrouter";
+                        qwen: "qwen";
+                        "qwen-chat-template": "qwen-chat-template";
+                        "string-thinking": "string-thinking";
+                        together: "together";
+                        zai: "zai";
+                    }>>;
+                    zaiToolStream: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            options: z.ZodObject<{
+                cacheRetention: z.ZodEnum<{
+                    long: "long";
+                    none: "none";
+                    short: "short";
+                }>;
+                maxTokens: z.ZodNumber;
+                temperature: z.ZodOptional<z.ZodNumber>;
+                toolChoice: z.ZodOptional<z.ZodEnum<{
+                    auto: "auto";
+                    none: "none";
+                }>>;
+                reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    xhigh: "xhigh";
+                }>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        deadlineAt: z.ZodISODateTime;
+        context: z.ZodUnion<readonly [z.ZodObject<{
+            inline: z.ZodString;
+        }, z.core.$strict>, 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>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>]>;
+        requiredToolsets: z.ZodArray<z.ZodString>;
+        permissionMode: z.ZodEnum<{
+            auto: "auto";
+            confirm: "confirm";
+            plan: "plan";
+            readonly: "readonly";
+        }>;
+        accountingPolicyRef: z.ZodOptional<z.ZodObject<{
+            revision: z.ZodString;
+            ruledRuntime: z.ZodString;
+            ruledTarget: z.ZodObject<{
+                endpoint: z.ZodString;
+                modelId: z.ZodString;
+            }, z.core.$strict>;
+            ruledResidualKeys: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
     readonly 'task.approve': z.ZodObject<{
         approvalId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -2698,6 +3221,11 @@ export declare const MESSAGE_PAYLOAD_SCHEMAS: {
             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;
@@ -2725,6 +3253,11 @@ export declare const MESSAGE_PAYLOAD_SCHEMAS: {
             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;
@@ -2771,7 +3304,7 @@ 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", "agent.egress.ack", "agent.message.disposition", "agent.content.read", "agent.home.projection", "task.approve", "task.reject", "task.cancel", "task.steer"];
+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", "task.approve", "task.reject", "task.cancel", "task.steer"];
 /**
  * Message types the daemon sends to the server — the flip side of
  * {@link SERVER_TO_DAEMON_TYPES}. `conn.hello` is deliberately excluded: it's

package/dist/task-assertion.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The device-level half of the task lane's capability gate (contract §8.1).
+ *
+ * Contract §8.1 fixes ONE name, `host-mcp-task-context`, carried on two
+ * independent channels that must both be in place before a host may route a
+ * tool invocation through the task lane:
+ *
+ * 1. **Deployment level** — the ADR-010 `CapabilityDeclarationSchema` a
+ *    deployment serves (`@byok-sdk/cloud`'s `CLOUD_CAPABILITIES`). §8.2(1)
+ *    governs it: a deployment declares the capability only once it is
+ *    completely implemented.
+ * 2. **Device level** — this constant: a `conn.hello` capability string a host
+ *    consumes through `declaresCapabilities`. §8.3 governs it: a device whose
+ *    build cannot serve the lane simply does not advertise it, and the host
+ *    answers `unavailable` rather than reaching for the device assertion the
+ *    task lane does not accept.
+ *
+ * It lives in `@byok-sdk/protocol` for the same reason every other daemon
+ * capability flag does: this package is the wire vocabulary both sides compile
+ * against, and a name spelled twice is a name that can drift. It is registered
+ * in `CAPABILITY_FLAGS` (`./version`), which is what makes it a value a daemon
+ * can actually send.
+ *
+ * The spelling satisfies `@byok-sdk/core`'s `CAPABILITY_NAME_PATTERN`
+ * (`/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/`) on purpose: the deployment-level channel
+ * carries this exact literal, so a name legal in only one of the two channels
+ * would leave them naming different things.
+ */
+/** Contract §8.1's capability gate for `byok-task-assertion-v1` tool authority. */
+export declare const HOST_MCP_TASK_CONTEXT_CAPABILITY: 'host-mcp-task-context';

package/dist/version.d.ts

@@ -107,5 +107,5 @@ export declare const STRICT_AGENT_ONLY_CAPABILITY: 'strict-agent-only';
  * cannot accidentally execute the instruction without the required tools.
  */
 export declare const CUSTOM_HARNESS_CAPABILITY: 'custom-harness';
-export declare const CAPABILITY_FLAGS: readonly ['steer', 'blob-upload', 'interactive-approval', 'approval_resolved', 'approval-targeting', 'result-document', 'dispatch-selection', "provider-profile-binding", 'toolset-selection', 'agent-home-contract', "strict-agent-only", "agent-egress-policy", "agent-egress-reliable-ack", "agent-message-egress", "agent-egress-fresh-session", "agent-content-workspace-read", "agent-content-transcript-read", "agent-content-artifact-read", "agent-home-projection", "terminal-projection-selection", "custom-harness", "mailbox-read-ahead"];
+export declare const CAPABILITY_FLAGS: readonly ['steer', 'blob-upload', 'interactive-approval', 'approval_resolved', 'approval-targeting', 'result-document', 'dispatch-selection', "provider-profile-binding", 'toolset-selection', 'agent-home-contract', "strict-agent-only", "agent-egress-policy", "agent-egress-reliable-ack", "agent-message-egress", "agent-egress-fresh-session", "agent-content-workspace-read", "agent-content-transcript-read", "agent-content-artifact-read", "agent-home-projection", "agent-input-preparation-v5", "terminal-projection-selection", "host-mcp-task-context", "custom-harness", "mailbox-read-ahead"];
 export type CapabilityFlag = (typeof CAPABILITY_FLAGS)[number];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byok-sdk/protocol",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "BYOK SDK wire protocol: envelope schema, message types, and codec helpers",
   "type": "module",
   "license": "MIT",