@byok-sdk/cloud 0.18.0 → 0.19.0

package/dist/index.js

@@ -1,7 +1,7 @@
-import { BOARD_STATUSES, CapabilityDeclarationSchema, NONCE_SIGNING_DOMAIN, hasCapability, isTenantId, tenantId, principalTenant, parseDeviceProofEnvelope, deviceProofSigningInput, contentHash, parseCapabilityDeclaration, ByokCoreError, tenantKey, PRESENCE_LEVELS, createInMemoryCoreStores, authenticateDeviceAssertion, assertCapability, isCoreConflictError, isCoreError, DEVICE_PROOF_HEADER, TRUTH_RECORD_KINDS, STORAGE_ERROR_CODES, STORAGE_ERROR_HTTP_STATUS } from '@byok-sdk/core';
+import { BOARD_STATUSES, CapabilityDeclarationSchema, NONCE_SIGNING_DOMAIN, hasCapability, isTenantId, tenantId, principalTenant, parseDeviceProofEnvelope, deviceProofSigningInput, contentHash, parseCapabilityDeclaration, ByokCoreError, tenantKey, PRESENCE_LEVELS, createInMemoryCoreStores, authenticateDeviceAssertion, authenticateTaskAssertion, assertCapability, isCoreConflictError, isCoreError, DEVICE_PROOF_HEADER, TRUTH_RECORD_KINDS, STORAGE_ERROR_CODES, STORAGE_ERROR_HTTP_STATUS } from '@byok-sdk/core';
 export { DEVICE_PROOF_HEADER, NONCE_SIGNING_DOMAIN, isTenantId, tenantId } from '@byok-sdk/core';
 import { z } from 'zod';
-import { AgentEventOrUnknownSchema, AgentMessageServerContextSchema, AgentMessageEgressRequirementSchema, AgentRefSchema, TaskOfferForAgentWithEgressFreshPayloadSchema, PROTOCOL_VERSION, DAEMON_TO_SERVER_TYPES, AGENT_EGRESS_RELIABLE_ACK_CAPABILITY, encodeEnvelope, decodeEnvelope, AgentHomeProjectionCompletionRequestSchema, BYOK_PAIR_PATH, BYOK_CHALLENGE_PATH, BYOK_TOKEN_PATH, BYOK_CAPABILITIES_PATH, BYOK_AGENT_MEMORY_PROJECTIONS_PATH, BYOK_EVENTS_PATH, BYOK_MESSAGES_PATH, BYOK_AGENT_HOME_PROJECTION_COMPLETION_ROUTE, BYOK_BOARD_PATH, BYOK_BOARD_CLAIM_ROUTE, BYOK_BOARD_UNCLAIM_ROUTE, BYOK_BOARD_STATUS_ROUTE, BYOK_BOARD_STREAM_PATH, BYOK_PRESENCE_PATH, BYOK_ACTIVITY_PATH, BYOK_RECORDS_PATH, BYOK_RECORD_ROUTE, BYOK_SKILL_PACKS_PATH, BYOK_SKILL_PACK_FILE_ROUTE, BYOK_BLOBS_PATH, BYOK_BLOB_FINALIZE_ROUTE, BYOK_BLOB_URL_ROUTE, BYOK_BLOB_CONTENT_ROUTE, AgentMessagePublishPayloadSchema, isTaskOfferType, MESSAGE_PAYLOAD_SCHEMAS, createEnvelope, AgentHomeProjectionPayloadSchema, AgentContentReadPayloadSchema, AGENT_EGRESS_POLICY_CAPABILITY, AGENT_MESSAGE_EGRESS_CAPABILITY, TERMINAL_PROJECTION_SELECTION_CAPABILITY, TaskOfferForAgentWithEgressPayloadSchema, TaskOfferForAgentPayloadSchema, AgentMemoryProjectionMutationSchema, AgentMemoryProjectionReceiptSchema, AGENT_MEMORY_PROJECTION_MAX_ORDERING_VALUE, AgentMemoryProjectionEraseResultSchema, HarnessIdSchema, STRICT_AGENT_ONLY_CAPABILITY, AGENT_CONTENT_ARTIFACT_READ_CAPABILITY, AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY, AGENT_CONTENT_WORKSPACE_READ_CAPABILITY, AGENT_HOME_PROJECTION_CAPABILITY, AGENT_EGRESS_FRESH_SESSION_CAPABILITY, PairRequestSchema, PairResponseSchema, ChallengeRequestSchema, TokenRequestSchema, AgentMemoryProjectionCommitRequestSchema, agentMemoryProjectionBase64UrlByteLength, MAILBOX_READ_AHEAD_MAX_SEQS, MAILBOX_READ_AHEAD_CAPABILITY, MessagesSendRequestSchema, PresencePublishRequestSchema, CreateBlobRequestSchema, byokBlobContentPath, AgentMessageDispositionPayloadSchema, AgentEgressAckPayloadSchema, AgentContentReceiptPayloadSchema } from '@byok-sdk/protocol';
+import { AgentEventOrUnknownSchema, AgentMessageServerContextSchema, AgentMessageEgressRequirementSchema, AgentRefSchema, TaskOfferForAgentWithEgressFreshPayloadSchema, PROTOCOL_VERSION, DAEMON_TO_SERVER_TYPES, AGENT_EGRESS_RELIABLE_ACK_CAPABILITY, encodeEnvelope, decodeEnvelope, AgentHomeProjectionCompletionRequestSchema, AgentInputPreparationPayloadSchema, InputPreparationCompletionRequestSchema, BYOK_PAIR_PATH, BYOK_CHALLENGE_PATH, BYOK_TOKEN_PATH, BYOK_CAPABILITIES_PATH, BYOK_AGENT_MEMORY_PROJECTIONS_PATH, BYOK_EVENTS_PATH, BYOK_MESSAGES_PATH, BYOK_AGENT_HOME_PROJECTION_COMPLETION_ROUTE, BYOK_INPUT_PREPARATION_COMPLETION_ROUTE, BYOK_INPUT_PREPARATION_STATUS_ROUTE, BYOK_BOARD_PATH, BYOK_BOARD_CLAIM_ROUTE, BYOK_BOARD_UNCLAIM_ROUTE, BYOK_BOARD_STATUS_ROUTE, BYOK_BOARD_STREAM_PATH, BYOK_PRESENCE_PATH, BYOK_ACTIVITY_PATH, BYOK_RECORDS_PATH, BYOK_RECORD_ROUTE, BYOK_SKILL_PACKS_PATH, BYOK_SKILL_PACK_FILE_ROUTE, BYOK_BLOBS_PATH, BYOK_BLOB_FINALIZE_ROUTE, BYOK_BLOB_URL_ROUTE, BYOK_BLOB_CONTENT_ROUTE, AgentMessagePublishPayloadSchema, isTaskOfferType, MESSAGE_PAYLOAD_SCHEMAS, createEnvelope, AgentHomeProjectionPayloadSchema, AgentContentReadPayloadSchema, AGENT_EGRESS_POLICY_CAPABILITY, AGENT_MESSAGE_EGRESS_CAPABILITY, TERMINAL_PROJECTION_SELECTION_CAPABILITY, TaskOfferForAgentWithEgressPayloadSchema, AGENT_INPUT_PREPARATION_CAPABILITY, TaskOfferPreparedPayloadSchema, TaskOfferForAgentPayloadSchema, AgentMemoryProjectionMutationSchema, AgentMemoryProjectionReceiptSchema, AGENT_MEMORY_PROJECTION_MAX_ORDERING_VALUE, AgentMemoryProjectionEraseResultSchema, HarnessIdSchema, STRICT_AGENT_ONLY_CAPABILITY, AGENT_CONTENT_ARTIFACT_READ_CAPABILITY, AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY, AGENT_CONTENT_WORKSPACE_READ_CAPABILITY, AGENT_HOME_PROJECTION_CAPABILITY, AGENT_EGRESS_FRESH_SESSION_CAPABILITY, PairRequestSchema, PairResponseSchema, ChallengeRequestSchema, TokenRequestSchema, AgentMemoryProjectionCommitRequestSchema, agentMemoryProjectionBase64UrlByteLength, MAILBOX_READ_AHEAD_MAX_SEQS, MAILBOX_READ_AHEAD_CAPABILITY, MessagesSendRequestSchema, InputPreparationStatusQuerySchema, PresencePublishRequestSchema, CreateBlobRequestSchema, byokBlobContentPath, AgentMessageDispositionPayloadSchema, AgentEgressAckPayloadSchema, AgentContentReceiptPayloadSchema } from '@byok-sdk/protocol';
 import { Hono } from 'hono';
 
 // src/index.ts
@@ -91,6 +91,16 @@ var CLOUD_ERROR_CODES = {
   agent_home_projection_receipt_mismatch: "agent_home_projection_receipt_mismatch",
   /** A receipt-store row at the projection namespace violated the frozen projection schema. */
   agent_home_projection_receipt_invalid: "agent_home_projection_receipt_invalid",
+  /** A remote input-preparation request id already names a different immutable desired request. */
+  input_preparation_request_conflict: "input_preparation_request_conflict",
+  /** A device completion did not identify a stored desired request for this exact device. */
+  input_preparation_request_not_found: "input_preparation_request_not_found",
+  /** A device completion changed the first durable terminal outcome. */
+  input_preparation_completion_conflict: "input_preparation_completion_conflict",
+  /** A completion did not exactly echo its immutable desired request/Agent/policy binding. */
+  input_preparation_receipt_mismatch: "input_preparation_receipt_mismatch",
+  /** A receipt-store row at the preparation namespace violated the frozen schema. */
+  input_preparation_receipt_invalid: "input_preparation_receipt_invalid",
   /** A hosted Agent-memory mutation did not match the durable task/device/AgentRef binding. */
   agent_memory_projection_task_mismatch: "agent_memory_projection_task_mismatch",
   /** The embedder-owned grant/consent authority denied a hosted memory mutation. */
@@ -1196,7 +1206,43 @@ var CLOUD_CAPABILITIES = {
    */
   skillPacks: "skills.pack",
   /** Optional, one-way redacted Agent-memory snapshot mutation route. */
-  agentMemoryProjection: "agent.memory.projection"
+  agentMemoryProjection: "agent.memory.projection",
+  /**
+   * Remote authenticated runtime input preparation (C07 G4): the host control
+   * plane enqueues `agent.input.preparation` and the device discharges it
+   * through the completion/status pair.
+   *
+   * Informational like `host-mcp-task-context`, not route-gating. Both routes
+   * mount unconditionally (`cloud.ts`) because the completion route is the
+   * DEVICE's only way to discharge a mailbox row this same deployment handed
+   * it — withholding it would strand the device's redelivery cursor rather
+   * than degrade a feature. For the same reason the completion route asserts
+   * no DEVICE capability either: the device-level `agent-input-preparation`
+   * flag gates ADMISSION (`enqueueInputPreparation`) and nothing else, so an
+   * unconfigured device is refused a row instead of being handed one whose
+   * only honest answer — `input_preparation_unconfigured` — it could not then
+   * record. What declaring THIS capability promises is that this deployment's
+   * host side actually drives the lane, which is what a Host reads before
+   * calling `enqueueInputPreparation` instead of probing.
+   */
+  inputPreparation: "agent.input.preparation",
+  /**
+   * Contract §8.1's capability gate for task-scoped tool authority
+   * (`byok-task-assertion-v1`), deployment-level channel.
+   *
+   * The SAME literal name `@byok-sdk/protocol`'s
+   * `HOST_MCP_TASK_CONTEXT_CAPABILITY` carries on the device-level channel —
+   * §8.1 requires both to be in place, and a name spelled differently in the
+   * two would make "both" unverifiable.
+   *
+   * Unlike its siblings above this capability mounts no route in this package:
+   * what a deployment promises by declaring it is that its host side actually
+   * VERIFIES task assertions (`authenticateHostedTaskAssertion` plus the frozen
+   * offer check that only the host can make). That is why it is default-off
+   * below and not derivable from anything this package can inspect — §8.2(1):
+   * the capability is declared only once it is completely implemented.
+   */
+  hostMcpTaskContext: "host-mcp-task-context"
 };
 var CapabilitiesResponseSchema = CapabilityDeclarationSchema;
 function fullCapabilityDeclaration(version = 1, options = {}) {
@@ -1209,6 +1255,9 @@ function fullCapabilityDeclaration(version = 1, options = {}) {
       if (capability === CLOUD_CAPABILITIES.agentMemoryProjection) {
         return options.includeAgentMemoryProjection === true;
       }
+      if (capability === CLOUD_CAPABILITIES.hostMcpTaskContext) {
+        return options.includeHostMcpTaskContext === true;
+      }
       return true;
     })
   };
@@ -1713,15 +1762,13 @@ function eventsHandler(deps) {
         if (page.messages.length === 0) break;
         const decoded = page.messages.map((message) => decodeEnvelope(message.body));
         const offeredTaskIds = decoded.flatMap(
-          (event) => (event.type === "task.offer" || event.type === "task.offer_with_toolsets" || event.type === "task.offer_for_agent" || event.type === "task.offer_for_agent_with_egress" || event.type === "task.offer_for_agent_with_egress_fresh") && event.task_id !== void 0 ? [event.task_id] : []
+          (event) => isTaskOfferType(event.type) && event.task_id !== void 0 ? [event.task_id] : []
         );
         const attemptsByTaskId = Object.fromEntries(
           (await stores.tasks.getMany(offeredTaskIds)).map((attempt2) => [attempt2.taskId, attempt2])
         );
         const events = decoded.filter((event) => {
-          if (event.type !== "task.offer" && event.type !== "task.offer_with_toolsets" && event.type !== "task.offer_for_agent" && event.type !== "task.offer_for_agent_with_egress" && event.type !== "task.offer_for_agent_with_egress_fresh") {
-            return true;
-          }
+          if (!isTaskOfferType(event.type)) return true;
           return event.task_id === void 0 || attemptsByTaskId[event.task_id]?.cancellation === void 0;
         });
         if (events.length === 0 && page.hasMore) {
@@ -1824,6 +1871,63 @@ function agentHomeProjectionCompletionHandler(deps) {
     }
   };
 }
+function mapCloudError(c, error) {
+  if (isCloudError(error, "input_preparation_request_not_found")) {
+    return c.json({ error: error.code }, 404);
+  }
+  if (isCloudError(error, "input_preparation_receipt_mismatch") || isCloudError(error, "input_preparation_receipt_invalid")) {
+    return c.json({ error: error.code }, 422);
+  }
+  if (isCloudError(error, "input_preparation_request_conflict") || isCloudError(error, "input_preparation_completion_conflict")) {
+    return c.json({ error: error.code }, 409);
+  }
+  throw error;
+}
+function inputPreparationCompletionHandler(deps) {
+  return async (c) => {
+    const authenticated = await authenticateDevice(c, deps);
+    if (authenticated === void 0) return c.json({ error: "unauthorized" }, 401);
+    const parsed = InputPreparationCompletionRequestSchema.safeParse(await readJsonBody(c));
+    if (!parsed.success) return c.json({ error: "invalid input preparation completion" }, 422);
+    const requestId = c.req.param("requestId");
+    if (requestId === void 0 || requestId !== parsed.data.requestId) {
+      return c.json({ error: "input_preparation_receipt_mismatch" }, 422);
+    }
+    try {
+      return c.json(
+        await deps.complete(authenticated.stores, authenticated.device.deviceId, parsed.data),
+        200
+      );
+    } catch (error) {
+      return mapCloudError(c, error);
+    }
+  };
+}
+function inputPreparationStatusHandler(deps) {
+  return async (c) => {
+    const authenticated = await authenticateDevice(c, deps);
+    if (authenticated === void 0) return c.json({ error: "unauthorized" }, 401);
+    const requestId = c.req.param("requestId");
+    if (requestId === void 0 || requestId.length === 0) {
+      return c.json({ error: "invalid input preparation request id" }, 422);
+    }
+    const query = InputPreparationStatusQuerySchema.safeParse({
+      agentId: c.req.query("agentId"),
+      profileRevision: c.req.query("profileRevision")
+    });
+    if (!query.success) return c.json({ error: "invalid input preparation status query" }, 422);
+    try {
+      const readback = await deps.status(authenticated.stores, authenticated.device.deviceId, {
+        requestId,
+        agentRef: { agentId: query.data.agentId, profileRevision: query.data.profileRevision }
+      });
+      if (readback === void 0) return c.json({ error: "input_preparation_request_not_found" }, 404);
+      return c.json(readback, 200);
+    } catch (error) {
+      return mapCloudError(c, error);
+    }
+  };
+}
 var DEFAULT_MAX_AGENT_MEMORY_PROJECTION_REQUEST_BYTES = 1 * 1024 * 1024;
 function agentMemoryProjectionHandler(deps) {
   return async (c) => {
@@ -2710,6 +2814,128 @@ async function recordAgentHomeProjectionCompletion(receipts, tenant, deviceId, r
     completedAt: storedCompletion.receipt.recordedAt
   };
 }
+function inputPreparationRequestKey(deviceId, agentRef, requestId) {
+  return agentReliabilityKey("agent-input-preparation-request", deviceId, agentRef, requestId);
+}
+function inputPreparationCompletionKey(deviceId, agentRef, requestId) {
+  return agentReliabilityKey("agent-input-preparation-completion", deviceId, agentRef, requestId);
+}
+function sameInputPreparationRequest(expected, actual) {
+  return canonicalRequestBody(expected) === canonicalRequestBody(actual);
+}
+function canonicalRequestBody(payload) {
+  return JSON.stringify(AgentInputPreparationPayloadSchema.parse(payload));
+}
+function receiptMatchesInputPreparation(request, receipt) {
+  return receipt.requestId === request.requestId && receipt.agentRef.agentId === request.agentRef.agentId && receipt.agentRef.profileRevision === request.agentRef.profileRevision && receipt.profileId === request.profileId && receipt.policyRevision === request.policyRevision;
+}
+function statusInputMatchesInputPreparation(request, input) {
+  return input.requestId === request.requestId && input.agentRef.agentId === request.agentRef.agentId && input.agentRef.profileRevision === request.agentRef.profileRevision;
+}
+function parseRequestBody2(body) {
+  try {
+    return AgentInputPreparationPayloadSchema.parse(JSON.parse(body));
+  } catch (error) {
+    throw new ByokCloudError(
+      "input_preparation_receipt_invalid",
+      "Stored input-preparation request is not a valid immutable desired fact.",
+      { cause: error }
+    );
+  }
+}
+function parseCompletionBody2(body) {
+  try {
+    return InputPreparationCompletionRequestSchema.parse(JSON.parse(body));
+  } catch (error) {
+    throw new ByokCloudError(
+      "input_preparation_receipt_invalid",
+      "Stored input-preparation completion is not a valid immutable receipt fact.",
+      { cause: error }
+    );
+  }
+}
+function terminalReadback(tenant, deviceId, request, completion, completedAt) {
+  const common = {
+    tenantId: tenant,
+    deviceId,
+    requestId: request.requestId,
+    agentRef: request.agentRef,
+    profileId: request.profileId,
+    policyRevision: request.policyRevision,
+    completedAt
+  };
+  return completion.outcome === "prepared" ? { ...common, status: "prepared", receipt: completion.receipt } : { ...common, status: "rejected", reason: completion.reason };
+}
+async function readInputPreparationStatus(receipts, tenant, deviceId, input) {
+  const storedRequest = await receipts.get(inputPreparationRequestKey(deviceId, input.agentRef, input.requestId));
+  if (storedRequest === void 0) return void 0;
+  const request = parseRequestBody2(storedRequest.body);
+  if (!statusInputMatchesInputPreparation(request, input)) {
+    throw new ByokCloudError(
+      "input_preparation_request_conflict",
+      `Input-preparation request ${input.requestId} does not match its immutable desired fact.`
+    );
+  }
+  const storedCompletion = await receipts.get(
+    inputPreparationCompletionKey(deviceId, request.agentRef, input.requestId)
+  );
+  if (storedCompletion === void 0) {
+    return {
+      tenantId: tenant,
+      deviceId,
+      requestId: request.requestId,
+      agentRef: request.agentRef,
+      profileId: request.profileId,
+      policyRevision: request.policyRevision,
+      status: "pending"
+    };
+  }
+  const completion = parseCompletionBody2(storedCompletion.body);
+  if (!receiptMatchesInputPreparation(request, completion)) {
+    throw new ByokCloudError(
+      "input_preparation_receipt_mismatch",
+      `Input-preparation completion ${input.requestId} does not match its immutable desired fact.`
+    );
+  }
+  return terminalReadback(tenant, deviceId, request, completion, storedCompletion.recordedAt);
+}
+async function recordInputPreparationCompletion(receipts, tenant, deviceId, receiptInput) {
+  const receipt = InputPreparationCompletionRequestSchema.parse(receiptInput);
+  const storedRequest = await receipts.get(
+    inputPreparationRequestKey(deviceId, receipt.agentRef, receipt.requestId)
+  );
+  if (storedRequest === void 0) {
+    throw new ByokCloudError(
+      "input_preparation_request_not_found",
+      `Input-preparation request ${receipt.requestId} was not found for this device.`
+    );
+  }
+  const request = parseRequestBody2(storedRequest.body);
+  if (!receiptMatchesInputPreparation(request, receipt)) {
+    throw new ByokCloudError(
+      "input_preparation_receipt_mismatch",
+      `Input-preparation completion ${receipt.requestId} does not exactly match its desired fact.`
+    );
+  }
+  const body = JSON.stringify(receipt);
+  const storedCompletion = await receipts.record({
+    key: inputPreparationCompletionKey(deviceId, request.agentRef, receipt.requestId),
+    body
+  });
+  if (!storedCompletion.created && storedCompletion.receipt.body !== body) {
+    throw new ByokCloudError(
+      "input_preparation_completion_conflict",
+      `Input-preparation request ${receipt.requestId} already has a different terminal completion.`
+    );
+  }
+  return terminalReadback(
+    tenant,
+    deviceId,
+    request,
+    parseCompletionBody2(storedCompletion.receipt.body),
+    storedCompletion.receipt.recordedAt
+  );
+}
 function readDeviceTerminalReceipt(taskId, receipt) {
   const envelope = decodeEnvelope(receipt.body);
   if (envelope.task_id !== taskId || envelope.type !== "task.complete" && envelope.type !== "task.fail" && envelope.type !== "task.decline" && envelope.type !== "task.cancelled") {
@@ -2886,6 +3112,19 @@ function createByokCloud(options) {
       complete: (stores, deviceId, receipt) => completeAgentHomeProjectionFromStores(stores, deviceId, receipt)
     })
   );
+  const inputPreparationRouteDeps = {
+    ...deviceRouteDeps,
+    complete: (stores, deviceId, receipt) => completeInputPreparationFromStores(stores, deviceId, receipt),
+    status: (stores, deviceId, input) => readInputPreparationStatus(stores.receipts, stores.tenant, deviceId, input)
+  };
+  registry.register(
+    { method: "PUT", path: BYOK_INPUT_PREPARATION_COMPLETION_ROUTE, class: "device" },
+    inputPreparationCompletionHandler(inputPreparationRouteDeps)
+  );
+  registry.register(
+    { method: "GET", path: BYOK_INPUT_PREPARATION_STATUS_ROUTE, class: "device" },
+    inputPreparationStatusHandler(inputPreparationRouteDeps)
+  );
   if (declares(declaration, CLOUD_CAPABILITIES.boardCoordination)) {
     const boardDeps = {
       ...deviceRouteDeps,
@@ -3396,6 +3635,25 @@ function createByokCloud(options) {
       receipt
     );
   }
+  async function getInputPreparationStatus(tenant, deviceId, input) {
+    return readInputPreparationStatus(
+      tenantStoresFor(controlPlane(tenant), root).receipts,
+      tenant,
+      deviceId,
+      input
+    );
+  }
+  async function completeInputPreparation(tenant, deviceId, receiptInput) {
+    return completeInputPreparationFromStores(
+      tenantStoresFor(controlPlane(tenant), root),
+      deviceId,
+      receiptInput
+    );
+  }
+  async function completeInputPreparationFromStores(stores, deviceId, receiptInput) {
+    const receipt = InputPreparationCompletionRequestSchema.parse(receiptInput);
+    return recordInputPreparationCompletion(stores.receipts, stores.tenant, deviceId, receipt);
+  }
   async function commitAgentMemoryProjectionFromStores(stores, deviceId, mutationInput, redactedBytes) {
     const mutation = AgentMemoryProjectionCommitRequestSchema.parse(mutationInput);
     const attempt = await stores.tasks.get(mutation.taskId);
@@ -3602,6 +3860,21 @@ function createByokCloud(options) {
         (taskId, seq, messageId) => createEnvelope("task.offer_for_agent", payload, { id: messageId, taskId, seq })
       );
     },
+    async enqueuePreparedOffer(tenant, deviceId, input) {
+      await assertAgentCapabilities(tenant, deviceId, [
+        AGENT_HOME_CONTRACT_CAPABILITY,
+        AGENT_INPUT_PREPARATION_CAPABILITY,
+        ...input.payload.terminalProjection === void 0 ? [] : [TERMINAL_PROJECTION_SELECTION_CAPABILITY]
+      ]);
+      const payload = TaskOfferPreparedPayloadSchema.parse(input.payload);
+      return enqueueTaskEnvelope(
+        tenant,
+        deviceId,
+        input.taskId,
+        payload.agentRef,
+        (taskId, seq, messageId) => createEnvelope("task.offer_prepared", payload, { id: messageId, taskId, seq })
+      );
+    },
     async enqueueAgentEgressOffer(tenant, deviceId, input) {
       await assertAgentCapabilities(tenant, deviceId, [
         AGENT_HOME_CONTRACT_CAPABILITY,
@@ -3730,6 +4003,58 @@ function createByokCloud(options) {
     },
     getAgentHomeProjectionStatus,
     completeAgentHomeProjection,
+    async enqueueInputPreparation(tenant, deviceId, input) {
+      const payload = AgentInputPreparationPayloadSchema.parse(input);
+      await assertAgentCapabilities(tenant, deviceId, [
+        AGENT_HOME_CONTRACT_CAPABILITY,
+        AGENT_INPUT_PREPARATION_CAPABILITY
+      ]);
+      const stores = tenantStoresFor(controlPlane(tenant), root);
+      const requestBody = JSON.stringify(payload);
+      const persisted = await stores.receipts.record({
+        key: inputPreparationRequestKey(deviceId, payload.agentRef, payload.requestId),
+        body: requestBody
+      });
+      const persistedPayload = AgentInputPreparationPayloadSchema.parse(JSON.parse(persisted.receipt.body));
+      if (!sameInputPreparationRequest(payload, persistedPayload)) {
+        throw new ByokCloudError(
+          "input_preparation_request_conflict",
+          `Input-preparation request ${payload.requestId} already exists with a different immutable desired body.`
+        );
+      }
+      const messageId = await agentControlEnvelopeId(
+        "byok:agent-input-preparation",
+        tenant,
+        deviceId,
+        payload.agentRef,
+        payload.requestId
+      );
+      const control = await enqueueAgentControlEnvelope(
+        tenant,
+        deviceId,
+        messageId,
+        (seq) => createEnvelope("agent.input.preparation", payload, { id: messageId, seq })
+      );
+      if (control.envelope.type !== "agent.input.preparation" || !sameInputPreparationRequest(payload, control.envelope.payload)) {
+        throw new ByokCloudError(
+          "input_preparation_request_conflict",
+          `Mailbox request ${payload.requestId} does not match its immutable input-preparation fact.`
+        );
+      }
+      const status = await getInputPreparationStatus(tenant, deviceId, {
+        requestId: payload.requestId,
+        agentRef: payload.agentRef
+      });
+      if (status === void 0) {
+        throw new ByokCloudError(
+          "input_preparation_receipt_invalid",
+          `Input-preparation request ${payload.requestId} disappeared after durable allocation.`
+        );
+      }
+      return { ...control, status };
+    },
+    getInputPreparationStatus,
+    completeInputPreparation,
     eraseAgentMemoryProjection,
     approveTask(tenant, taskId, opts) {
       return resolveApproval(tenant, taskId, "approve", opts);
@@ -5142,6 +5467,28 @@ function authenticateHostedDeviceAssertion(input, deps) {
     ...deps.maxLifetimeMs === void 0 ? {} : { maxLifetimeMs: deps.maxLifetimeMs }
   });
 }
+function authenticateHostedTaskAssertion(input, deps) {
+  return authenticateTaskAssertion(input, {
+    verifier: {
+      verify: ({ publicKey, signingInput, signature }) => deps.crypto.verifyEd25519(publicKey, signingInput, signature)
+    },
+    lookupDevice: async (deviceId) => {
+      const row = await deps.devices.resolveByDeviceId(deviceId);
+      if (row === void 0) return void 0;
+      return {
+        tenantId: row.tenantId,
+        productId: row.productId,
+        deviceId: row.deviceId,
+        publicKeyJwkX: row.devicePublicKey,
+        revoked: row.revoked
+      };
+    },
+    replay: deps.replay,
+    expected: deps.expected,
+    now: deps.clock.now(),
+    ...deps.maxLifetimeMs === void 0 ? {} : { maxLifetimeMs: deps.maxLifetimeMs }
+  });
+}
 var BoardFeedItemSchema = z.object({
   tenantId: z.string(),
   itemId: z.string(),
@@ -5325,6 +5672,6 @@ var CLOUD_PORT_INTERFACES = {
   rateLimiter: "InboundRateLimiter"
 };
 
-export { ACCESS_TOKEN_TTL_SECONDS, AGENT_HOME_CONTRACT_CAPABILITY, APPROVAL_SUMMARY_MAX_BYTES, ActivityAppendRequestSchema, AllowAllRateLimiter, ApprovalObservationSchema, ApprovalTimelineEventSchema, BLOB_READ_ERROR_CODES, BLOB_URL_TTL_MS, BoardFeedClient, BoardFeedRetryableError, BoardFeedStoppedError, ByokCloudError, CLOUD_CAPABILITIES, CLOUD_ERROR_CODES, CLOUD_PORT_INTERFACES, CLOUD_PORT_METHODS, CLOUD_STORE_NAMES, CapabilitiesResponseSchema, CloudRouteRegistry, DEDUP_RING_CAPACITY, DEFAULT_ACTIVITY_BOUNDS, DEFAULT_ACTIVITY_CAPACITY, DEFAULT_ACTIVITY_MAX_BYTES, DEFAULT_ACTIVITY_MAX_EVENTS, DEFAULT_ACTIVITY_TTL_MS, DEFAULT_APPROVAL_TIMELINE_CAPACITY, DEFAULT_APPROVAL_TIMELINE_TTL_MS, DEFAULT_BOARD_CHANNEL_MAX_BYTES, DEFAULT_BOARD_PAGE_LIMIT, DEFAULT_BOARD_STREAM_HEARTBEAT_INTERVAL_MS, DEFAULT_BOARD_STREAM_QUERY_INTERVAL_MS, DEFAULT_BOARD_STREAM_RECONCILIATION_INTERVAL_MS, DEFAULT_BOARD_TITLE_MAX_BYTES, DEFAULT_DEVICE_PROOF_CLOCK_SKEW_MS, DEFAULT_DEVICE_PROOF_MAX_LIFETIME_MS, DEFAULT_EVENTS_PAGE_LIMIT, DEFAULT_LONG_POLL_HOLD_MS, DEFAULT_LONG_POLL_INTERVAL_MS, DEFAULT_MAX_BLOB_SIZE_BYTES, DEFAULT_MAX_TRUTH_REQUEST_BYTES, DEFAULT_PRESENCE_DETAIL_MAX_BYTES, DEFAULT_PRESENCE_MINIMUM_INTERVAL_MS, DEFAULT_PRESENCE_TTL_MS, DEFAULT_SKILL_PACK_PAGE_LIMIT, DEVICE_IDENTITY_PROOF_KEY_EPOCH, DEVICE_IDENTITY_PROOF_KEY_ID, InMemoryActivityStore, InMemoryAgentEgressStore, InMemoryAgentMemoryProjectionAuthorizer, InMemoryAgentMemoryProjectionStore, InMemoryBlobContentProxy, InMemoryCloudBlobStore, InMemoryDeviceDirectory, InMemoryInboundDedupStore, InMemoryNonceStore, InMemoryPairingCodeStore, InMemoryProofRequestReceiptStore, InMemoryRequestReceiptStore, InMemoryTaskAttemptStore, InMemoryTaskCancellationStore, MAX_DEVICE_PROOF_CLOCK_SKEW_MS, MAX_DEVICE_PROOF_HEADER_BYTES, MAX_DEVICE_PROOF_MAX_LIFETIME_MS, NONCE_TTL_MS, PAIRING_CODE_TTL_MS, ROUTE_CLASSES, ROUTE_METHODS, RecurringExecutionInputSchema, StaleApprovalError, SteerRejectedError, TASK_ATTEMPT_STATUSES, TRUTH_BATCH_MAX_RECORDS, TRUTH_INLINE_CONTENT_TYPE, TRUTH_LABEL_MAX_LENGTH, TRUTH_MANIFEST_MAX_LIMIT, TRUTH_RECORD_CAPABILITY, TRUTH_RECORD_KEY_MAX_LENGTH, TRUTH_REQUEST_ID_MAX_LENGTH, TimelineEventSchema, TruthBodyInputSchema, TruthCommitError, TruthCommitResponseSchema, TruthRecordKeySchema, TruthRecordMetadataSchema, TruthWriteRequestSchema, activityCursor, activitySourceBatchState, agentHomeProjectionCompletionKey, agentHomeProjectionRequestKey, approvalTimelineCursor, assertTaskAttemptListLimit, authenticateBearer, authenticateDeviceProof, authenticateHostedDeviceAssertion, createAuthPlane, createByokCloud, createHmacTokenSigner, createInMemoryBlobs, createInMemoryByokCloud, createInMemoryCloudStores, createWebCrypto, declares, extractBearerToken, fullCapabilityDeclaration, handleInboundEnvelope, isCloudError, isTruthCommitError, parseApprovalObservations, parseTimelineEvents, pendingApproval, projectTerminalResult, projectTimelineEvents, readAgentHomeProjectionStatus, recordAgentHomeProjectionCompletion, routeKey, tenantStoresFor, terminalReceiptKey, truthManifestMetadata, truthRecordMetadata, validateActivityAppend, validateApprovalTimelineAppend, validateApprovalTimelineResolve, verifyNonceSignature };
+export { ACCESS_TOKEN_TTL_SECONDS, AGENT_HOME_CONTRACT_CAPABILITY, APPROVAL_SUMMARY_MAX_BYTES, ActivityAppendRequestSchema, AllowAllRateLimiter, ApprovalObservationSchema, ApprovalTimelineEventSchema, BLOB_READ_ERROR_CODES, BLOB_URL_TTL_MS, BoardFeedClient, BoardFeedRetryableError, BoardFeedStoppedError, ByokCloudError, CLOUD_CAPABILITIES, CLOUD_ERROR_CODES, CLOUD_PORT_INTERFACES, CLOUD_PORT_METHODS, CLOUD_STORE_NAMES, CapabilitiesResponseSchema, CloudRouteRegistry, DEDUP_RING_CAPACITY, DEFAULT_ACTIVITY_BOUNDS, DEFAULT_ACTIVITY_CAPACITY, DEFAULT_ACTIVITY_MAX_BYTES, DEFAULT_ACTIVITY_MAX_EVENTS, DEFAULT_ACTIVITY_TTL_MS, DEFAULT_APPROVAL_TIMELINE_CAPACITY, DEFAULT_APPROVAL_TIMELINE_TTL_MS, DEFAULT_BOARD_CHANNEL_MAX_BYTES, DEFAULT_BOARD_PAGE_LIMIT, DEFAULT_BOARD_STREAM_HEARTBEAT_INTERVAL_MS, DEFAULT_BOARD_STREAM_QUERY_INTERVAL_MS, DEFAULT_BOARD_STREAM_RECONCILIATION_INTERVAL_MS, DEFAULT_BOARD_TITLE_MAX_BYTES, DEFAULT_DEVICE_PROOF_CLOCK_SKEW_MS, DEFAULT_DEVICE_PROOF_MAX_LIFETIME_MS, DEFAULT_EVENTS_PAGE_LIMIT, DEFAULT_LONG_POLL_HOLD_MS, DEFAULT_LONG_POLL_INTERVAL_MS, DEFAULT_MAX_BLOB_SIZE_BYTES, DEFAULT_MAX_TRUTH_REQUEST_BYTES, DEFAULT_PRESENCE_DETAIL_MAX_BYTES, DEFAULT_PRESENCE_MINIMUM_INTERVAL_MS, DEFAULT_PRESENCE_TTL_MS, DEFAULT_SKILL_PACK_PAGE_LIMIT, DEVICE_IDENTITY_PROOF_KEY_EPOCH, DEVICE_IDENTITY_PROOF_KEY_ID, InMemoryActivityStore, InMemoryAgentEgressStore, InMemoryAgentMemoryProjectionAuthorizer, InMemoryAgentMemoryProjectionStore, InMemoryBlobContentProxy, InMemoryCloudBlobStore, InMemoryDeviceDirectory, InMemoryInboundDedupStore, InMemoryNonceStore, InMemoryPairingCodeStore, InMemoryProofRequestReceiptStore, InMemoryRequestReceiptStore, InMemoryTaskAttemptStore, InMemoryTaskCancellationStore, MAX_DEVICE_PROOF_CLOCK_SKEW_MS, MAX_DEVICE_PROOF_HEADER_BYTES, MAX_DEVICE_PROOF_MAX_LIFETIME_MS, NONCE_TTL_MS, PAIRING_CODE_TTL_MS, ROUTE_CLASSES, ROUTE_METHODS, RecurringExecutionInputSchema, StaleApprovalError, SteerRejectedError, TASK_ATTEMPT_STATUSES, TRUTH_BATCH_MAX_RECORDS, TRUTH_INLINE_CONTENT_TYPE, TRUTH_LABEL_MAX_LENGTH, TRUTH_MANIFEST_MAX_LIMIT, TRUTH_RECORD_CAPABILITY, TRUTH_RECORD_KEY_MAX_LENGTH, TRUTH_REQUEST_ID_MAX_LENGTH, TimelineEventSchema, TruthBodyInputSchema, TruthCommitError, TruthCommitResponseSchema, TruthRecordKeySchema, TruthRecordMetadataSchema, TruthWriteRequestSchema, activityCursor, activitySourceBatchState, agentHomeProjectionCompletionKey, agentHomeProjectionRequestKey, approvalTimelineCursor, assertTaskAttemptListLimit, authenticateBearer, authenticateDeviceProof, authenticateHostedDeviceAssertion, authenticateHostedTaskAssertion, createAuthPlane, createByokCloud, createHmacTokenSigner, createInMemoryBlobs, createInMemoryByokCloud, createInMemoryCloudStores, createWebCrypto, declares, extractBearerToken, fullCapabilityDeclaration, handleInboundEnvelope, inputPreparationCompletionKey, inputPreparationRequestKey, isCloudError, isTruthCommitError, parseApprovalObservations, parseTimelineEvents, pendingApproval, projectTerminalResult, projectTimelineEvents, readAgentHomeProjectionStatus, readInputPreparationStatus, recordAgentHomeProjectionCompletion, recordInputPreparationCompletion, routeKey, sameInputPreparationRequest, tenantStoresFor, terminalReceiptKey, truthManifestMetadata, truthRecordMetadata, validateActivityAppend, validateApprovalTimelineAppend, validateApprovalTimelineResolve, verifyNonceSignature };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map