@byok-sdk/cloud 0.17.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 { AgentEventOrUnknownSchema, 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, isTaskOfferType, MESSAGE_PAYLOAD_SCHEMAS, createEnvelope, AgentHomeProjectionPayloadSchema, AgentContentReadPayloadSchema, AGENT_EGRESS_POLICY_CAPABILITY, AGENT_EGRESS_FRESH_SESSION_CAPABILITY, AGENT_MESSAGE_EGRESS_CAPABILITY, TERMINAL_PROJECTION_SELECTION_CAPABILITY, TaskOfferForAgentWithEgressFreshPayloadSchema, AgentMessageServerContextSchema, 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, AgentRefSchema, PairRequestSchema, PairResponseSchema, ChallengeRequestSchema, TokenRequestSchema, AgentMemoryProjectionCommitRequestSchema, agentMemoryProjectionBase64UrlByteLength, MAILBOX_READ_AHEAD_MAX_SEQS, MAILBOX_READ_AHEAD_CAPABILITY, MessagesSendRequestSchema, PresencePublishRequestSchema, CreateBlobRequestSchema, byokBlobContentPath, AgentEgressAckPayloadSchema, AgentContentReceiptPayloadSchema } from '@byok-sdk/protocol';
 import { z } from 'zod';
+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
@@ -25,1682 +25,1778 @@ async function hashOfferBytes(bytes) {
   return `sha256:${Array.from(hash, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 }
 
-// src/approval-control.ts
-var StaleApprovalError = class extends Error {
-  constructor(taskId, requestedApprovalId, currentApprovalId) {
-    super(
-      `cannot resolve approval ${requestedApprovalId} for task ${taskId}: the currently pending approval is ${currentApprovalId ?? "(none recorded)"}`
-    );
-    this.taskId = taskId;
-    this.requestedApprovalId = requestedApprovalId;
-    this.currentApprovalId = currentApprovalId;
-    this.name = "StaleApprovalError";
-  }
-  taskId;
-  requestedApprovalId;
-  currentApprovalId;
+// src/errors.ts
+var CLOUD_ERROR_CODES = {
+  /** A pairing code that is unknown, expired, or already redeemed (§6.1). */
+  pairing_code_invalid: "pairing_code_invalid",
+  /** The composition handed a device row whose tenant is not a mintable `TenantId`. */
+  device_tenant_invalid: "device_tenant_invalid",
+  /**
+   * The mailbox committed a row `seq` that disagrees with the delivery `seq`
+   * its body factory baked into the envelope. Loud rather than silent: those
+   * two numbers ARE the daemon's redelivery cursor.
+   */
+  mailbox_seq_mismatch: "mailbox_seq_mismatch",
+  /** A capability declaration the host supplied that core refused. */
+  capability_declaration_invalid: "capability_declaration_invalid",
+  /**
+   * The declaration names a capability this composition cannot serve, so the
+   * deployment would publish a surface it does not have (ADR-010).
+   *
+   * Construction-time and fatal. A client learns what a deployment supports by
+   * READING the declaration and is entitled to act on it without probing, so a
+   * declaration that over-states is not a degraded deployment — it is a
+   * deployment whose one honest interface lies.
+   */
+  capability_over_declared: "capability_over_declared",
+  /** Host-supplied board labels or coordination input exceeded the explicit contract. */
+  coordination_input_invalid: "coordination_input_invalid",
+  /**
+   * A terminal receipt whose stored body is not a terminal envelope — either
+   * undecodable or a non-terminal type. Whatever wrote that row broke the
+   * receipt-store contract, so the typed read model fails closed instead of
+   * projecting a best-effort shape.
+   */
+  terminal_receipt_unreadable: "terminal_receipt_unreadable",
+  /** A progress/activity batch exceeded the configured event or byte ceiling. */
+  activity_batch_too_large: "activity_batch_too_large",
+  /** Host control-plane task lookup is tenant-closed and found no task. */
+  task_not_found: "task_not_found",
+  /**
+   * A host `approveTask`/`rejectTask` names a task with no approval to
+   * resolve: the durable timeline holds no unresolved `approval_requested`
+   * (including a tail that has expired or was never written), the attempt has
+   * already reached a terminal status, or no device ever claimed it so there
+   * is nothing to notify. Fail-closed by construction — cloud never invents a
+   * pending approval to make the call succeed.
+   */
+  task_not_awaiting_approval: "task_not_awaiting_approval",
+  /** Durable target-device capability is absent, revoked, or unavailable. */
+  agent_capability_missing: "agent_capability_missing",
+  /** Inbound Agent identity did not exactly match the offered identity. */
+  agent_ref_mismatch: "agent_ref_mismatch",
+  /** A strict Agent task id already names a durable attempt and cannot be re-enqueued. */
+  agent_task_already_exists: "agent_task_already_exists",
+  /** A first-write-wins Agent control record was replayed with a different body. */
+  agent_content_request_mismatch: "agent_content_request_mismatch",
+  /** A durable mailbox receipt id resolved to an envelope other than its exact acknowledgement. */
+  mailbox_receipt_mismatch: "mailbox_receipt_mismatch",
+  /** A task-free Agent-home request id already names a different immutable desired projection. */
+  agent_home_projection_request_conflict: "agent_home_projection_request_conflict",
+  /** A direct Agent-home completion did not identify a stored desired request for this exact device. */
+  agent_home_projection_request_not_found: "agent_home_projection_request_not_found",
+  /** A direct Agent-home completion changed the first durable terminal outcome. */
+  agent_home_projection_completion_conflict: "agent_home_projection_completion_conflict",
+  /** A task-free completion did not exactly echo its immutable desired projection binding. */
+  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. */
+  agent_memory_projection_authorization_denied: "agent_memory_projection_authorization_denied",
+  /** A redacted snapshot's decoded bytes did not match its declared hash or byte count. */
+  agent_memory_projection_hash_mismatch: "agent_memory_projection_hash_mismatch",
+  /** A writer epoch/source sequence already names a different immutable projection mutation. */
+  agent_memory_projection_replay_mismatch: "agent_memory_projection_replay_mismatch",
+  /** A hosted memory mutation came from an older writer epoch. */
+  agent_memory_projection_stale_epoch: "agent_memory_projection_stale_epoch",
+  /** A server-side erase fence prevents a deleted writer epoch from re-entering. */
+  agent_memory_projection_erased_epoch: "agent_memory_projection_erased_epoch",
+  /** A prior erase reached the protocol writer-epoch ceiling and cannot mint a later writer. */
+  agent_memory_projection_epoch_exhausted: "agent_memory_projection_epoch_exhausted",
+  /** A hosted memory mutation skipped or reset a required source sequence. */
+  agent_memory_projection_sequence_gap: "agent_memory_projection_sequence_gap"
 };
-function pendingApproval(tail) {
-  if (tail === void 0) return void 0;
-  let pending;
-  for (const entry of tail.entries) {
-    const event = entry.event;
-    if (event.type === "approval_requested") {
-      pending = {
-        sourceEnvelopeId: entry.sourceEnvelopeId,
-        revision: entry.revision,
-        ...event.approvalId === void 0 ? {} : { approvalId: event.approvalId }
-      };
-      continue;
-    }
-    if (pending === void 0) continue;
-    if (pending.approvalId === void 0 || pending.approvalId === event.approvalId) {
-      pending = void 0;
-    }
+var ByokCloudError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "ByokCloudError";
+    this.code = code;
   }
-  return pending;
+};
+function isCloudError(value, code) {
+  if (!(value instanceof ByokCloudError)) return false;
+  return code === void 0 || value.code === code;
 }
 
-// src/steer-control.ts
-function steerRejectionMessage(taskId, code, status, runtime) {
-  switch (code) {
-    case "task_terminal":
-      return `cannot steer task ${taskId}: task is already terminal (status ${status})`;
-    case "task_not_running":
-      return `cannot steer task ${taskId}: not running (status ${status})`;
-    case "steer_unsupported_runtime":
-      return `cannot steer task ${taskId}: claimed runtime ${runtime ?? "(unknown)"} does not support steering`;
+// src/activity.ts
+var DEFAULT_ACTIVITY_CAPACITY = 50;
+var ActivityTaskIdSchema = z.string().min(1).max(200);
+var SourceEnvelopeIdSchema = z.string().max(200).regex(/\S/, "sourceEnvelopeId must not be blank");
+var ActivityAppendRequestSchema = z.object({
+  taskId: ActivityTaskIdSchema,
+  sourceEnvelopeId: SourceEnvelopeIdSchema,
+  batchSeq: z.number().int().nonnegative(),
+  events: z.array(AgentEventOrUnknownSchema).min(1),
+  dropped: z.number().int().nonnegative()
+});
+var TimelineEventSchema = z.object({
+  taskId: ActivityTaskIdSchema,
+  sourceEnvelopeId: SourceEnvelopeIdSchema,
+  batchSeq: z.number().int().nonnegative(),
+  eventIndex: z.number().int().nonnegative(),
+  /**
+   * The producer-declared loss attached to this source batch. It travels with
+   * every retained event so a replay includes it in the canonical batch
+   * binding rather than treating the aggregate as an incidental counter.
+   */
+  sourceDropped: z.number().int().nonnegative().optional(),
+  receivedAt: z.iso.datetime(),
+  event: AgentEventOrUnknownSchema
+});
+function validateActivityAppend(input) {
+  if (!Number.isFinite(input.ttlMs) || input.ttlMs <= 0) {
+    throw new ByokCloudError(
+      "coordination_input_invalid",
+      `Activity ttl must be a positive number of milliseconds, received ${String(input.ttlMs)}.`
+    );
   }
-}
-var SteerRejectedError = class extends Error {
-  constructor(taskId, code, status, runtime) {
-    super(steerRejectionMessage(taskId, code, status, runtime));
-    this.taskId = taskId;
-    this.code = code;
-    this.status = status;
-    this.runtime = runtime;
-    this.name = "SteerRejectedError";
+  const capacity = input.capacity ?? DEFAULT_ACTIVITY_CAPACITY;
+  if (!Number.isSafeInteger(capacity) || capacity <= 0) {
+    throw new ByokCloudError(
+      "coordination_input_invalid",
+      `Activity capacity must be a positive integer, received ${String(capacity)}.`
+    );
   }
-  taskId;
-  code;
-  status;
-  runtime;
-};
-
-// src/crypto/web-crypto.ts
-var PAIRING_CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-var HEX_DIGITS = "0123456789abcdef";
-function base64UrlEncode(bytes) {
-  let binary = "";
-  for (const byte of bytes) binary += String.fromCharCode(byte);
-  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
-}
-function base64UrlDecode(value) {
-  const padded = value.replaceAll("-", "+").replaceAll("_", "/");
-  try {
-    const binary = atob(padded);
-    const bytes = new Uint8Array(binary.length);
-    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
-    return bytes;
-  } catch {
-    return void 0;
+  const parsed = ActivityAppendRequestSchema.safeParse(input);
+  if (!parsed.success) {
+    throw new ByokCloudError(
+      "coordination_input_invalid",
+      "Activity batches require stable source identity, order, at least one valid event, and a non-negative dropped count."
+    );
   }
+  return capacity;
 }
-function toHex(bytes) {
-  let out = "";
-  for (const byte of bytes) {
-    out += HEX_DIGITS[byte >> 4 & 15];
-    out += HEX_DIGITS[byte & 15];
-  }
-  return out;
+function projectTimelineEvents(input, receivedAt) {
+  return input.events.map(
+    (event, eventIndex) => TimelineEventSchema.parse({
+      taskId: input.taskId,
+      sourceEnvelopeId: input.sourceEnvelopeId,
+      batchSeq: input.batchSeq,
+      eventIndex,
+      sourceDropped: input.dropped,
+      receivedAt,
+      event
+    })
+  );
 }
-function subtle() {
-  const webCrypto = globalThis.crypto;
-  if (webCrypto?.subtle === void 0) {
-    throw new Error("@byok-sdk/cloud requires a WebCrypto implementation on globalThis.crypto");
+function activitySourceBatchState(entries, input) {
+  const existing = entries.filter((entry) => entry.sourceEnvelopeId === input.sourceEnvelopeId).sort((left, right) => left.eventIndex - right.eventIndex);
+  if (existing.length === 0) return "absent";
+  if (existing.length !== input.events.length) return "conflict";
+  for (const [eventIndex, event] of input.events.entries()) {
+    const stored = existing[eventIndex];
+    if (stored === void 0 || stored.taskId !== input.taskId || stored.batchSeq !== input.batchSeq || stored.eventIndex !== eventIndex || stored.sourceDropped !== input.dropped || JSON.stringify(stored.event) !== JSON.stringify(event)) {
+      return "conflict";
+    }
   }
-  return webCrypto.subtle;
+  return "same";
 }
-function createWebCrypto() {
-  return {
-    randomUuid() {
-      return globalThis.crypto.randomUUID();
-    },
-    randomToken(byteLength) {
-      return base64UrlEncode(globalThis.crypto.getRandomValues(new Uint8Array(byteLength)));
-    },
-    randomPairingCode(length) {
-      const bytes = globalThis.crypto.getRandomValues(new Uint8Array(length));
-      let out = "";
-      for (const byte of bytes) {
-        out += PAIRING_CODE_ALPHABET[byte % PAIRING_CODE_ALPHABET.length];
-      }
-      return out;
-    },
-    async verifyEd25519(publicKeyBase64Url, message, signature) {
-      const signatureBytes = base64UrlDecode(signature);
-      if (signatureBytes === void 0) return false;
-      try {
-        const key = await subtle().importKey(
-          "jwk",
-          { kty: "OKP", crv: "Ed25519", x: publicKeyBase64Url },
-          { name: "Ed25519" },
-          false,
-          ["verify"]
-        );
-        const messageBytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
-        return await subtle().verify({ name: "Ed25519" }, key, signatureBytes, messageBytes);
-      } catch {
-        return false;
-      }
-    },
-    async hmacSha256(secret, message) {
-      const key = await subtle().importKey("raw", secret, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-      const signature = await subtle().sign("HMAC", key, new TextEncoder().encode(message));
-      return base64UrlEncode(new Uint8Array(signature));
-    },
-    async sha256(data) {
-      const digest = await subtle().digest("SHA-256", data);
-      return `sha256:${toHex(new Uint8Array(digest))}`;
-    },
-    timingSafeEqual(left, right) {
-      const leftBytes = base64UrlDecode(left);
-      const rightBytes = base64UrlDecode(right);
-      if (leftBytes === void 0 || rightBytes === void 0) return false;
-      if (leftBytes.length !== rightBytes.length) return false;
-      let diff = 0;
-      for (let index = 0; index < leftBytes.length; index += 1) {
-        diff |= (leftBytes[index] ?? 0) ^ (rightBytes[index] ?? 0);
-      }
-      return diff === 0;
-    }
-  };
+function parseTimelineEvents(value) {
+  return z.array(TimelineEventSchema).parse(value);
+}
+function compareTimelineEvents(left, right) {
+  return left.batchSeq - right.batchSeq || left.eventIndex - right.eventIndex;
+}
+function activityCursor(entries) {
+  const last = entries.at(-1);
+  return last === void 0 ? void 0 : { batchSeq: last.batchSeq, eventIndex: last.eventIndex };
+}
+function activityTailKey(tenant, taskId) {
+  return tenantKey(tenant, taskId);
 }
 
-// src/auth/tokens.ts
-var ACCESS_TOKEN_TTL_SECONDS = 60 * 60;
-function encodeSegment(value) {
-  return base64UrlEncode(new TextEncoder().encode(JSON.stringify(value)));
+// src/coordination.ts
+var DEFAULT_BOARD_CHANNEL_MAX_BYTES = 128;
+var DEFAULT_BOARD_TITLE_MAX_BYTES = 512;
+var DEFAULT_ACTIVITY_MAX_EVENTS = 50;
+var DEFAULT_ACTIVITY_MAX_BYTES = 64 * 1024;
+var DEFAULT_ACTIVITY_TTL_MS = 10 * 6e4;
+var DEFAULT_PRESENCE_TTL_MS = 9e4;
+var DEFAULT_PRESENCE_MINIMUM_INTERVAL_MS = 5e3;
+var DEFAULT_PRESENCE_DETAIL_MAX_BYTES = 512;
+var encoder = new TextEncoder();
+var DEFAULT_ACTIVITY_BOUNDS = {
+  maxEvents: DEFAULT_ACTIVITY_MAX_EVENTS,
+  maxBytes: DEFAULT_ACTIVITY_MAX_BYTES,
+  capacity: DEFAULT_ACTIVITY_CAPACITY,
+  ttlMs: DEFAULT_ACTIVITY_TTL_MS
+};
+function assertBoardLabels(channel, title, limits) {
+  if (channel.length === 0 || encoder.encode(channel).length > limits.channelMaxBytes) {
+    throw new ByokCloudError(
+      "coordination_input_invalid",
+      `Board channel must contain 1..${limits.channelMaxBytes} UTF-8 bytes.`
+    );
+  }
+  if (title.length === 0 || encoder.encode(title).length > limits.titleMaxBytes) {
+    throw new ByokCloudError(
+      "coordination_input_invalid",
+      `Board title must contain 1..${limits.titleMaxBytes} UTF-8 bytes.`
+    );
+  }
 }
-function createHmacTokenSigner(secret, clock) {
-  async function signingKey(usage) {
-    return globalThis.crypto.subtle.importKey("raw", secret, { name: "HMAC", hash: "SHA-256" }, false, [usage]);
+function assertTaskAttemptListLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new ByokCloudError(
+      "coordination_input_invalid",
+      `Task attempt list limit must be a positive integer; received ${String(limit)}.`
+    );
   }
-  async function signature(signingInput) {
-    const key = await signingKey("sign");
-    const bytes = await globalThis.crypto.subtle.sign("HMAC", key, new TextEncoder().encode(signingInput));
-    return base64UrlEncode(new Uint8Array(bytes));
+}
+function validateActivityEvents(events, dropped, bounds) {
+  if (!Number.isSafeInteger(dropped) || dropped < 0) {
+    throw new ByokCloudError(
+      "coordination_input_invalid",
+      "Activity dropped must be a non-negative integer."
+    );
+  }
+  if (events.length === 0 || events.length > bounds.maxEvents) {
+    throw new ByokCloudError(
+      "activity_batch_too_large",
+      `Activity batch must contain 1..${bounds.maxEvents} events.`
+    );
+  }
+  const encoded = JSON.stringify(events);
+  if (encoder.encode(encoded).length > bounds.maxBytes) {
+    throw new ByokCloudError(
+      "activity_batch_too_large",
+      `Activity batch exceeds ${bounds.maxBytes} UTF-8 bytes.`
+    );
   }
-  return {
-    async sign(claims, expiresInSeconds) {
-      const issuedAt = Math.floor(clock.now().getTime() / 1e3);
-      const header = encodeSegment({ alg: "HS256", typ: "JWT" });
-      const payload = encodeSegment({
-        deviceId: claims.deviceId,
-        tenantId: claims.tenantId,
-        productId: claims.productId,
-        iat: issuedAt,
-        exp: issuedAt + expiresInSeconds
-      });
-      const signingInput = `${header}.${payload}`;
-      return `${signingInput}.${await signature(signingInput)}`;
-    },
-    async verify(token) {
-      const parts = token.split(".");
-      if (parts.length !== 3) return void 0;
-      const [header, payload, provided] = parts;
-      const key = await signingKey("verify");
-      const providedBytes = base64UrlDecode(provided);
-      if (providedBytes === void 0) return void 0;
-      const ok = await globalThis.crypto.subtle.verify(
-        "HMAC",
-        key,
-        providedBytes,
-        new TextEncoder().encode(`${header}.${payload}`)
-      );
-      if (!ok) return void 0;
-      const headerBytes = base64UrlDecode(header);
-      const payloadBytes = base64UrlDecode(payload);
-      if (headerBytes === void 0 || payloadBytes === void 0) return void 0;
-      let decodedHeader;
-      let decodedPayload;
-      try {
-        decodedHeader = JSON.parse(new TextDecoder().decode(headerBytes));
-        decodedPayload = JSON.parse(new TextDecoder().decode(payloadBytes));
-      } catch {
-        return void 0;
-      }
-      const alg = decodedHeader?.alg;
-      if (alg !== "HS256") return void 0;
-      const { deviceId, tenantId: tenantId4, productId, exp } = decodedPayload;
-      if (typeof deviceId !== "string" || typeof tenantId4 !== "string" || typeof productId !== "string") {
-        return void 0;
-      }
-      if (typeof exp !== "number" || clock.now().getTime() / 1e3 >= exp) return void 0;
-      return { deviceId, tenantId: tenantId4, productId };
-    }
-  };
 }
-function verifyNonceSignature(crypto2, devicePublicKey, nonce, signature) {
-  return crypto2.verifyEd25519(devicePublicKey, NONCE_SIGNING_DOMAIN + nonce, signature);
+function validateActivityBatch(input, bounds) {
+  validateActivityEvents(input.events, input.dropped, bounds);
+  validateActivityAppend({ ...input, ttlMs: bounds.ttlMs, capacity: bounds.capacity });
 }
-
-// src/auth/plane.ts
-var PAIRING_CODE_TTL_MS = 10 * 60 * 1e3;
-var PAIRING_CODE_LENGTH = 8;
-var DEVICE_IDENTITY_PROOF_KEY_ID = "identity";
-var DEVICE_IDENTITY_PROOF_KEY_EPOCH = 0;
-function createAuthPlane(deps) {
-  const { stores, crypto: crypto2, clock, tokenSigner } = deps;
-  const ttlSeconds = deps.accessTokenTtlSeconds ?? ACCESS_TOKEN_TTL_SECONDS;
-  return {
-    async createPairingCode(tenant, input) {
-      const expiresAt = new Date(clock.now().getTime() + (input.ttlMs ?? PAIRING_CODE_TTL_MS)).toISOString();
-      return stores.pairingCodes.issue(tenant, {
-        code: crypto2.randomPairingCode(PAIRING_CODE_LENGTH),
-        productId: input.productId,
-        expiresAt
-      });
-    },
-    async redeemAndRegister(input) {
-      return stores.pairing.redeemAndRegister({
-        pairingCode: input.pairingCode,
-        deviceId: `dev_${crypto2.randomUuid()}`,
-        deviceName: input.deviceName,
-        devicePublicKey: input.devicePublicKey,
-        proofKeyId: DEVICE_IDENTITY_PROOF_KEY_ID,
-        proofKeyEpoch: DEVICE_IDENTITY_PROOF_KEY_EPOCH,
-        ...input.machineId === void 0 ? {} : { machineId: input.machineId }
-      });
-    },
-    async resolveDevice(deviceId) {
-      const device = await stores.devices.resolveByDeviceId(deviceId);
-      if (device === void 0 || device.revoked) return void 0;
-      return device;
-    },
-    issueNonce(device) {
-      return stores.nonces.issue(device.tenantId, device.deviceId);
-    },
-    consumeNonceIfValid(device, nonce) {
-      return stores.nonces.consumeIfValid(device.tenantId, device.deviceId, nonce);
-    },
-    verifySignature(device, nonce, signature) {
-      return verifyNonceSignature(crypto2, device.devicePublicKey, nonce, signature);
-    },
-    async mintAccessToken(device) {
-      const accessToken = await tokenSigner.sign(
-        { deviceId: device.deviceId, tenantId: device.tenantId, productId: device.productId },
-        ttlSeconds
-      );
-      return {
-        accessToken,
-        expiresAt: new Date(clock.now().getTime() + ttlSeconds * 1e3).toISOString()
-      };
-    }
-  };
+async function appendActivityEvents(activity, input, bounds) {
+  validateActivityBatch(input, bounds);
+  return activity.append({
+    taskId: input.taskId,
+    sourceEnvelopeId: input.sourceEnvelopeId,
+    batchSeq: input.batchSeq,
+    events: input.events,
+    dropped: input.dropped,
+    ttlMs: bounds.ttlMs,
+    capacity: bounds.capacity
+  });
 }
-var CLOUD_CAPABILITIES = {
-  /** `GET /byok/events` long-poll receive (§8). */
-  eventsLongPoll: "events.longpoll",
-  /** `POST /byok/messages` batched send (§8.2). */
-  messagesBatch: "messages.batch",
-  /** The three bearer-authed blob routes: reserve/grant, explicit finalize, committed-only download (§7). */
-  blobsPresigned: "blobs.presigned",
-  /**
-   * The two presigned `/byok/blobs/:id/content` routes — cloud carrying the
-   * bytes itself.
-   *
-   * Split out of `blobs.presigned` because it was one capability describing two
-   * separable facts. A composition whose bytes live in object storage mints
-   * grants (`blobs.presigned`) but has no byte-proxy path at all, and saying so
-   * by declaration is ADR-010's whole posture: a client reads what a deployment
-   * serves, it never probes a `/content` route and interprets the status code.
-   *
-   * Spelled all-lowercase because core's declaration schema pins capability
-   * names to `/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/` — the same reason the sibling
-   * above reads `events.longpoll` and not `events.longPoll`.
-   */
-  blobsContentProxy: "blobs.contentproxy",
-  /** Board list/claim/unclaim/status routes. Polling is first-class under this declaration. */
-  boardCoordination: "board.coordination",
-  /** Additional SSE transport for the same board read model. */
-  boardSse: "board.sse",
-  /** Device-scoped five-level presence publication. */
-  presenceHints: "presence.hints",
-  /** Bounded task activity batch publication. */
-  activityTail: "activity.tail",
-  /** Request-bound device proof record manifest/read/write surface (S6). */
-  truthRecords: "truth.records",
-  /**
-   * Tenant-scoped skill pack distribution: the manifest list plus the per-file
-   * content route a paired device installs from.
-   *
-   * Hosted HTTP on purpose. A pack is DECLARATIVE CONTENT a device pulls after
-   * reading this declaration — not a message — so `@byok-sdk/protocol` gains
-   * nothing from it and the frozen v1 envelope stays untouched. Composition-
-   * bound like `truth.records`: a deployment that declares it without supplying
-   * a `SkillPackStore` is refused at construction rather than publishing two
-   * routes it would then 404.
-   */
-  skillPacks: "skills.pack",
-  /** Optional, one-way redacted Agent-memory snapshot mutation route. */
-  agentMemoryProjection: "agent.memory.projection"
-};
-var CapabilitiesResponseSchema = CapabilityDeclarationSchema;
-function fullCapabilityDeclaration(version = 1, options = {}) {
-  return {
-    schema: "byok-capabilities-v1",
-    version,
-    capabilities: Object.values(CLOUD_CAPABILITIES).filter((capability) => {
-      if (capability === CLOUD_CAPABILITIES.truthRecords) return options.includeTruthRecords === true;
-      if (capability === CLOUD_CAPABILITIES.skillPacks) return options.includeSkillPacks === true;
-      if (capability === CLOUD_CAPABILITIES.agentMemoryProjection) {
-        return options.includeAgentMemoryProjection === true;
-      }
-      return true;
-    })
-  };
-}
-function declares(declaration, capability) {
-  return hasCapability(declaration, capability);
-}
-
-// src/errors.ts
-var CLOUD_ERROR_CODES = {
-  /** A pairing code that is unknown, expired, or already redeemed (§6.1). */
-  pairing_code_invalid: "pairing_code_invalid",
-  /** The composition handed a device row whose tenant is not a mintable `TenantId`. */
-  device_tenant_invalid: "device_tenant_invalid",
-  /**
-   * The mailbox committed a row `seq` that disagrees with the delivery `seq`
-   * its body factory baked into the envelope. Loud rather than silent: those
-   * two numbers ARE the daemon's redelivery cursor.
-   */
-  mailbox_seq_mismatch: "mailbox_seq_mismatch",
-  /** A capability declaration the host supplied that core refused. */
-  capability_declaration_invalid: "capability_declaration_invalid",
-  /**
-   * The declaration names a capability this composition cannot serve, so the
-   * deployment would publish a surface it does not have (ADR-010).
-   *
-   * Construction-time and fatal. A client learns what a deployment supports by
-   * READING the declaration and is entitled to act on it without probing, so a
-   * declaration that over-states is not a degraded deployment — it is a
-   * deployment whose one honest interface lies.
-   */
-  capability_over_declared: "capability_over_declared",
-  /** Host-supplied board labels or coordination input exceeded the explicit contract. */
-  coordination_input_invalid: "coordination_input_invalid",
-  /**
-   * A terminal receipt whose stored body is not a terminal envelope — either
-   * undecodable or a non-terminal type. Whatever wrote that row broke the
-   * receipt-store contract, so the typed read model fails closed instead of
-   * projecting a best-effort shape.
-   */
-  terminal_receipt_unreadable: "terminal_receipt_unreadable",
-  /** A progress/activity batch exceeded the configured event or byte ceiling. */
-  activity_batch_too_large: "activity_batch_too_large",
-  /** Host control-plane task lookup is tenant-closed and found no task. */
-  task_not_found: "task_not_found",
-  /**
-   * A host `approveTask`/`rejectTask` names a task with no approval to
-   * resolve: the durable timeline holds no unresolved `approval_requested`
-   * (including a tail that has expired or was never written), the attempt has
-   * already reached a terminal status, or no device ever claimed it so there
-   * is nothing to notify. Fail-closed by construction — cloud never invents a
-   * pending approval to make the call succeed.
-   */
-  task_not_awaiting_approval: "task_not_awaiting_approval",
-  /** Durable target-device capability is absent, revoked, or unavailable. */
-  agent_capability_missing: "agent_capability_missing",
-  /** Inbound Agent identity did not exactly match the offered identity. */
-  agent_ref_mismatch: "agent_ref_mismatch",
-  /** A strict Agent task id already names a durable attempt and cannot be re-enqueued. */
-  agent_task_already_exists: "agent_task_already_exists",
-  /** A first-write-wins Agent control record was replayed with a different body. */
-  agent_content_request_mismatch: "agent_content_request_mismatch",
-  /** A durable mailbox receipt id resolved to an envelope other than its exact acknowledgement. */
-  mailbox_receipt_mismatch: "mailbox_receipt_mismatch",
-  /** A task-free Agent-home request id already names a different immutable desired projection. */
-  agent_home_projection_request_conflict: "agent_home_projection_request_conflict",
-  /** A direct Agent-home completion did not identify a stored desired request for this exact device. */
-  agent_home_projection_request_not_found: "agent_home_projection_request_not_found",
-  /** A direct Agent-home completion changed the first durable terminal outcome. */
-  agent_home_projection_completion_conflict: "agent_home_projection_completion_conflict",
-  /** A task-free completion did not exactly echo its immutable desired projection binding. */
-  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 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. */
-  agent_memory_projection_authorization_denied: "agent_memory_projection_authorization_denied",
-  /** A redacted snapshot's decoded bytes did not match its declared hash or byte count. */
-  agent_memory_projection_hash_mismatch: "agent_memory_projection_hash_mismatch",
-  /** A writer epoch/source sequence already names a different immutable projection mutation. */
-  agent_memory_projection_replay_mismatch: "agent_memory_projection_replay_mismatch",
-  /** A hosted memory mutation came from an older writer epoch. */
-  agent_memory_projection_stale_epoch: "agent_memory_projection_stale_epoch",
-  /** A server-side erase fence prevents a deleted writer epoch from re-entering. */
-  agent_memory_projection_erased_epoch: "agent_memory_projection_erased_epoch",
-  /** A prior erase reached the protocol writer-epoch ceiling and cannot mint a later writer. */
-  agent_memory_projection_epoch_exhausted: "agent_memory_projection_epoch_exhausted",
-  /** A hosted memory mutation skipped or reset a required source sequence. */
-  agent_memory_projection_sequence_gap: "agent_memory_projection_sequence_gap"
-};
-var ByokCloudError = class extends Error {
-  code;
-  constructor(code, message, options) {
-    super(message, options);
-    this.name = "ByokCloudError";
-    this.code = code;
-  }
-};
-function isCloudError(value, code) {
-  if (!(value instanceof ByokCloudError)) return false;
-  return code === void 0 || value.code === code;
-}
-
-// src/activity.ts
-var DEFAULT_ACTIVITY_CAPACITY = 50;
-var ActivityTaskIdSchema = z.string().min(1).max(200);
-var SourceEnvelopeIdSchema = z.string().max(200).regex(/\S/, "sourceEnvelopeId must not be blank");
-var ActivityAppendRequestSchema = z.object({
-  taskId: ActivityTaskIdSchema,
-  sourceEnvelopeId: SourceEnvelopeIdSchema,
-  batchSeq: z.number().int().nonnegative(),
-  events: z.array(AgentEventOrUnknownSchema).min(1),
-  dropped: z.number().int().nonnegative()
-});
-var TimelineEventSchema = z.object({
-  taskId: ActivityTaskIdSchema,
-  sourceEnvelopeId: SourceEnvelopeIdSchema,
-  batchSeq: z.number().int().nonnegative(),
-  eventIndex: z.number().int().nonnegative(),
-  /**
-   * The producer-declared loss attached to this source batch. It travels with
-   * every retained event so a replay includes it in the canonical batch
-   * binding rather than treating the aggregate as an incidental counter.
-   */
-  sourceDropped: z.number().int().nonnegative().optional(),
+var DEFAULT_APPROVAL_TIMELINE_CAPACITY = 50;
+var DEFAULT_APPROVAL_TIMELINE_TTL_MS = 10 * 60 * 1e3;
+var APPROVAL_SUMMARY_MAX_BYTES = 16 * 1024;
+var NonBlankIdSchema = z.string().max(200).regex(/\S/, "value must not be blank");
+var TaskIdSchema = z.string().min(1).max(200);
+var ApprovalRequestedEventSchema = z.object({
+  type: z.literal("approval_requested"),
+  summary: z.string(),
+  approvalId: NonBlankIdSchema.optional()
+}).strict();
+var LocalApprovalResolutionEventSchema = z.object({
+  type: z.literal("approval_resolved"),
+  // Absent only when a daemon resolved the single outstanding request without
+  // native approval identity. No id is synthesized.
+  approvalId: NonBlankIdSchema.optional(),
+  decision: z.enum(["approve", "reject"]),
+  // A daemon's `task.approval_resolved` is pure wire observation; it cannot
+  // declare a host command payload.
+  resolvedBy: z.literal("local"),
+  at: z.iso.datetime({ offset: true })
+}).strict();
+var HostApprovalResolutionEventSchema = z.object({
+  type: z.literal("approval_resolved"),
+  approvalId: NonBlankIdSchema.optional(),
+  decision: z.literal("approve"),
+  resolvedBy: z.literal("host"),
+  at: z.iso.datetime({ offset: true })
+}).strict();
+var HostRejectResolutionEventSchema = z.object({
+  type: z.literal("approval_resolved"),
+  approvalId: NonBlankIdSchema.optional(),
+  decision: z.literal("reject"),
+  resolvedBy: z.literal("host"),
+  // Required even when the host deliberately omitted a wire reason. `null`
+  // records that complete payload, so a historical host reject with no field
+  // cannot be mistaken for a recoverable executable command.
+  reason: z.string().nullable(),
+  at: z.iso.datetime({ offset: true })
+}).strict();
+var ApprovalTimelineEventSchema = z.union([
+  ApprovalRequestedEventSchema,
+  LocalApprovalResolutionEventSchema,
+  HostApprovalResolutionEventSchema,
+  HostRejectResolutionEventSchema
+]);
+var ApprovalObservationSchema = z.object({
+  taskId: TaskIdSchema,
+  sourceEnvelopeId: NonBlankIdSchema,
+  revision: z.number().int().positive(),
   receivedAt: z.iso.datetime(),
-  event: AgentEventOrUnknownSchema
+  event: ApprovalTimelineEventSchema
 });
-function validateActivityAppend(input) {
-  if (!Number.isFinite(input.ttlMs) || input.ttlMs <= 0) {
+function validateApprovalTimelineAppend(input) {
+  const capacity = input.capacity ?? DEFAULT_APPROVAL_TIMELINE_CAPACITY;
+  const ttlMs = input.ttlMs ?? DEFAULT_APPROVAL_TIMELINE_TTL_MS;
+  if (!Number.isSafeInteger(capacity) || capacity <= 0) {
     throw new ByokCloudError(
       "coordination_input_invalid",
-      `Activity ttl must be a positive number of milliseconds, received ${String(input.ttlMs)}.`
+      `Approval timeline capacity must be a positive integer, received ${String(capacity)}.`
     );
   }
-  const capacity = input.capacity ?? DEFAULT_ACTIVITY_CAPACITY;
-  if (!Number.isSafeInteger(capacity) || capacity <= 0) {
+  if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
     throw new ByokCloudError(
       "coordination_input_invalid",
-      `Activity capacity must be a positive integer, received ${String(capacity)}.`
+      `Approval timeline ttl must be a positive number of milliseconds, received ${String(ttlMs)}.`
     );
   }
-  const parsed = ActivityAppendRequestSchema.safeParse(input);
+  const parsed = z.object({
+    taskId: TaskIdSchema,
+    sourceEnvelopeId: NonBlankIdSchema,
+    event: ApprovalTimelineEventSchema
+  }).safeParse(input);
   if (!parsed.success) {
     throw new ByokCloudError(
       "coordination_input_invalid",
-      "Activity batches require stable source identity, order, at least one valid event, and a non-negative dropped count."
+      "Approval observations require stable source identity and a valid native lifecycle event."
     );
   }
-  return capacity;
+  if (parsed.data.event.type === "approval_requested" && new TextEncoder().encode(parsed.data.event.summary).byteLength > APPROVAL_SUMMARY_MAX_BYTES) {
+    throw new ByokCloudError(
+      "coordination_input_invalid",
+      `Approval summary exceeds ${APPROVAL_SUMMARY_MAX_BYTES} UTF-8 bytes.`
+    );
+  }
+  return { capacity, ttlMs, event: parsed.data.event };
 }
-function projectTimelineEvents(input, receivedAt) {
-  return input.events.map(
-    (event, eventIndex) => TimelineEventSchema.parse({
-      taskId: input.taskId,
-      sourceEnvelopeId: input.sourceEnvelopeId,
-      batchSeq: input.batchSeq,
-      eventIndex,
-      sourceDropped: input.dropped,
-      receivedAt,
-      event
-    })
-  );
-}
-function activitySourceBatchState(entries, input) {
-  const existing = entries.filter((entry) => entry.sourceEnvelopeId === input.sourceEnvelopeId).sort((left, right) => left.eventIndex - right.eventIndex);
-  if (existing.length === 0) return "absent";
-  if (existing.length !== input.events.length) return "conflict";
-  for (const [eventIndex, event] of input.events.entries()) {
-    const stored = existing[eventIndex];
-    if (stored === void 0 || stored.taskId !== input.taskId || stored.batchSeq !== input.batchSeq || stored.eventIndex !== eventIndex || stored.sourceDropped !== input.dropped || JSON.stringify(stored.event) !== JSON.stringify(event)) {
-      return "conflict";
-    }
+function validateApprovalTimelineResolve(input) {
+  const validated = validateApprovalTimelineAppend(input);
+  const expected = z.object({
+    expectedSourceEnvelopeId: NonBlankIdSchema,
+    expectedRevision: z.number().int().positive()
+  }).safeParse(input);
+  if (!expected.success || validated.event.type !== "approval_resolved" || validated.event.resolvedBy !== "host") {
+    throw new ByokCloudError(
+      "coordination_input_invalid",
+      "Host approval resolution requires an exact pending source/revision and a host resolution event."
+    );
   }
-  return "same";
+  return validated;
 }
-function parseTimelineEvents(value) {
-  return z.array(TimelineEventSchema).parse(value);
+function approvalTimelineKey(tenant, taskId) {
+  return tenantKey(tenant, taskId);
 }
-function compareTimelineEvents(left, right) {
-  return left.batchSeq - right.batchSeq || left.eventIndex - right.eventIndex;
+function parseApprovalObservations(value) {
+  return z.array(ApprovalObservationSchema).parse(value);
 }
-function activityCursor(entries) {
-  const last = entries.at(-1);
-  return last === void 0 ? void 0 : { batchSeq: last.batchSeq, eventIndex: last.eventIndex };
+function approvalTimelineCursor(entries) {
+  return entries.at(-1)?.revision;
 }
-function activityTailKey(tenant, taskId) {
-  return tenantKey(tenant, taskId);
+async function projectTerminalToReview(board, taskId) {
+  const item = await board.get(taskId);
+  if (item === void 0 || item.status !== "in_progress") return;
+  try {
+    await board.updateStatus({
+      itemId: taskId,
+      expectedStatus: "in_progress",
+      status: "in_review"
+    });
+  } catch (caught) {
+    if (isCoreConflictError(caught)) return;
+    throw caught;
+  }
+}
+function agentReliabilityKey(domain, deviceId, agentRef, id) {
+  const exact = AgentRefSchema.parse(agentRef);
+  return `${domain}:${JSON.stringify([deviceId, exact.agentId, exact.profileRevision, id])}`;
 }
 
-// src/coordination.ts
-var DEFAULT_BOARD_CHANNEL_MAX_BYTES = 128;
-var DEFAULT_BOARD_TITLE_MAX_BYTES = 512;
-var DEFAULT_ACTIVITY_MAX_EVENTS = 50;
-var DEFAULT_ACTIVITY_MAX_BYTES = 64 * 1024;
-var DEFAULT_ACTIVITY_TTL_MS = 10 * 6e4;
-var DEFAULT_PRESENCE_TTL_MS = 9e4;
-var DEFAULT_PRESENCE_MINIMUM_INTERVAL_MS = 5e3;
-var DEFAULT_PRESENCE_DETAIL_MAX_BYTES = 512;
-var encoder = new TextEncoder();
-var DEFAULT_ACTIVITY_BOUNDS = {
-  maxEvents: DEFAULT_ACTIVITY_MAX_EVENTS,
-  maxBytes: DEFAULT_ACTIVITY_MAX_BYTES,
-  capacity: DEFAULT_ACTIVITY_CAPACITY,
-  ttlMs: DEFAULT_ACTIVITY_TTL_MS
-};
-function assertBoardLabels(channel, title, limits) {
-  if (channel.length === 0 || encoder.encode(channel).length > limits.channelMaxBytes) {
-    throw new ByokCloudError(
-      "coordination_input_invalid",
-      `Board channel must contain 1..${limits.channelMaxBytes} UTF-8 bytes.`
-    );
+// src/inbound.ts
+async function handleAgentMessagePublish(stores, deviceId, taskId, payload, consume, alreadyDeduplicated) {
+  const device = await stores.devices.get(deviceId);
+  const attempt = await stores.tasks.get(taskId);
+  const binding = await stores.receipts.get(`agent-message-offer:${deviceId}:${taskId}`);
+  if (device === void 0 || device.revoked || !hasCapabilities(device.capabilities, [AGENT_MESSAGE_EGRESS_CAPABILITY]) || attempt === void 0 || attempt.deviceId !== deviceId || binding === void 0 || attempt.agentRef === void 0 || !sameAgentRef(attempt.agentRef, payload.agentRef)) return { outcome: "rejected" };
+  let frozen;
+  try {
+    frozen = JSON.parse(binding.body);
+  } catch {
+    return { outcome: "rejected" };
   }
-  if (title.length === 0 || encoder.encode(title).length > limits.titleMaxBytes) {
-    throw new ByokCloudError(
-      "coordination_input_invalid",
-      `Board title must contain 1..${limits.titleMaxBytes} UTF-8 bytes.`
-    );
+  if (!sameAgentRef(frozen.agentRef, payload.agentRef) || frozen.context === void 0 || frozen.requirement?.contract !== payload.contract || frozen.sessionRef !== void 0 && frozen.sessionRef !== payload.sessionRef || frozen.requirement.contentType !== payload.contentType || typeof frozen.requirement.maxBytes !== "number" || payload.byteCount > frozen.requirement.maxBytes) return { outcome: "rejected" };
+  const priorDisposition = await readAgentMessageDisposition(stores, deviceId, taskId, payload);
+  if (priorDisposition !== void 0) return { outcome: "duplicate", disposition: priorDisposition };
+  const payloadBody = JSON.stringify(payload);
+  const reservation = await stores.tasks.reserveAgentMessage({
+    taskId,
+    deviceId,
+    messageId: payload.messageId,
+    payloadBody
+  });
+  if (reservation !== "reserved" && reservation !== "pending") return { outcome: "rejected" };
+  let decision;
+  if (consume === void 0) {
+    if (reservation === "pending") {
+      throw new Error("Agent message consumer is unavailable while reconciling an exact pending admission.");
+    }
+    decision = { outcome: "held", reasonCode: "consumer_unavailable" };
+  } else {
+    decision = await consume({ tenant: stores.tenant, deviceId, taskId, context: frozen.context, payload });
   }
+  const disposition = agentMessageDisposition(payload, decision);
+  const admission = await stores.tasks.finalizeAgentMessage({
+    taskId,
+    deviceId,
+    messageId: payload.messageId,
+    payloadBody,
+    terminalBody: JSON.stringify({ payload, disposition })
+  });
+  const terminal = admission?.terminalBody === void 0 ? void 0 : parseAgentMessageDisposition(payload, admission.terminalBody);
+  return terminal === void 0 ? { outcome: "rejected" } : { outcome: "accepted", disposition: terminal };
 }
-function assertTaskAttemptListLimit(limit) {
-  if (!Number.isSafeInteger(limit) || limit <= 0) {
-    throw new ByokCloudError(
-      "coordination_input_invalid",
-      `Task attempt list limit must be a positive integer; received ${String(limit)}.`
-    );
-  }
+function agentMessageDisposition(payload, decision) {
+  return {
+    agentRef: payload.agentRef,
+    sessionRef: payload.sessionRef,
+    contract: payload.contract,
+    messageId: payload.messageId,
+    cursor: payload.cursor,
+    contentHash: payload.contentHash,
+    outcome: decision.outcome,
+    receiptId: crypto.randomUUID(),
+    ...decision.reasonCode === void 0 ? {} : { reasonCode: decision.reasonCode }
+  };
 }
-function validateActivityEvents(events, dropped, bounds) {
-  if (!Number.isSafeInteger(dropped) || dropped < 0) {
-    throw new ByokCloudError(
-      "coordination_input_invalid",
-      "Activity dropped must be a non-negative integer."
-    );
-  }
-  if (events.length === 0 || events.length > bounds.maxEvents) {
-    throw new ByokCloudError(
-      "activity_batch_too_large",
-      `Activity batch must contain 1..${bounds.maxEvents} events.`
-    );
+async function readAgentMessageDisposition(stores, deviceId, taskId, payload) {
+  const admission = await stores.tasks.readAgentMessage({
+    taskId,
+    deviceId,
+    messageId: payload.messageId,
+    payloadBody: JSON.stringify(payload)
+  });
+  return admission?.terminalBody === void 0 ? void 0 : parseAgentMessageDisposition(payload, admission.terminalBody);
+}
+function parseAgentMessageDisposition(payload, terminalBody) {
+  const invalid = () => new Error("Invalid persisted Agent message disposition.");
+  let decoded;
+  try {
+    decoded = JSON.parse(terminalBody);
+  } catch {
+    throw invalid();
   }
-  const encoded = JSON.stringify(events);
-  if (encoder.encode(encoded).length > bounds.maxBytes) {
-    throw new ByokCloudError(
-      "activity_batch_too_large",
-      `Activity batch exceeds ${bounds.maxBytes} UTF-8 bytes.`
-    );
+  if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) throw invalid();
+  const record = decoded;
+  const storedPayload = AgentMessagePublishPayloadSchema.safeParse(record.payload);
+  const storedDisposition = AgentMessageDispositionPayloadSchema.safeParse(record.disposition);
+  if (!storedPayload.success || !storedDisposition.success || JSON.stringify(record.payload) !== JSON.stringify(payload)) throw invalid();
+  const disposition = storedDisposition.data;
+  if (!sameAgentRef(payload.agentRef, disposition.agentRef) || disposition.sessionRef !== payload.sessionRef || disposition.contract !== payload.contract || disposition.messageId !== payload.messageId || disposition.cursor !== payload.cursor || disposition.contentHash !== payload.contentHash) throw invalid();
+  return disposition;
+}
+function terminalReceiptKey(taskId) {
+  return `task:${taskId}:terminal`;
+}
+function sameAgentRef(expected, actual) {
+  return actual?.agentId === expected.agentId && actual.profileRevision === expected.profileRevision;
+}
+function sameReliableEgress(expected, actual) {
+  return sameAgentRef(expected.agentRef, actual.agentRef) && expected.sessionRef === actual.sessionRef && expected.policyRevision === actual.policyRevision && expected.eventId === actual.eventId && expected.cursor === actual.cursor && expected.contentHash === actual.contentHash && expected.byteCount === actual.byteCount && JSON.stringify(expected.payload) === JSON.stringify(actual.payload);
+}
+function contentReadCapability(surface) {
+  switch (surface) {
+    case "workspace":
+      return AGENT_CONTENT_WORKSPACE_READ_CAPABILITY;
+    case "transcript":
+      return AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY;
+    case "artifact":
+      return AGENT_CONTENT_ARTIFACT_READ_CAPABILITY;
   }
 }
-function validateActivityBatch(input, bounds) {
-  validateActivityEvents(input.events, input.dropped, bounds);
-  validateActivityAppend({ ...input, ttlMs: bounds.ttlMs, capacity: bounds.capacity });
+function hasCapabilities(capabilities, required) {
+  return capabilities !== void 0 && required.every((capability) => capabilities.includes(capability));
 }
-async function appendActivityEvents(activity, input, bounds) {
-  validateActivityBatch(input, bounds);
-  return activity.append({
-    taskId: input.taskId,
-    sourceEnvelopeId: input.sourceEnvelopeId,
-    batchSeq: input.batchSeq,
-    events: input.events,
-    dropped: input.dropped,
-    ttlMs: bounds.ttlMs,
-    capacity: bounds.capacity
-  });
+function contentRequestReceiptKey(deviceId, agentRef, requestId) {
+  return agentReliabilityKey("agent-content-request", deviceId, agentRef, requestId);
 }
-function extractBearerToken(header) {
-  if (header === void 0) return void 0;
-  const match = /^Bearer\s+(.+)$/i.exec(header);
-  return match?.[1];
+function contentReceiptKey(deviceId, agentRef, requestId) {
+  return agentReliabilityKey("agent-content-receipt", deviceId, agentRef, requestId);
 }
-async function authenticateBearer(header, deps) {
-  const token = extractBearerToken(header);
-  if (token === void 0) return void 0;
-  const claims = await deps.tokenSigner.verify(token);
-  if (claims === void 0) return void 0;
-  if (!isTenantId(claims.tenantId)) return void 0;
-  const device = await deps.devices.get(tenantId(claims.tenantId), claims.deviceId);
-  if (device === void 0 || device.revoked) return void 0;
-  if (device.productId !== claims.productId) return void 0;
-  if (deps.instanceProductId !== void 0 && claims.productId !== deps.instanceProductId) {
+function matchesContentReadReceipt(request, receipt) {
+  return request.requestId === receipt.requestId && request.surface === receipt.surface && request.actor.kind === receipt.actor.kind && request.actor.id === receipt.actor.id && sameAgentRef(request.agentRef, receipt.agentRef) && request.sessionRef === receipt.sessionRef && request.runtime === receipt.runtime && request.cwd === receipt.cwd && request.policyRevision === receipt.policyRevision && request.target === receipt.target && request.mimeType === receipt.mimeType && request.decodeAs === receipt.decodeAs;
+}
+async function readContentRequest(stores, deviceId, agentRef, requestId) {
+  const stored = await stores.receipts.get(contentRequestReceiptKey(deviceId, agentRef, requestId));
+  if (stored === void 0) return void 0;
+  try {
+    return AgentContentReadPayloadSchema.parse(JSON.parse(stored.body));
+  } catch {
     return void 0;
   }
-  return {
-    kind: "device",
-    tenantId: device.tenantId,
-    productId: device.productId,
-    deviceId: device.deviceId
-  };
 }
-function tenantStoresFor(principal, root) {
-  const tenant = principalTenant(principal);
-  const { core, cloud } = root;
-  return {
-    tenant,
-    principal,
-    mailbox: {
-      append: (input) => core.mailbox.append(tenant, input),
-      readAfter: (query) => core.mailbox.readAfter(tenant, query),
-      recordDelivery: (input) => core.mailbox.recordDelivery(tenant, input),
-      advanceCursor: (input) => core.mailbox.advanceCursor(tenant, input),
-      readCursor: (deviceId) => core.mailbox.readCursor(tenant, deviceId)
-    },
-    board: {
-      create: (input) => core.board.create(tenant, input),
-      get: (itemId) => core.board.get(tenant, itemId),
-      list: (query) => core.board.list(tenant, query),
-      claim: (input) => core.board.claim(tenant, input),
-      unclaim: (input) => core.board.unclaim(tenant, input),
-      updateStatus: (input) => core.board.updateStatus(tenant, input)
-    },
-    presence: {
-      publish: (input) => core.presence.publish(tenant, input),
-      read: (deviceId) => core.presence.read(tenant, deviceId),
-      list: () => core.presence.list(tenant)
-    },
-    activity: {
-      append: (input) => cloud.activity.append(tenant, input),
-      read: (taskId) => cloud.activity.read(tenant, taskId)
-    },
-    approvals: {
-      append: (input) => cloud.approvals.append(tenant, input),
-      read: (taskId) => cloud.approvals.read(tenant, taskId)
-    },
-    devices: {
-      get: (deviceId) => cloud.devices.get(tenant, deviceId),
-      list: () => cloud.devices.list(tenant),
-      revoke: (deviceId) => cloud.devices.revoke(tenant, deviceId),
-      recordCapabilities: (input) => principal.kind === "device" ? cloud.devices.recordCapabilities(tenant, {
-        deviceId: principal.deviceId,
-        capabilities: input.capabilities,
-        ...input.harnesses === void 0 ? {} : { harnesses: input.harnesses }
-      }) : Promise.resolve(void 0),
-      readiness: () => cloud.devices.readiness(tenant, core.presence)
-    },
-    tasks: {
-      open: (input) => cloud.tasks.open(tenant, input),
-      reserveAgentOffer: (input) => cloud.tasks.reserveAgentOffer(tenant, input),
-      reserveAgentMessage: (input) => cloud.tasks.reserveAgentMessage(tenant, input),
-      readAgentMessage: (input) => cloud.tasks.readAgentMessage(tenant, input),
-      finalizeAgentMessage: (input) => cloud.tasks.finalizeAgentMessage(tenant, input),
-      get: (taskId) => cloud.tasks.get(tenant, taskId),
-      getMany: (taskIds) => cloud.tasks.getMany(tenant, taskIds),
-      list: (query) => cloud.tasks.list(tenant, query),
-      claim: (input) => cloud.tasks.claim(tenant, input),
-      recordStatus: (input) => cloud.tasks.recordStatus(tenant, input)
-    },
-    cancellations: {
-      request: (input) => cloud.cancellations.request(tenant, input)
-    },
-    dedup: {
-      checkAndRecord: (deviceId, envelopeId) => cloud.dedup.checkAndRecord(tenant, deviceId, envelopeId),
-      checkAndRecordAgent: (deviceId, agentRef, envelopeId) => cloud.dedup.checkAndRecordAgent(tenant, deviceId, agentRef, envelopeId)
-    },
-    receipts: {
-      record: (input) => cloud.receipts.record(tenant, input),
-      get: (key) => cloud.receipts.get(tenant, key)
-    },
-    egress: {
-      record: (input) => cloud.egress.record(tenant, input),
-      get: (deviceId, agentRef, eventId) => cloud.egress.get(tenant, deviceId, agentRef, eventId)
-    },
-    blobs: {
-      createUpload: (reservation) => cloud.blobs.createUpload(tenant, reservation),
-      observeUpload: (blobId, reservation) => cloud.blobs.observeUpload(tenant, blobId, reservation),
-      getDownloadUrl: (blobId) => cloud.blobs.getDownloadUrl(tenant, blobId)
-    },
-    quota: {
-      readReservation: (reservationId) => core.quota.readReservation(tenant, reservationId),
-      reserve: (input) => core.quota.reserve(tenant, input),
-      finalizeReservation: (input) => core.quota.finalizeReservation(tenant, input),
-      abortReservation: (reservationId) => core.quota.abortReservation(tenant, reservationId)
-    },
-    rateLimiter: {
-      consume: (deviceId) => cloud.rateLimiter.consume(tenant, deviceId)
-    }
-  };
-}
-
-// src/handlers/shared.ts
-async function readJsonBody(c) {
-  try {
-    return await c.req.json();
-  } catch {
-    return void 0;
+function inboundAgentRef(envelope) {
+  switch (envelope.type) {
+    case "task.claim":
+    case "task.decline":
+    case "task.complete":
+    case "task.fail":
+    case "task.cancelled":
+      return envelope.payload.agentRef;
+    default:
+      return void 0;
   }
 }
-async function readBoundedJsonBody(c, maximum) {
-  const declaredLength = c.req.header("content-length");
-  if (declaredLength !== void 0) {
-    const parsedLength = parseContentLength(declaredLength);
-    if (parsedLength !== void 0 && parsedLength > BigInt(maximum)) {
-      cancelBody(c.req.raw.body);
-      return { body: void 0, tooLarge: true };
+function agentRefEchoRequired(envelope) {
+  return envelope.type === "task.claim" || envelope.type === "task.decline" || envelope.type === "task.complete" || envelope.type === "task.fail" || envelope.type === "task.cancelled";
+}
+async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds = DEFAULT_ACTIVITY_BOUNDS, agentMessageConsume, observer) {
+  if (envelope.v !== PROTOCOL_VERSION) return "rejected";
+  const outcome = await applyInboundGate(
+    stores,
+    deviceId,
+    envelope,
+    activityBounds,
+    agentMessageConsume
+  );
+  if (outcome === "accepted" && observer !== void 0) {
+    try {
+      observer.onInboundCommitted({ tenantId: stores.tenant, deviceId, envelope, outcome });
+    } catch {
     }
   }
-  const stream = c.req.raw.body;
-  if (stream === null) return { body: void 0, tooLarge: false };
-  const reader = stream.getReader();
-  const chunks = [];
-  let total = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (value.byteLength > maximum - total) {
-        cancelBody(reader);
-        return { body: void 0, tooLarge: true };
-      }
-      if (value.byteLength === 0) continue;
-      chunks.push(value);
-      total += value.byteLength;
+  return outcome;
+}
+async function applyInboundGate(stores, deviceId, envelope, activityBounds, agentMessageConsume) {
+  if (!await stores.rateLimiter.consume(deviceId)) return "rate_limited";
+  if (envelope.type === "conn.hello") {
+    if (envelope.payload.deviceId !== deviceId) return "rejected";
+    if (envelope.payload.harnesses !== void 0 && !envelope.payload.capabilities.includes("custom-harness")) return "rejected";
+    if (!envelope.payload.protocolVersions.includes(PROTOCOL_VERSION)) return "rejected";
+    const device = await stores.devices.get(deviceId);
+    if (device === void 0 || device.revoked || device.productId !== envelope.payload.productId) {
+      return "rejected";
     }
-  } catch {
-    return { body: void 0, tooLarge: false };
-  } finally {
-    reader.releaseLock();
+    if (await stores.devices.recordCapabilities({ capabilities: envelope.payload.capabilities, ...envelope.payload.harnesses === void 0 ? {} : { harnesses: envelope.payload.harnesses } }) === void 0) {
+      return "rejected";
+    }
+    return completeInboundEnvelope(stores, deviceId, envelope.id, void 0);
   }
-  const bytes = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
+  if (!DAEMON_TO_SERVER_TYPES.includes(envelope.type)) return "rejected";
+  if (envelope.type === "agent.message.publish") {
+    const message = await handleAgentMessagePublish(
+      stores,
+      deviceId,
+      envelope.task_id,
+      envelope.payload,
+      agentMessageConsume);
+    return message.outcome === "rejected" ? "rejected" : completeInboundEnvelope(stores, deviceId, envelope.id, envelope.payload.agentRef);
   }
-  return { body: parseJsonBytes(bytes), tooLarge: false };
-}
-function cancelBody(body) {
-  if (body === null) return;
-  try {
-    void Promise.resolve(body.cancel()).catch(() => {
+  if (envelope.type === "agent.egress.reliable") {
+    const device = await stores.devices.get(deviceId);
+    if (device === void 0 || device.revoked || !hasCapabilities(device.capabilities, [AGENT_EGRESS_POLICY_CAPABILITY, AGENT_EGRESS_RELIABLE_ACK_CAPABILITY])) {
+      return "rejected";
+    }
+    const outcome = await stores.egress.record({
+      deviceId,
+      payload: envelope.payload,
+      receiptId: crypto.randomUUID()
     });
-  } catch {
+    if (!outcome.created && !sameReliableEgress(outcome.record.payload, envelope.payload)) return "rejected";
+    return completeInboundEnvelope(stores, deviceId, envelope.id, envelope.payload.agentRef);
   }
-}
-function parseContentLength(value) {
-  const normalized = value.trim();
-  if (!/^\d+$/u.test(normalized)) return void 0;
-  try {
-    return BigInt(normalized);
-  } catch {
-    return void 0;
+  if (envelope.type === "agent.content.receipt") {
+    const device = await stores.devices.get(deviceId);
+    if (device === void 0 || device.revoked || envelope.payload.eventId !== envelope.payload.requestId || !hasCapabilities(device.capabilities, [contentReadCapability(envelope.payload.surface), AGENT_EGRESS_RELIABLE_ACK_CAPABILITY])) {
+      return "rejected";
+    }
+    const request = await readContentRequest(stores, deviceId, envelope.payload.agentRef, envelope.payload.requestId);
+    if (request === void 0 || !matchesContentReadReceipt(request, envelope.payload)) return "rejected";
+    const key = contentReceiptKey(deviceId, envelope.payload.agentRef, envelope.payload.requestId);
+    const body = JSON.stringify(envelope.payload);
+    const receipt = await stores.receipts.record({ key, body });
+    if (!receipt.created && receipt.receipt.body !== body) return "rejected";
+    return completeInboundEnvelope(stores, deviceId, envelope.id, envelope.payload.agentRef);
   }
-}
-function parseJsonBytes(bytes) {
-  try {
-    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
-  } catch {
-    return void 0;
+  const taskId = envelope.task_id;
+  if (taskId === void 0) return "rejected";
+  const attempt = await stores.tasks.get(taskId);
+  if (attempt === void 0 || attempt.deviceId !== deviceId) return "rejected";
+  if (attempt?.ownerDeviceId !== void 0 && attempt.ownerDeviceId !== deviceId) return "rejected";
+  if (envelope.type === "task.claim" && envelope.payload.deviceId !== deviceId) return "rejected";
+  if (envelope.type === "task.claim") {
+    const harnessId = envelope.payload.harnessId;
+    if (harnessId !== void 0 && envelope.payload.runtime !== void 0) return "rejected";
+    if (attempt.ownerDeviceId !== void 0 && (harnessId !== void 0 || attempt.claimedHarnessId !== void 0) && harnessId !== attempt.claimedHarnessId) return "rejected";
+    const device = await stores.devices.get(deviceId);
+    if (harnessId !== void 0 && (!device?.capabilities?.includes("custom-harness") || !device.harnesses?.some((harness) => harness.id === harnessId))) return "rejected";
+    const messageId = await taskOfferMessageId(stores.tenant, taskId, deviceId, attempt.agentRef, hashOfferBytes);
+    const offer = await stores.receipts.get(`task-offer:${messageId}`);
+    if (offer !== void 0) {
+      const sealed = JSON.parse(offer.body);
+      if (harnessId !== void 0 && (sealed.payload.runtime !== void 0 || sealed.payload.dispatchSelection !== void 0)) return "rejected";
+      if (sealed.payload.harnessId !== void 0 && sealed.payload.harnessId !== harnessId) return "rejected";
+    } else if (harnessId !== void 0) return "rejected";
   }
-}
-async function authenticateDevice(c, deps) {
-  const device = await authenticateBearer(c.req.header("authorization"), deps.bearer);
-  if (device === void 0) return void 0;
-  return { device, stores: tenantStoresFor(device, deps.root) };
-}
-
-// src/handlers/blobs.ts
-var BLOB_RESERVATION_TTL_MS = 15 * 60 * 1e3;
-var SignedUrlQuerySchema = z.object({
-  sig: z.string().min(1),
-  exp: z.coerce.number().finite()
-});
-function createBlobHandler(deps) {
-  return async (c) => {
-    const authenticated = await authenticateDevice(c, deps);
-    if (authenticated === void 0) return c.json({ error: "unauthorized" }, 401);
-    const parsed = CreateBlobRequestSchema.safeParse(await readJsonBody(c));
-    if (!parsed.success) return c.json({ error: "size, contentType, and contentHash are required" }, 400);
-    if (parsed.data.size > deps.maxBlobSizeBytes) {
-      return c.json({ error: `blob exceeds max size of ${deps.maxBlobSizeBytes} bytes` }, 413);
-    }
-    const reservationId = idempotencyKey(c);
-    if (reservationId === void 0) {
-      return c.json({ error: "Idempotency-Key header is required" }, 400);
-    }
-    try {
-      const reservation = await authenticated.stores.quota.reserve({
-        reservationId,
-        kind: "object",
-        expectedBytes: BigInt(parsed.data.size),
-        contentHash: contentHash(parsed.data.contentHash),
-        contentType: parsed.data.contentType,
-        ttlMs: BLOB_RESERVATION_TTL_MS
-      });
-      try {
-        const { blobId, uploadUrl } = await authenticated.stores.blobs.createUpload(reservation);
-        const response = { blobId, uploadUrl };
-        return c.json(response, 200);
-      } catch (error) {
-        await authenticated.stores.quota.abortReservation(reservationId).catch(() => void 0);
-        const rendered = renderStorageError(c, error);
-        if (rendered !== void 0) return rendered;
-        throw error;
-      }
-    } catch (error) {
-      const rendered = renderStorageError(c, error);
-      if (rendered !== void 0) return rendered;
-      throw error;
-    }
-  };
-}
-function finalizeBlobHandler(deps) {
-  return async (c) => {
-    const authenticated = await authenticateDevice(c, deps);
-    if (authenticated === void 0) return c.json({ error: "unauthorized" }, 401);
-    const reservationId = idempotencyKey(c);
-    if (reservationId === void 0) {
-      return c.json({ error: "Idempotency-Key header is required" }, 400);
-    }
+  let unclaimedInterruption = false;
+  if (envelope.type === "task.fail" && envelope.payload.recovery !== void 0) {
+    if (envelope.payload.reason !== "daemon_interrupted" || envelope.payload.retryable !== false) return "rejected";
+    const messageId = await taskOfferMessageId(stores.tenant, taskId, deviceId, attempt.agentRef, hashOfferBytes);
+    if (envelope.payload.recovery.offerId !== messageId) return "rejected";
+    const offer = await stores.receipts.get(`task-offer:${messageId}`);
+    if (offer === void 0) return "rejected";
+    const sealed = JSON.parse(offer.body);
+    const harnessId = envelope.payload.harnessId;
+    if (sealed.payload.harnessId !== void 0 && sealed.payload.harnessId !== harnessId) return "rejected";
+    if (harnessId !== void 0 && (sealed.payload.runtime !== void 0 || sealed.payload.dispatchSelection !== void 0)) return "rejected";
+    unclaimedInterruption = attempt.ownerDeviceId === void 0 && attempt.claimedHarnessId === void 0;
+  }
+  if ((envelope.type === "task.complete" || envelope.type === "task.fail" || envelope.type === "task.cancelled") && !unclaimedInterruption && envelope.payload.harnessId !== attempt.claimedHarnessId) return "rejected";
+  if (attempt?.agentRef !== void 0 && agentRefEchoRequired(envelope) && !sameAgentRef(attempt.agentRef, inboundAgentRef(envelope))) {
+    return "rejected";
+  }
+  if (envelope.type === "task.progress" && envelope.payload.events.length > 0) {
     try {
-      const reservation = await authenticated.stores.quota.readReservation(reservationId);
-      if (reservation === void 0) {
-        return c.json({ error: "storage_reservation_not_found" }, 404);
-      }
-      const blobId = c.req.param("id") ?? "";
-      const observed = await authenticated.stores.blobs.observeUpload(
-        blobId,
-        reservation
+      validateActivityBatch(
+        {
+          taskId,
+          sourceEnvelopeId: envelope.id,
+          batchSeq: envelope.payload.seq,
+          events: envelope.payload.events,
+          dropped: 0
+        },
+        activityBounds
       );
-      if (observed === void 0) {
-        await authenticated.stores.quota.abortReservation(reservationId);
-        return c.json({ error: "storage_integrity_mismatch" }, 422);
+    } catch (caught) {
+      if (isCloudError(caught, "activity_batch_too_large") || isCloudError(caught, "coordination_input_invalid")) {
+        return "rejected";
       }
-      await authenticated.stores.quota.finalizeReservation({
-        reservationId,
-        ...observed
-      });
-      return c.body(null, 204);
-    } catch (error) {
-      const rendered = renderStorageError(c, error);
-      if (rendered !== void 0) return rendered;
-      throw error;
+      throw caught;
     }
-  };
+  }
+  const approvalInput = approvalTimelineAppendInput(taskId, envelope);
+  if (approvalInput !== void 0) {
+    try {
+      validateApprovalTimelineAppend(approvalInput);
+    } catch (caught) {
+      if (isCloudError(caught, "coordination_input_invalid")) return "rejected";
+      throw caught;
+    }
+  }
+  const lifecycleOutcome = await applyLifecycle(stores, deviceId, taskId, envelope, activityBounds, attempt?.agentRef);
+  if (lifecycleOutcome === "rejected") return "rejected";
+  return completeInboundEnvelope(stores, deviceId, envelope.id, attempt?.agentRef);
 }
-function blobDownloadUrlHandler(deps) {
-  return async (c) => {
-    const authenticated = await authenticateDevice(c, deps);
-    if (authenticated === void 0) return c.json({ error: "unauthorized" }, 401);
-    const downloadUrl = await authenticated.stores.blobs.getDownloadUrl(c.req.param("id") ?? "");
-    if (downloadUrl === void 0) return c.json({ error: "blob not found" }, 404);
-    const response = { downloadUrl };
-    return c.json(response, 200);
-  };
+async function completeInboundEnvelope(stores, deviceId, envelopeId, agentRef) {
+  const duplicate = agentRef === void 0 ? await stores.dedup.checkAndRecord(deviceId, envelopeId) : await stores.dedup.checkAndRecordAgent(deviceId, agentRef, envelopeId);
+  return duplicate ? "duplicate" : "accepted";
 }
-function blobUploadContentHandler(deps) {
-  return async (c) => {
-    const blobId = c.req.param("id") ?? "";
-    const query = SignedUrlQuerySchema.safeParse({ sig: c.req.query("sig"), exp: c.req.query("exp") });
-    if (!query.success || !await deps.contentProxy.verifySignedUrl(blobId, "put", query.data.sig, query.data.exp)) {
-      return c.json({ error: "invalid or expired signature" }, 401);
-    }
-    const expectedBytes = await deps.contentProxy.expectedUploadBytes(blobId);
-    if (expectedBytes === void 0) return c.json({ error: "blob not found" }, 404);
-    const absoluteCeiling = BigInt(deps.maxUploadBytes);
-    if (expectedBytes > absoluteCeiling) return c.json({ error: "upload exceeds size limit" }, 413);
-    const contentLength = c.req.header("content-length");
-    if (contentLength !== void 0 && /^\d+$/u.test(contentLength) && BigInt(contentLength) > expectedBytes) {
-      return c.json({ error: "upload exceeds declared size" }, 413);
+async function applyLifecycle(stores, deviceId, taskId, envelope, activityBounds, persistedAgentRef) {
+  switch (envelope.type) {
+    case "task.claim": {
+      const claimed = await stores.tasks.claim({
+        taskId,
+        deviceId,
+        ...envelope.payload.runtime === void 0 ? {} : { runtime: envelope.payload.runtime },
+        ...envelope.payload.harnessId === void 0 ? {} : { harnessId: envelope.payload.harnessId },
+        ...envelope.payload.capabilities === void 0 ? {} : { capabilities: envelope.payload.capabilities }
+      });
+      if (claimed === void 0 || claimed.ownerDeviceId !== deviceId || claimed.claimedRuntime !== envelope.payload.runtime || claimed.claimedHarnessId !== envelope.payload.harnessId) return "rejected";
+      return;
     }
-    const body = await readBoundedBody(c.req.raw.body, Number(expectedBytes));
-    if (body.tooLarge) return c.json({ error: "upload exceeds declared size" }, 413);
-    const result = await deps.contentProxy.writeContent(blobId, body.data);
-    if (!result.ok) return c.json({ error: result.reason }, 422);
-    return c.body(null, 204);
-  };
-}
-async function readBoundedBody(body, ceiling) {
-  if (body === null) return { tooLarge: false, data: new Uint8Array() };
-  const reader = body.getReader();
-  const data = new Uint8Array(ceiling);
-  let offset = 0;
-  try {
-    for (; ; ) {
-      const next = await reader.read();
-      if (next.done) break;
-      const chunk = next.value;
-      if (chunk.byteLength > ceiling - offset) {
-        void reader.cancel().catch(() => void 0);
-        return { tooLarge: true };
+    case "task.started":
+      await stores.tasks.recordStatus({
+        taskId,
+        status: "running",
+        ...persistedAgentRef === void 0 ? {} : { agentRef: persistedAgentRef }
+      });
+      return;
+    case "task.decline":
+      await recordTerminal(stores, taskId, envelope);
+      return;
+    case "task.progress":
+      if (envelope.payload.events.length > 0) {
+        await appendActivityEvents(
+          stores.activity,
+          {
+            taskId,
+            sourceEnvelopeId: envelope.id,
+            batchSeq: envelope.payload.seq,
+            events: envelope.payload.events,
+            dropped: 0
+          },
+          activityBounds
+        );
       }
-      data.set(chunk, offset);
-      offset += chunk.byteLength;
-    }
-  } finally {
-    reader.releaseLock();
+      return;
+    case "task.await_approval":
+      await stores.approvals.append(approvalTimelineAppendInput(taskId, envelope));
+      return;
+    case "task.approval_resolved":
+      await stores.approvals.append(approvalTimelineAppendInput(taskId, envelope));
+      return;
+    case "task.complete":
+      await recordTerminal(stores, taskId, envelope);
+      return;
+    case "task.fail":
+      await recordTerminal(stores, taskId, envelope);
+      return;
+    case "task.cancelled":
+      await recordTerminal(stores, taskId, envelope);
+      return;
+    default:
+      return;
   }
-  return { tooLarge: false, data: data.subarray(0, offset) };
-}
-function blobDownloadContentHandler(deps) {
-  return async (c) => {
-    const blobId = c.req.param("id") ?? "";
-    const query = SignedUrlQuerySchema.safeParse({ sig: c.req.query("sig"), exp: c.req.query("exp") });
-    if (!query.success || !await deps.contentProxy.verifySignedUrl(blobId, "get", query.data.sig, query.data.exp)) {
-      return c.json({ error: "invalid or expired signature" }, 401);
-    }
-    const result = await deps.contentProxy.readContent(blobId);
-    if (result === void 0) return c.json({ error: "blob not found" }, 404);
-    if (!result.ok) return c.json({ error: result.code }, BLOB_READ_ERROR_HTTP_STATUS[result.code]);
-    return c.body(new Uint8Array(result.content.data), 200, { "content-type": result.content.contentType });
-  };
-}
-var BLOB_READ_ERROR_HTTP_STATUS = {
-  blob_upstream_unavailable: 502,
-  blob_upstream_stream_interrupted: 502
-};
-function idempotencyKey(c) {
-  const value = c.req.header("Idempotency-Key");
-  if (value === void 0 || value.length === 0 || value.length > 200) return void 0;
-  return value;
 }
-function renderStorageError(c, error) {
-  if (!isCoreError(error)) return void 0;
-  if (STORAGE_ERROR_CODES.includes(error.code)) {
-    const code = error.code;
-    return c.json({ error: code }, STORAGE_ERROR_HTTP_STATUS[code]);
-  }
-  if (error.code === "storage_reservation_not_found" || error.code === "object_not_found") {
-    return c.json({ error: error.code }, 404);
-  }
-  if (error.code === "storage_entitlement_missing" || error.code === "object_state_invalid") {
-    return c.json({ error: error.code }, 409);
+function approvalTimelineAppendInput(taskId, envelope) {
+  switch (envelope.type) {
+    case "task.await_approval":
+      return {
+        taskId,
+        sourceEnvelopeId: envelope.id,
+        event: {
+          type: "approval_requested",
+          summary: envelope.payload.summary,
+          ...envelope.payload.approvalId === void 0 ? {} : { approvalId: envelope.payload.approvalId }
+        }
+      };
+    case "task.approval_resolved":
+      return {
+        taskId,
+        sourceEnvelopeId: envelope.id,
+        event: {
+          type: "approval_resolved",
+          approvalId: envelope.payload.approvalId,
+          decision: envelope.payload.decision,
+          resolvedBy: envelope.payload.resolvedBy,
+          at: envelope.payload.at
+        }
+      };
+    default:
+      return void 0;
   }
-  if (error.code === "content_hash_invalid") {
-    return c.json({ error: error.code }, 400);
+}
+async function recordTerminal(stores, taskId, envelope) {
+  const receipt = await stores.receipts.record({
+    key: terminalReceiptKey(taskId),
+    body: encodeEnvelope(envelope)
+  });
+  const winner = terminalReceiptBinding(taskId, receipt.receipt.body);
+  if (winner === void 0) {
+    throw new Error(`terminal receipt for ${taskId} is not a canonical terminal binding`);
   }
-  return void 0;
+  const attempt = await stores.tasks.get(taskId);
+  if (attempt?.cancellation !== void 0) {
+    await stores.tasks.recordStatus({
+      taskId,
+      status: "cancelled",
+      ...attempt.agentRef === void 0 ? {} : { agentRef: attempt.agentRef }
+    });
+    return;
+  }
+  const recordedAttempt = await stores.tasks.recordStatus({
+    taskId,
+    status: winner.status,
+    ...attempt?.agentRef === void 0 ? {} : { agentRef: attempt.agentRef },
+    ...winner.cause === void 0 ? {} : { terminalCause: winner.cause }
+  });
+  if (recordedAttempt?.cancellation !== void 0 || recordedAttempt?.status !== winner.status) {
+    if (recordedAttempt?.cancellation !== void 0) {
+      await stores.tasks.recordStatus({
+        taskId,
+        status: "cancelled",
+        ...recordedAttempt.agentRef === void 0 ? {} : { agentRef: recordedAttempt.agentRef }
+      });
+    }
+    return;
+  }
+  await projectTerminalToReview(stores.board, taskId);
 }
-
-// src/handlers/capabilities.ts
-function capabilitiesHandler(deps) {
-  return async (c) => c.json(deps.declaration, 200);
+function terminalStatus(envelope) {
+  switch (envelope.type) {
+    case "task.complete":
+      return "complete";
+    case "task.fail":
+    case "task.decline":
+      return "failed";
+    case "task.cancelled":
+      return "cancelled";
+    default:
+      return void 0;
+  }
 }
-var AUTH_JSON_BODY_MAX_BYTES = 16 * 1024;
-function pairHandler(deps) {
-  return async (c) => {
-    const body = await readBoundedJsonBody(c, AUTH_JSON_BODY_MAX_BYTES);
-    if (body.tooLarge) return c.json({ error: "request body too large" }, 413);
-    const parsed = PairRequestSchema.safeParse(body.body);
-    if (!parsed.success) {
-      return c.json(
-        {
-          error: "pairingCode, deviceName, and devicePublicKey are required strings; optional machineId must be 64 lowercase hex characters"
-        },
-        400
-      );
-    }
-    const device = await deps.auth.redeemAndRegister(parsed.data);
-    if (device === void 0) return c.json({ error: "invalid pairing code" }, 401);
-    const { accessToken, expiresAt } = await deps.auth.mintAccessToken(device);
-    const response = PairResponseSchema.parse({
-      deviceId: device.deviceId,
-      accessToken,
-      refreshHint: expiresAt,
-      tenantId: device.tenantId
-    });
-    return c.json(response, 200);
-  };
+function terminalReceiptBinding(taskId, body) {
+  let envelope;
+  try {
+    envelope = decodeEnvelope(body);
+  } catch {
+    return void 0;
+  }
+  const status = terminalStatus(envelope);
+  if (status === void 0 || envelope.task_id !== taskId || encodeEnvelope(envelope) !== body) return void 0;
+  const cause = envelope.type === "task.fail" || envelope.type === "task.cancelled" || envelope.type === "task.decline" ? envelope.payload.reason : void 0;
+  return { status, ...cause === void 0 ? {} : { cause } };
 }
-function challengeHandler(deps) {
-  return async (c) => {
-    const body = await readBoundedJsonBody(c, AUTH_JSON_BODY_MAX_BYTES);
-    if (body.tooLarge) return c.json({ error: "request body too large" }, 413);
-    const parsed = ChallengeRequestSchema.safeParse(body.body);
-    if (!parsed.success) return c.json({ error: "deviceId is required" }, 400);
-    const device = await deps.auth.resolveDevice(parsed.data.deviceId);
-    if (device === void 0) return c.json({ error: "unknown or revoked device" }, 401);
-    const response = { nonce: await deps.auth.issueNonce(device) };
-    return c.json(response, 200);
-  };
+
+// src/task-agent-message.ts
+var FrozenMessageBinding = z.object({
+  agentRef: AgentRefSchema,
+  sessionRef: z.string().min(1).optional(),
+  requirement: AgentMessageEgressRequirementSchema,
+  context: AgentMessageServerContextSchema
+}).strict();
+function sameRef(a, b) {
+  return a.agentId === b.agentId && a.profileRevision === b.profileRevision;
 }
-function tokenHandler(deps) {
-  return async (c) => {
-    const body = await readBoundedJsonBody(c, AUTH_JSON_BODY_MAX_BYTES);
-    if (body.tooLarge) return c.json({ error: "request body too large" }, 413);
-    const parsed = TokenRequestSchema.safeParse(body.body);
-    if (!parsed.success) return c.json({ error: "deviceId, nonce, and signature are required" }, 400);
-    const { deviceId, nonce, signature } = parsed.data;
-    const device = await deps.auth.resolveDevice(deviceId);
-    if (device === void 0) return c.json({ error: "unknown or revoked device" }, 401);
-    if (!await deps.auth.verifySignature(device, nonce, signature)) {
-      return c.json({ error: "invalid signature" }, 401);
+async function readTaskAgentMessage(stores, deviceId, taskId, expectedRef) {
+  const agentRef = AgentRefSchema.parse(expectedRef);
+  const attempt = await stores.tasks.get(taskId);
+  if (!attempt || attempt.tenantId !== stores.tenant || attempt.taskId !== taskId || attempt.deviceId !== deviceId || !attempt.agentRef || !sameRef(attempt.agentRef, agentRef)) return void 0;
+  const admission = await stores.tasks.readTaskAgentMessage({ taskId, deviceId });
+  if (!admission) return void 0;
+  const invalid = () => new Error("Invalid persisted task Agent message.");
+  const binding = await stores.receipts.get(`agent-message-offer:${deviceId}:${taskId}`);
+  if (!binding) throw invalid();
+  let body, frozenBody;
+  try {
+    body = JSON.parse(admission.payloadBody);
+    frozenBody = JSON.parse(binding.body);
+  } catch {
+    throw invalid();
+  }
+  const parsed = AgentMessagePublishPayloadSchema.safeParse(body);
+  const frozen = FrozenMessageBinding.safeParse(frozenBody);
+  if (!parsed.success || !frozen.success) throw invalid();
+  const payload = parsed.data;
+  if (admission.messageId !== payload.messageId || JSON.stringify(payload) !== admission.payloadBody || !sameRef(payload.agentRef, agentRef) || !sameRef(frozen.data.agentRef, agentRef) || payload.contract !== frozen.data.requirement.contract || payload.contentType !== frozen.data.requirement.contentType || frozen.data.sessionRef !== void 0 && payload.sessionRef !== frozen.data.sessionRef || payload.byteCount > frozen.data.requirement.maxBytes) throw invalid();
+  const disposition = admission.terminalBody === void 0 ? void 0 : parseAgentMessageDisposition(payload, admission.terminalBody);
+  return { payload, context: frozen.data.context, ...disposition === void 0 ? {} : { disposition } };
+}
+var RecurringExecutionInputSchema = z.object({
+  taskId: z.string().min(1),
+  deviceId: z.string().min(1),
+  payload: TaskOfferForAgentWithEgressFreshPayloadSchema.required({ runtime: true, messageEgress: true, terminalProjection: true }),
+  agentMessageContext: AgentMessageServerContextSchema
+}).strict();
+
+// src/approval-control.ts
+var StaleApprovalError = class extends Error {
+  constructor(taskId, requestedApprovalId, currentApprovalId) {
+    super(
+      `cannot resolve approval ${requestedApprovalId} for task ${taskId}: the currently pending approval is ${currentApprovalId ?? "(none recorded)"}`
+    );
+    this.taskId = taskId;
+    this.requestedApprovalId = requestedApprovalId;
+    this.currentApprovalId = currentApprovalId;
+    this.name = "StaleApprovalError";
+  }
+  taskId;
+  requestedApprovalId;
+  currentApprovalId;
+};
+function pendingApproval(tail) {
+  if (tail === void 0) return void 0;
+  let pending;
+  for (const entry of tail.entries) {
+    const event = entry.event;
+    if (event.type === "approval_requested") {
+      pending = {
+        sourceEnvelopeId: entry.sourceEnvelopeId,
+        revision: entry.revision,
+        ...event.approvalId === void 0 ? {} : { approvalId: event.approvalId }
+      };
+      continue;
     }
-    if (!await deps.auth.consumeNonceIfValid(device, nonce)) {
-      return c.json({ error: "invalid, expired, or already-used nonce" }, 401);
+    if (pending === void 0) continue;
+    if (pending.approvalId === void 0 || pending.approvalId === event.approvalId) {
+      pending = void 0;
     }
-    const { accessToken, expiresAt } = await deps.auth.mintAccessToken(device);
-    const response = { accessToken, expiresAt };
-    return c.json(response, 200);
-  };
+  }
+  return pending;
 }
-var CLOUD_PROTOCOL_CAPABILITIES = [
-  "custom-harness",
-  MAILBOX_READ_AHEAD_CAPABILITY,
-  "result-document",
-  // The kernel's inbound handles `task.approval_resolved` on both the plain
-  // and the approval-timeline paths (`packages/cloud/src/inbound.ts:576,610`).
-  // Without this flag `TaskRunner.sendApprovalResolved` returns early and a
-  // locally-resolved approval is never reported on the wire at all.
-  "approval_resolved",
-  "agent-home-contract",
-  "agent-home-projection",
-  "agent-egress-policy",
-  "agent-egress-reliable-ack",
-  "agent-egress-fresh-session",
-  // `handleAgentMessagePublish` accepts `agent.message_egress` gated on exactly
-  // this capability (`packages/cloud/src/inbound.ts:124`) — the same inbound
-  // family as the three egress flags above, omitted by the same drift.
-  "agent-message-egress",
-  "agent-content-workspace-read",
-  "agent-content-transcript-read",
-  "agent-content-artifact-read"
-];
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/steer-control.ts
+function steerRejectionMessage(taskId, code, status, runtime) {
+  switch (code) {
+    case "task_terminal":
+      return `cannot steer task ${taskId}: task is already terminal (status ${status})`;
+    case "task_not_running":
+      return `cannot steer task ${taskId}: not running (status ${status})`;
+    case "steer_unsupported_runtime":
+      return `cannot steer task ${taskId}: claimed runtime ${runtime ?? "(unknown)"} does not support steering`;
+  }
 }
-function eventsHandler(deps) {
-  return async (c) => {
-    const authenticated = await authenticateDevice(c, deps);
-    if (authenticated === void 0) return c.json({ error: "unauthorized" }, 401);
-    const { device, stores } = authenticated;
-    const cursorRaw = c.req.query("cursor");
-    let cursor = 0;
-    if (cursorRaw !== void 0) {
-      const parsedCursor = Number(cursorRaw);
-      if (!Number.isSafeInteger(parsedCursor) || parsedCursor < 0) {
-        return c.json({ error: "invalid cursor" }, 400);
-      }
-      cursor = parsedCursor;
-    }
-    const afterRaw = c.req.query("afterSeq");
-    const afterSeq = afterRaw === void 0 ? cursor : Number(afterRaw);
-    if (!Number.isSafeInteger(afterSeq) || afterSeq < cursor || afterSeq - cursor > MAILBOX_READ_AHEAD_MAX_SEQS) {
-      return c.json({ error: "invalid read-ahead offset" }, 400);
-    }
-    const acked = await stores.mailbox.readCursor(device.deviceId);
-    if (afterRaw !== void 0 && afterSeq > acked.deliveredSeq) return c.json({ error: "read offset exceeds delivered watermark" }, 409);
-    if (cursor > acked.ackedSeq) {
-      try {
-        await stores.mailbox.advanceCursor({ deviceId: device.deviceId, ackedSeq: cursor });
-      } catch (caught) {
-        if (isCoreConflictError(caught, "mailbox_cursor_ahead_of_delivery")) {
-          return c.json({ error: "cursor exceeds delivered watermark" }, 409);
-        }
-        throw caught;
-      }
-    }
-    const attempts = Math.max(1, Math.ceil(deps.longPollHoldMs / deps.longPollIntervalMs));
-    for (let attempt = 0; attempt < attempts; attempt += 1) {
-      let scanCursor = afterSeq;
-      while (true) {
-        const page = await stores.mailbox.readAfter({
-          deviceId: device.deviceId,
-          afterSeq: scanCursor,
-          limit: deps.pageLimit
-        });
-        if (cursor < page.recoverableFrom - 1) {
-          return c.json({ error: "cursor_too_old", recoverableFrom: page.recoverableFrom }, 409);
-        }
-        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] : []
-        );
-        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;
-          }
-          return event.task_id === void 0 || attemptsByTaskId[event.task_id]?.cancellation === void 0;
-        });
-        if (events.length === 0 && page.hasMore) {
-          scanCursor = page.nextSeq;
-          continue;
-        }
-        if (events.length === 0) break;
-        const response2 = {
-          events,
-          cursor: page.nextSeq,
-          capabilities: CLOUD_PROTOCOL_CAPABILITIES
-        };
-        await stores.mailbox.recordDelivery({
-          deviceId: device.deviceId,
-          deliveredSeq: response2.cursor
-        });
-        return c.json(response2, 200);
+var SteerRejectedError = class extends Error {
+  constructor(taskId, code, status, runtime) {
+    super(steerRejectionMessage(taskId, code, status, runtime));
+    this.taskId = taskId;
+    this.code = code;
+    this.status = status;
+    this.runtime = runtime;
+    this.name = "SteerRejectedError";
+  }
+  taskId;
+  code;
+  status;
+  runtime;
+};
+
+// src/crypto/web-crypto.ts
+var PAIRING_CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+var HEX_DIGITS = "0123456789abcdef";
+function base64UrlEncode(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function base64UrlDecode(value) {
+  const padded = value.replaceAll("-", "+").replaceAll("_", "/");
+  try {
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    return bytes;
+  } catch {
+    return void 0;
+  }
+}
+function toHex(bytes) {
+  let out = "";
+  for (const byte of bytes) {
+    out += HEX_DIGITS[byte >> 4 & 15];
+    out += HEX_DIGITS[byte & 15];
+  }
+  return out;
+}
+function subtle() {
+  const webCrypto = globalThis.crypto;
+  if (webCrypto?.subtle === void 0) {
+    throw new Error("@byok-sdk/cloud requires a WebCrypto implementation on globalThis.crypto");
+  }
+  return webCrypto.subtle;
+}
+function createWebCrypto() {
+  return {
+    randomUuid() {
+      return globalThis.crypto.randomUUID();
+    },
+    randomToken(byteLength) {
+      return base64UrlEncode(globalThis.crypto.getRandomValues(new Uint8Array(byteLength)));
+    },
+    randomPairingCode(length) {
+      const bytes = globalThis.crypto.getRandomValues(new Uint8Array(length));
+      let out = "";
+      for (const byte of bytes) {
+        out += PAIRING_CODE_ALPHABET[byte % PAIRING_CODE_ALPHABET.length];
       }
-      if (attempt < attempts - 1) await sleep(deps.longPollIntervalMs);
+      return out;
+    },
+    async verifyEd25519(publicKeyBase64Url, message, signature) {
+      const signatureBytes = base64UrlDecode(signature);
+      if (signatureBytes === void 0) return false;
+      try {
+        const key = await subtle().importKey(
+          "jwk",
+          { kty: "OKP", crv: "Ed25519", x: publicKeyBase64Url },
+          { name: "Ed25519" },
+          false,
+          ["verify"]
+        );
+        const messageBytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+        return await subtle().verify({ name: "Ed25519" }, key, signatureBytes, messageBytes);
+      } catch {
+        return false;
+      }
+    },
+    async hmacSha256(secret, message) {
+      const key = await subtle().importKey("raw", secret, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+      const signature = await subtle().sign("HMAC", key, new TextEncoder().encode(message));
+      return base64UrlEncode(new Uint8Array(signature));
+    },
+    async sha256(data) {
+      const digest = await subtle().digest("SHA-256", data);
+      return `sha256:${toHex(new Uint8Array(digest))}`;
+    },
+    timingSafeEqual(left, right) {
+      const leftBytes = base64UrlDecode(left);
+      const rightBytes = base64UrlDecode(right);
+      if (leftBytes === void 0 || rightBytes === void 0) return false;
+      if (leftBytes.length !== rightBytes.length) return false;
+      let diff = 0;
+      for (let index = 0; index < leftBytes.length; index += 1) {
+        diff |= (leftBytes[index] ?? 0) ^ (rightBytes[index] ?? 0);
+      }
+      return diff === 0;
     }
-    const response = {
-      events: [],
-      cursor: afterSeq,
-      capabilities: CLOUD_PROTOCOL_CAPABILITIES
-    };
-    return c.json(response, 200);
   };
 }
-var DEFAULT_APPROVAL_TIMELINE_CAPACITY = 50;
-var DEFAULT_APPROVAL_TIMELINE_TTL_MS = 10 * 60 * 1e3;
-var APPROVAL_SUMMARY_MAX_BYTES = 16 * 1024;
-var NonBlankIdSchema = z.string().max(200).regex(/\S/, "value must not be blank");
-var TaskIdSchema = z.string().min(1).max(200);
-var ApprovalRequestedEventSchema = z.object({
-  type: z.literal("approval_requested"),
-  summary: z.string(),
-  approvalId: NonBlankIdSchema.optional()
-}).strict();
-var LocalApprovalResolutionEventSchema = z.object({
-  type: z.literal("approval_resolved"),
-  // Absent only when a daemon resolved the single outstanding request without
-  // native approval identity. No id is synthesized.
-  approvalId: NonBlankIdSchema.optional(),
-  decision: z.enum(["approve", "reject"]),
-  // A daemon's `task.approval_resolved` is pure wire observation; it cannot
-  // declare a host command payload.
-  resolvedBy: z.literal("local"),
-  at: z.iso.datetime({ offset: true })
-}).strict();
-var HostApprovalResolutionEventSchema = z.object({
-  type: z.literal("approval_resolved"),
-  approvalId: NonBlankIdSchema.optional(),
-  decision: z.literal("approve"),
-  resolvedBy: z.literal("host"),
-  at: z.iso.datetime({ offset: true })
-}).strict();
-var HostRejectResolutionEventSchema = z.object({
-  type: z.literal("approval_resolved"),
-  approvalId: NonBlankIdSchema.optional(),
-  decision: z.literal("reject"),
-  resolvedBy: z.literal("host"),
-  // Required even when the host deliberately omitted a wire reason. `null`
-  // records that complete payload, so a historical host reject with no field
-  // cannot be mistaken for a recoverable executable command.
-  reason: z.string().nullable(),
-  at: z.iso.datetime({ offset: true })
-}).strict();
-var ApprovalTimelineEventSchema = z.union([
-  ApprovalRequestedEventSchema,
-  LocalApprovalResolutionEventSchema,
-  HostApprovalResolutionEventSchema,
-  HostRejectResolutionEventSchema
-]);
-var ApprovalObservationSchema = z.object({
-  taskId: TaskIdSchema,
-  sourceEnvelopeId: NonBlankIdSchema,
-  revision: z.number().int().positive(),
-  receivedAt: z.iso.datetime(),
-  event: ApprovalTimelineEventSchema
-});
-function validateApprovalTimelineAppend(input) {
-  const capacity = input.capacity ?? DEFAULT_APPROVAL_TIMELINE_CAPACITY;
-  const ttlMs = input.ttlMs ?? DEFAULT_APPROVAL_TIMELINE_TTL_MS;
-  if (!Number.isSafeInteger(capacity) || capacity <= 0) {
-    throw new ByokCloudError(
-      "coordination_input_invalid",
-      `Approval timeline capacity must be a positive integer, received ${String(capacity)}.`
-    );
-  }
-  if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
-    throw new ByokCloudError(
-      "coordination_input_invalid",
-      `Approval timeline ttl must be a positive number of milliseconds, received ${String(ttlMs)}.`
-    );
-  }
-  const parsed = z.object({
-    taskId: TaskIdSchema,
-    sourceEnvelopeId: NonBlankIdSchema,
-    event: ApprovalTimelineEventSchema
-  }).safeParse(input);
-  if (!parsed.success) {
-    throw new ByokCloudError(
-      "coordination_input_invalid",
-      "Approval observations require stable source identity and a valid native lifecycle event."
-    );
+
+// src/auth/tokens.ts
+var ACCESS_TOKEN_TTL_SECONDS = 60 * 60;
+function encodeSegment(value) {
+  return base64UrlEncode(new TextEncoder().encode(JSON.stringify(value)));
+}
+function createHmacTokenSigner(secret, clock) {
+  async function signingKey(usage) {
+    return globalThis.crypto.subtle.importKey("raw", secret, { name: "HMAC", hash: "SHA-256" }, false, [usage]);
   }
-  if (parsed.data.event.type === "approval_requested" && new TextEncoder().encode(parsed.data.event.summary).byteLength > APPROVAL_SUMMARY_MAX_BYTES) {
-    throw new ByokCloudError(
-      "coordination_input_invalid",
-      `Approval summary exceeds ${APPROVAL_SUMMARY_MAX_BYTES} UTF-8 bytes.`
-    );
+  async function signature(signingInput) {
+    const key = await signingKey("sign");
+    const bytes = await globalThis.crypto.subtle.sign("HMAC", key, new TextEncoder().encode(signingInput));
+    return base64UrlEncode(new Uint8Array(bytes));
   }
-  return { capacity, ttlMs, event: parsed.data.event };
+  return {
+    async sign(claims, expiresInSeconds) {
+      const issuedAt = Math.floor(clock.now().getTime() / 1e3);
+      const header = encodeSegment({ alg: "HS256", typ: "JWT" });
+      const payload = encodeSegment({
+        deviceId: claims.deviceId,
+        tenantId: claims.tenantId,
+        productId: claims.productId,
+        iat: issuedAt,
+        exp: issuedAt + expiresInSeconds
+      });
+      const signingInput = `${header}.${payload}`;
+      return `${signingInput}.${await signature(signingInput)}`;
+    },
+    async verify(token) {
+      const parts = token.split(".");
+      if (parts.length !== 3) return void 0;
+      const [header, payload, provided] = parts;
+      const key = await signingKey("verify");
+      const providedBytes = base64UrlDecode(provided);
+      if (providedBytes === void 0) return void 0;
+      const ok = await globalThis.crypto.subtle.verify(
+        "HMAC",
+        key,
+        providedBytes,
+        new TextEncoder().encode(`${header}.${payload}`)
+      );
+      if (!ok) return void 0;
+      const headerBytes = base64UrlDecode(header);
+      const payloadBytes = base64UrlDecode(payload);
+      if (headerBytes === void 0 || payloadBytes === void 0) return void 0;
+      let decodedHeader;
+      let decodedPayload;
+      try {
+        decodedHeader = JSON.parse(new TextDecoder().decode(headerBytes));
+        decodedPayload = JSON.parse(new TextDecoder().decode(payloadBytes));
+      } catch {
+        return void 0;
+      }
+      const alg = decodedHeader?.alg;
+      if (alg !== "HS256") return void 0;
+      const { deviceId, tenantId: tenantId4, productId, exp } = decodedPayload;
+      if (typeof deviceId !== "string" || typeof tenantId4 !== "string" || typeof productId !== "string") {
+        return void 0;
+      }
+      if (typeof exp !== "number" || clock.now().getTime() / 1e3 >= exp) return void 0;
+      return { deviceId, tenantId: tenantId4, productId };
+    }
+  };
 }
-function validateApprovalTimelineResolve(input) {
-  const validated = validateApprovalTimelineAppend(input);
-  const expected = z.object({
-    expectedSourceEnvelopeId: NonBlankIdSchema,
-    expectedRevision: z.number().int().positive()
-  }).safeParse(input);
-  if (!expected.success || validated.event.type !== "approval_resolved" || validated.event.resolvedBy !== "host") {
-    throw new ByokCloudError(
-      "coordination_input_invalid",
-      "Host approval resolution requires an exact pending source/revision and a host resolution event."
-    );
-  }
-  return validated;
+function verifyNonceSignature(crypto2, devicePublicKey, nonce, signature) {
+  return crypto2.verifyEd25519(devicePublicKey, NONCE_SIGNING_DOMAIN + nonce, signature);
 }
-function approvalTimelineKey(tenant, taskId) {
-  return tenantKey(tenant, taskId);
+
+// src/auth/plane.ts
+var PAIRING_CODE_TTL_MS = 10 * 60 * 1e3;
+var PAIRING_CODE_LENGTH = 8;
+var DEVICE_IDENTITY_PROOF_KEY_ID = "identity";
+var DEVICE_IDENTITY_PROOF_KEY_EPOCH = 0;
+function createAuthPlane(deps) {
+  const { stores, crypto: crypto2, clock, tokenSigner } = deps;
+  const ttlSeconds = deps.accessTokenTtlSeconds ?? ACCESS_TOKEN_TTL_SECONDS;
+  return {
+    async createPairingCode(tenant, input) {
+      const expiresAt = new Date(clock.now().getTime() + (input.ttlMs ?? PAIRING_CODE_TTL_MS)).toISOString();
+      return stores.pairingCodes.issue(tenant, {
+        code: crypto2.randomPairingCode(PAIRING_CODE_LENGTH),
+        productId: input.productId,
+        expiresAt
+      });
+    },
+    async redeemAndRegister(input) {
+      return stores.pairing.redeemAndRegister({
+        pairingCode: input.pairingCode,
+        deviceId: `dev_${crypto2.randomUuid()}`,
+        deviceName: input.deviceName,
+        devicePublicKey: input.devicePublicKey,
+        proofKeyId: DEVICE_IDENTITY_PROOF_KEY_ID,
+        proofKeyEpoch: DEVICE_IDENTITY_PROOF_KEY_EPOCH,
+        ...input.machineId === void 0 ? {} : { machineId: input.machineId }
+      });
+    },
+    async resolveDevice(deviceId) {
+      const device = await stores.devices.resolveByDeviceId(deviceId);
+      if (device === void 0 || device.revoked) return void 0;
+      return device;
+    },
+    issueNonce(device) {
+      return stores.nonces.issue(device.tenantId, device.deviceId);
+    },
+    consumeNonceIfValid(device, nonce) {
+      return stores.nonces.consumeIfValid(device.tenantId, device.deviceId, nonce);
+    },
+    verifySignature(device, nonce, signature) {
+      return verifyNonceSignature(crypto2, device.devicePublicKey, nonce, signature);
+    },
+    async mintAccessToken(device) {
+      const accessToken = await tokenSigner.sign(
+        { deviceId: device.deviceId, tenantId: device.tenantId, productId: device.productId },
+        ttlSeconds
+      );
+      return {
+        accessToken,
+        expiresAt: new Date(clock.now().getTime() + ttlSeconds * 1e3).toISOString()
+      };
+    }
+  };
 }
-function parseApprovalObservations(value) {
-  return z.array(ApprovalObservationSchema).parse(value);
+var CLOUD_CAPABILITIES = {
+  /** `GET /byok/events` long-poll receive (§8). */
+  eventsLongPoll: "events.longpoll",
+  /** `POST /byok/messages` batched send (§8.2). */
+  messagesBatch: "messages.batch",
+  /** The three bearer-authed blob routes: reserve/grant, explicit finalize, committed-only download (§7). */
+  blobsPresigned: "blobs.presigned",
+  /**
+   * The two presigned `/byok/blobs/:id/content` routes — cloud carrying the
+   * bytes itself.
+   *
+   * Split out of `blobs.presigned` because it was one capability describing two
+   * separable facts. A composition whose bytes live in object storage mints
+   * grants (`blobs.presigned`) but has no byte-proxy path at all, and saying so
+   * by declaration is ADR-010's whole posture: a client reads what a deployment
+   * serves, it never probes a `/content` route and interprets the status code.
+   *
+   * Spelled all-lowercase because core's declaration schema pins capability
+   * names to `/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/` — the same reason the sibling
+   * above reads `events.longpoll` and not `events.longPoll`.
+   */
+  blobsContentProxy: "blobs.contentproxy",
+  /** Board list/claim/unclaim/status routes. Polling is first-class under this declaration. */
+  boardCoordination: "board.coordination",
+  /** Additional SSE transport for the same board read model. */
+  boardSse: "board.sse",
+  /** Device-scoped five-level presence publication. */
+  presenceHints: "presence.hints",
+  /** Bounded task activity batch publication. */
+  activityTail: "activity.tail",
+  /** Request-bound device proof record manifest/read/write surface (S6). */
+  truthRecords: "truth.records",
+  /**
+   * Tenant-scoped skill pack distribution: the manifest list plus the per-file
+   * content route a paired device installs from.
+   *
+   * Hosted HTTP on purpose. A pack is DECLARATIVE CONTENT a device pulls after
+   * reading this declaration — not a message — so `@byok-sdk/protocol` gains
+   * nothing from it and the frozen v1 envelope stays untouched. Composition-
+   * bound like `truth.records`: a deployment that declares it without supplying
+   * a `SkillPackStore` is refused at construction rather than publishing two
+   * routes it would then 404.
+   */
+  skillPacks: "skills.pack",
+  /** Optional, one-way redacted Agent-memory snapshot mutation route. */
+  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 = {}) {
+  return {
+    schema: "byok-capabilities-v1",
+    version,
+    capabilities: Object.values(CLOUD_CAPABILITIES).filter((capability) => {
+      if (capability === CLOUD_CAPABILITIES.truthRecords) return options.includeTruthRecords === true;
+      if (capability === CLOUD_CAPABILITIES.skillPacks) return options.includeSkillPacks === true;
+      if (capability === CLOUD_CAPABILITIES.agentMemoryProjection) {
+        return options.includeAgentMemoryProjection === true;
+      }
+      if (capability === CLOUD_CAPABILITIES.hostMcpTaskContext) {
+        return options.includeHostMcpTaskContext === true;
+      }
+      return true;
+    })
+  };
 }
-function approvalTimelineCursor(entries) {
-  return entries.at(-1)?.revision;
+function declares(declaration, capability) {
+  return hasCapability(declaration, capability);
+}
+function extractBearerToken(header) {
+  if (header === void 0) return void 0;
+  const match = /^Bearer\s+(.+)$/i.exec(header);
+  return match?.[1];
+}
+async function authenticateBearer(header, deps) {
+  const token = extractBearerToken(header);
+  if (token === void 0) return void 0;
+  const claims = await deps.tokenSigner.verify(token);
+  if (claims === void 0) return void 0;
+  if (!isTenantId(claims.tenantId)) return void 0;
+  const device = await deps.devices.get(tenantId(claims.tenantId), claims.deviceId);
+  if (device === void 0 || device.revoked) return void 0;
+  if (device.productId !== claims.productId) return void 0;
+  if (deps.instanceProductId !== void 0 && claims.productId !== deps.instanceProductId) {
+    return void 0;
+  }
+  return {
+    kind: "device",
+    tenantId: device.tenantId,
+    productId: device.productId,
+    deviceId: device.deviceId
+  };
+}
+function tenantStoresFor(principal, root) {
+  const tenant = principalTenant(principal);
+  const { core, cloud } = root;
+  return {
+    tenant,
+    principal,
+    mailbox: {
+      append: (input) => core.mailbox.append(tenant, input),
+      readAfter: (query) => core.mailbox.readAfter(tenant, query),
+      recordDelivery: (input) => core.mailbox.recordDelivery(tenant, input),
+      advanceCursor: (input) => core.mailbox.advanceCursor(tenant, input),
+      readCursor: (deviceId) => core.mailbox.readCursor(tenant, deviceId)
+    },
+    board: {
+      create: (input) => core.board.create(tenant, input),
+      get: (itemId) => core.board.get(tenant, itemId),
+      list: (query) => core.board.list(tenant, query),
+      claim: (input) => core.board.claim(tenant, input),
+      unclaim: (input) => core.board.unclaim(tenant, input),
+      updateStatus: (input) => core.board.updateStatus(tenant, input)
+    },
+    presence: {
+      publish: (input) => core.presence.publish(tenant, input),
+      read: (deviceId) => core.presence.read(tenant, deviceId),
+      list: () => core.presence.list(tenant)
+    },
+    activity: {
+      append: (input) => cloud.activity.append(tenant, input),
+      read: (taskId) => cloud.activity.read(tenant, taskId)
+    },
+    approvals: {
+      append: (input) => cloud.approvals.append(tenant, input),
+      read: (taskId) => cloud.approvals.read(tenant, taskId)
+    },
+    devices: {
+      get: (deviceId) => cloud.devices.get(tenant, deviceId),
+      list: () => cloud.devices.list(tenant),
+      revoke: (deviceId) => cloud.devices.revoke(tenant, deviceId),
+      recordCapabilities: (input) => principal.kind === "device" ? cloud.devices.recordCapabilities(tenant, {
+        deviceId: principal.deviceId,
+        capabilities: input.capabilities,
+        ...input.harnesses === void 0 ? {} : { harnesses: input.harnesses }
+      }) : Promise.resolve(void 0),
+      readiness: () => cloud.devices.readiness(tenant, core.presence)
+    },
+    tasks: {
+      open: (input) => cloud.tasks.open(tenant, input),
+      reserveAgentOffer: (input) => cloud.tasks.reserveAgentOffer(tenant, input),
+      reserveAgentMessage: (input) => cloud.tasks.reserveAgentMessage(tenant, input),
+      readTaskAgentMessage: (input) => cloud.tasks.readTaskAgentMessage(tenant, input),
+      readAgentMessage: (input) => cloud.tasks.readAgentMessage(tenant, input),
+      finalizeAgentMessage: (input) => cloud.tasks.finalizeAgentMessage(tenant, input),
+      get: (taskId) => cloud.tasks.get(tenant, taskId),
+      getMany: (taskIds) => cloud.tasks.getMany(tenant, taskIds),
+      list: (query) => cloud.tasks.list(tenant, query),
+      claim: (input) => cloud.tasks.claim(tenant, input),
+      recordStatus: (input) => cloud.tasks.recordStatus(tenant, input)
+    },
+    cancellations: {
+      request: (input) => cloud.cancellations.request(tenant, input)
+    },
+    dedup: {
+      checkAndRecord: (deviceId, envelopeId) => cloud.dedup.checkAndRecord(tenant, deviceId, envelopeId),
+      checkAndRecordAgent: (deviceId, agentRef, envelopeId) => cloud.dedup.checkAndRecordAgent(tenant, deviceId, agentRef, envelopeId)
+    },
+    receipts: {
+      record: (input) => cloud.receipts.record(tenant, input),
+      get: (key) => cloud.receipts.get(tenant, key)
+    },
+    egress: {
+      record: (input) => cloud.egress.record(tenant, input),
+      get: (deviceId, agentRef, eventId) => cloud.egress.get(tenant, deviceId, agentRef, eventId)
+    },
+    blobs: {
+      createUpload: (reservation) => cloud.blobs.createUpload(tenant, reservation),
+      observeUpload: (blobId, reservation) => cloud.blobs.observeUpload(tenant, blobId, reservation),
+      getDownloadUrl: (blobId) => cloud.blobs.getDownloadUrl(tenant, blobId)
+    },
+    quota: {
+      readReservation: (reservationId) => core.quota.readReservation(tenant, reservationId),
+      reserve: (input) => core.quota.reserve(tenant, input),
+      finalizeReservation: (input) => core.quota.finalizeReservation(tenant, input),
+      abortReservation: (reservationId) => core.quota.abortReservation(tenant, reservationId)
+    },
+    rateLimiter: {
+      consume: (deviceId) => cloud.rateLimiter.consume(tenant, deviceId)
+    }
+  };
 }
-async function projectTerminalToReview(board, taskId) {
-  const item = await board.get(taskId);
-  if (item === void 0 || item.status !== "in_progress") return;
+
+// src/handlers/shared.ts
+async function readJsonBody(c) {
   try {
-    await board.updateStatus({
-      itemId: taskId,
-      expectedStatus: "in_progress",
-      status: "in_review"
-    });
-  } catch (caught) {
-    if (isCoreConflictError(caught)) return;
-    throw caught;
+    return await c.req.json();
+  } catch {
+    return void 0;
   }
 }
-function agentReliabilityKey(domain, deviceId, agentRef, id) {
-  const exact = AgentRefSchema.parse(agentRef);
-  return `${domain}:${JSON.stringify([deviceId, exact.agentId, exact.profileRevision, id])}`;
-}
-
-// src/inbound.ts
-async function handleAgentMessagePublish(stores, deviceId, taskId, payload, consume, alreadyDeduplicated) {
-  const device = await stores.devices.get(deviceId);
-  const attempt = await stores.tasks.get(taskId);
-  const binding = await stores.receipts.get(`agent-message-offer:${deviceId}:${taskId}`);
-  if (device === void 0 || device.revoked || !hasCapabilities(device.capabilities, [AGENT_MESSAGE_EGRESS_CAPABILITY]) || attempt === void 0 || attempt.deviceId !== deviceId || binding === void 0 || attempt.agentRef === void 0 || !sameAgentRef(attempt.agentRef, payload.agentRef)) return { outcome: "rejected" };
-  let frozen;
+async function readBoundedJsonBody(c, maximum) {
+  const declaredLength = c.req.header("content-length");
+  if (declaredLength !== void 0) {
+    const parsedLength = parseContentLength(declaredLength);
+    if (parsedLength !== void 0 && parsedLength > BigInt(maximum)) {
+      cancelBody(c.req.raw.body);
+      return { body: void 0, tooLarge: true };
+    }
+  }
+  const stream = c.req.raw.body;
+  if (stream === null) return { body: void 0, tooLarge: false };
+  const reader = stream.getReader();
+  const chunks = [];
+  let total = 0;
   try {
-    frozen = JSON.parse(binding.body);
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value.byteLength > maximum - total) {
+        cancelBody(reader);
+        return { body: void 0, tooLarge: true };
+      }
+      if (value.byteLength === 0) continue;
+      chunks.push(value);
+      total += value.byteLength;
+    }
   } catch {
-    return { outcome: "rejected" };
+    return { body: void 0, tooLarge: false };
+  } finally {
+    reader.releaseLock();
   }
-  if (!sameAgentRef(frozen.agentRef, payload.agentRef) || frozen.context === void 0 || frozen.requirement?.contract !== payload.contract || frozen.sessionRef !== void 0 && frozen.sessionRef !== payload.sessionRef || frozen.requirement.contentType !== payload.contentType || typeof frozen.requirement.maxBytes !== "number" || payload.byteCount > frozen.requirement.maxBytes) return { outcome: "rejected" };
-  const priorDisposition = await readAgentMessageDisposition(stores, deviceId, taskId, payload);
-  if (priorDisposition !== void 0) return { outcome: "duplicate", disposition: priorDisposition };
-  const payloadBody = JSON.stringify(payload);
-  const reservation = await stores.tasks.reserveAgentMessage({
-    taskId,
-    deviceId,
-    messageId: payload.messageId,
-    payloadBody
-  });
-  if (reservation !== "reserved" && reservation !== "pending") return { outcome: "rejected" };
-  let decision;
-  if (consume === void 0) {
-    if (reservation === "pending") {
-      throw new Error("Agent message consumer is unavailable while reconciling an exact pending admission.");
-    }
-    decision = { outcome: "held", reasonCode: "consumer_unavailable" };
-  } else {
-    decision = await consume({ tenant: stores.tenant, deviceId, taskId, context: frozen.context, payload });
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
   }
-  const disposition = agentMessageDisposition(payload, decision);
-  const admission = await stores.tasks.finalizeAgentMessage({
-    taskId,
-    deviceId,
-    messageId: payload.messageId,
-    payloadBody,
-    terminalBody: JSON.stringify({ payload, disposition })
-  });
-  const terminal = admission?.terminalBody === void 0 ? void 0 : parseAgentMessageDisposition(payload, admission.terminalBody);
-  return terminal === void 0 ? { outcome: "rejected" } : { outcome: "accepted", disposition: terminal };
-}
-function agentMessageDisposition(payload, decision) {
-  return {
-    agentRef: payload.agentRef,
-    sessionRef: payload.sessionRef,
-    contract: payload.contract,
-    messageId: payload.messageId,
-    cursor: payload.cursor,
-    contentHash: payload.contentHash,
-    outcome: decision.outcome,
-    receiptId: crypto.randomUUID(),
-    ...decision.reasonCode === void 0 ? {} : { reasonCode: decision.reasonCode }
-  };
-}
-async function readAgentMessageDisposition(stores, deviceId, taskId, payload) {
-  const admission = await stores.tasks.readAgentMessage({
-    taskId,
-    deviceId,
-    messageId: payload.messageId,
-    payloadBody: JSON.stringify(payload)
-  });
-  return admission?.terminalBody === void 0 ? void 0 : parseAgentMessageDisposition(payload, admission.terminalBody);
+  return { body: parseJsonBytes(bytes), tooLarge: false };
 }
-function parseAgentMessageDisposition(payload, terminalBody) {
+function cancelBody(body) {
+  if (body === null) return;
   try {
-    const decoded = JSON.parse(terminalBody);
-    return decoded.disposition !== void 0 && JSON.stringify(decoded.payload) === JSON.stringify(payload) ? decoded.disposition : void 0;
+    void Promise.resolve(body.cancel()).catch(() => {
+    });
   } catch {
-    return void 0;
   }
 }
-function terminalReceiptKey(taskId) {
-  return `task:${taskId}:terminal`;
-}
-function sameAgentRef(expected, actual) {
-  return actual?.agentId === expected.agentId && actual.profileRevision === expected.profileRevision;
-}
-function sameReliableEgress(expected, actual) {
-  return sameAgentRef(expected.agentRef, actual.agentRef) && expected.sessionRef === actual.sessionRef && expected.policyRevision === actual.policyRevision && expected.eventId === actual.eventId && expected.cursor === actual.cursor && expected.contentHash === actual.contentHash && expected.byteCount === actual.byteCount && JSON.stringify(expected.payload) === JSON.stringify(actual.payload);
-}
-function contentReadCapability(surface) {
-  switch (surface) {
-    case "workspace":
-      return AGENT_CONTENT_WORKSPACE_READ_CAPABILITY;
-    case "transcript":
-      return AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY;
-    case "artifact":
-      return AGENT_CONTENT_ARTIFACT_READ_CAPABILITY;
+function parseContentLength(value) {
+  const normalized = value.trim();
+  if (!/^\d+$/u.test(normalized)) return void 0;
+  try {
+    return BigInt(normalized);
+  } catch {
+    return void 0;
   }
 }
-function hasCapabilities(capabilities, required) {
-  return capabilities !== void 0 && required.every((capability) => capabilities.includes(capability));
-}
-function contentRequestReceiptKey(deviceId, agentRef, requestId) {
-  return agentReliabilityKey("agent-content-request", deviceId, agentRef, requestId);
-}
-function contentReceiptKey(deviceId, agentRef, requestId) {
-  return agentReliabilityKey("agent-content-receipt", deviceId, agentRef, requestId);
-}
-function matchesContentReadReceipt(request, receipt) {
-  return request.requestId === receipt.requestId && request.surface === receipt.surface && request.actor.kind === receipt.actor.kind && request.actor.id === receipt.actor.id && sameAgentRef(request.agentRef, receipt.agentRef) && request.sessionRef === receipt.sessionRef && request.runtime === receipt.runtime && request.cwd === receipt.cwd && request.policyRevision === receipt.policyRevision && request.target === receipt.target && request.mimeType === receipt.mimeType && request.decodeAs === receipt.decodeAs;
-}
-async function readContentRequest(stores, deviceId, agentRef, requestId) {
-  const stored = await stores.receipts.get(contentRequestReceiptKey(deviceId, agentRef, requestId));
-  if (stored === void 0) return void 0;
+function parseJsonBytes(bytes) {
   try {
-    return AgentContentReadPayloadSchema.parse(JSON.parse(stored.body));
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
   } catch {
     return void 0;
   }
 }
-function inboundAgentRef(envelope) {
-  switch (envelope.type) {
-    case "task.claim":
-    case "task.decline":
-    case "task.complete":
-    case "task.fail":
-    case "task.cancelled":
-      return envelope.payload.agentRef;
-    default:
-      return void 0;
-  }
+async function authenticateDevice(c, deps) {
+  const device = await authenticateBearer(c.req.header("authorization"), deps.bearer);
+  if (device === void 0) return void 0;
+  return { device, stores: tenantStoresFor(device, deps.root) };
 }
-function agentRefEchoRequired(envelope) {
-  return envelope.type === "task.claim" || envelope.type === "task.decline" || envelope.type === "task.complete" || envelope.type === "task.fail" || envelope.type === "task.cancelled";
+
+// src/handlers/blobs.ts
+var BLOB_RESERVATION_TTL_MS = 15 * 60 * 1e3;
+var SignedUrlQuerySchema = z.object({
+  sig: z.string().min(1),
+  exp: z.coerce.number().finite()
+});
+function createBlobHandler(deps) {
+  return async (c) => {
+    const authenticated = await authenticateDevice(c, deps);
+    if (authenticated === void 0) return c.json({ error: "unauthorized" }, 401);
+    const parsed = CreateBlobRequestSchema.safeParse(await readJsonBody(c));
+    if (!parsed.success) return c.json({ error: "size, contentType, and contentHash are required" }, 400);
+    if (parsed.data.size > deps.maxBlobSizeBytes) {
+      return c.json({ error: `blob exceeds max size of ${deps.maxBlobSizeBytes} bytes` }, 413);
+    }
+    const reservationId = idempotencyKey(c);
+    if (reservationId === void 0) {
+      return c.json({ error: "Idempotency-Key header is required" }, 400);
+    }
+    try {
+      const reservation = await authenticated.stores.quota.reserve({
+        reservationId,
+        kind: "object",
+        expectedBytes: BigInt(parsed.data.size),
+        contentHash: contentHash(parsed.data.contentHash),
+        contentType: parsed.data.contentType,
+        ttlMs: BLOB_RESERVATION_TTL_MS
+      });
+      try {
+        const { blobId, uploadUrl } = await authenticated.stores.blobs.createUpload(reservation);
+        const response = { blobId, uploadUrl };
+        return c.json(response, 200);
+      } catch (error) {
+        await authenticated.stores.quota.abortReservation(reservationId).catch(() => void 0);
+        const rendered = renderStorageError(c, error);
+        if (rendered !== void 0) return rendered;
+        throw error;
+      }
+    } catch (error) {
+      const rendered = renderStorageError(c, error);
+      if (rendered !== void 0) return rendered;
+      throw error;
+    }
+  };
 }
-async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds = DEFAULT_ACTIVITY_BOUNDS, agentMessageConsume, observer) {
-  if (envelope.v !== PROTOCOL_VERSION) return "rejected";
-  const outcome = await applyInboundGate(
-    stores,
-    deviceId,
-    envelope,
-    activityBounds,
-    agentMessageConsume
-  );
-  if (outcome === "accepted" && observer !== void 0) {
+function finalizeBlobHandler(deps) {
+  return async (c) => {
+    const authenticated = await authenticateDevice(c, deps);
+    if (authenticated === void 0) return c.json({ error: "unauthorized" }, 401);
+    const reservationId = idempotencyKey(c);
+    if (reservationId === void 0) {
+      return c.json({ error: "Idempotency-Key header is required" }, 400);
+    }
     try {
-      observer.onInboundCommitted({ tenantId: stores.tenant, deviceId, envelope, outcome });
-    } catch {
+      const reservation = await authenticated.stores.quota.readReservation(reservationId);
+      if (reservation === void 0) {
+        return c.json({ error: "storage_reservation_not_found" }, 404);
+      }
+      const blobId = c.req.param("id") ?? "";
+      const observed = await authenticated.stores.blobs.observeUpload(
+        blobId,
+        reservation
+      );
+      if (observed === void 0) {
+        await authenticated.stores.quota.abortReservation(reservationId);
+        return c.json({ error: "storage_integrity_mismatch" }, 422);
+      }
+      await authenticated.stores.quota.finalizeReservation({
+        reservationId,
+        ...observed
+      });
+      return c.body(null, 204);
+    } catch (error) {
+      const rendered = renderStorageError(c, error);
+      if (rendered !== void 0) return rendered;
+      throw error;
     }
-  }
-  return outcome;
+  };
 }
-async function applyInboundGate(stores, deviceId, envelope, activityBounds, agentMessageConsume) {
-  if (!await stores.rateLimiter.consume(deviceId)) return "rate_limited";
-  if (envelope.type === "conn.hello") {
-    if (envelope.payload.deviceId !== deviceId) return "rejected";
-    if (envelope.payload.harnesses !== void 0 && !envelope.payload.capabilities.includes("custom-harness")) return "rejected";
-    if (!envelope.payload.protocolVersions.includes(PROTOCOL_VERSION)) return "rejected";
-    const device = await stores.devices.get(deviceId);
-    if (device === void 0 || device.revoked || device.productId !== envelope.payload.productId) {
-      return "rejected";
+function blobDownloadUrlHandler(deps) {
+  return async (c) => {
+    const authenticated = await authenticateDevice(c, deps);
+    if (authenticated === void 0) return c.json({ error: "unauthorized" }, 401);
+    const downloadUrl = await authenticated.stores.blobs.getDownloadUrl(c.req.param("id") ?? "");
+    if (downloadUrl === void 0) return c.json({ error: "blob not found" }, 404);
+    const response = { downloadUrl };
+    return c.json(response, 200);
+  };
+}
+function blobUploadContentHandler(deps) {
+  return async (c) => {
+    const blobId = c.req.param("id") ?? "";
+    const query = SignedUrlQuerySchema.safeParse({ sig: c.req.query("sig"), exp: c.req.query("exp") });
+    if (!query.success || !await deps.contentProxy.verifySignedUrl(blobId, "put", query.data.sig, query.data.exp)) {
+      return c.json({ error: "invalid or expired signature" }, 401);
     }
-    if (await stores.devices.recordCapabilities({ capabilities: envelope.payload.capabilities, ...envelope.payload.harnesses === void 0 ? {} : { harnesses: envelope.payload.harnesses } }) === void 0) {
-      return "rejected";
+    const expectedBytes = await deps.contentProxy.expectedUploadBytes(blobId);
+    if (expectedBytes === void 0) return c.json({ error: "blob not found" }, 404);
+    const absoluteCeiling = BigInt(deps.maxUploadBytes);
+    if (expectedBytes > absoluteCeiling) return c.json({ error: "upload exceeds size limit" }, 413);
+    const contentLength = c.req.header("content-length");
+    if (contentLength !== void 0 && /^\d+$/u.test(contentLength) && BigInt(contentLength) > expectedBytes) {
+      return c.json({ error: "upload exceeds declared size" }, 413);
     }
-    return completeInboundEnvelope(stores, deviceId, envelope.id, void 0);
-  }
-  if (!DAEMON_TO_SERVER_TYPES.includes(envelope.type)) return "rejected";
-  if (envelope.type === "agent.message.publish") {
-    const message = await handleAgentMessagePublish(
-      stores,
-      deviceId,
-      envelope.task_id,
-      envelope.payload,
-      agentMessageConsume);
-    return message.outcome === "rejected" ? "rejected" : completeInboundEnvelope(stores, deviceId, envelope.id, envelope.payload.agentRef);
-  }
-  if (envelope.type === "agent.egress.reliable") {
-    const device = await stores.devices.get(deviceId);
-    if (device === void 0 || device.revoked || !hasCapabilities(device.capabilities, [AGENT_EGRESS_POLICY_CAPABILITY, AGENT_EGRESS_RELIABLE_ACK_CAPABILITY])) {
-      return "rejected";
+    const body = await readBoundedBody(c.req.raw.body, Number(expectedBytes));
+    if (body.tooLarge) return c.json({ error: "upload exceeds declared size" }, 413);
+    const result = await deps.contentProxy.writeContent(blobId, body.data);
+    if (!result.ok) return c.json({ error: result.reason }, 422);
+    return c.body(null, 204);
+  };
+}
+async function readBoundedBody(body, ceiling) {
+  if (body === null) return { tooLarge: false, data: new Uint8Array() };
+  const reader = body.getReader();
+  const data = new Uint8Array(ceiling);
+  let offset = 0;
+  try {
+    for (; ; ) {
+      const next = await reader.read();
+      if (next.done) break;
+      const chunk = next.value;
+      if (chunk.byteLength > ceiling - offset) {
+        void reader.cancel().catch(() => void 0);
+        return { tooLarge: true };
+      }
+      data.set(chunk, offset);
+      offset += chunk.byteLength;
     }
-    const outcome = await stores.egress.record({
-      deviceId,
-      payload: envelope.payload,
-      receiptId: crypto.randomUUID()
-    });
-    if (!outcome.created && !sameReliableEgress(outcome.record.payload, envelope.payload)) return "rejected";
-    return completeInboundEnvelope(stores, deviceId, envelope.id, envelope.payload.agentRef);
+  } finally {
+    reader.releaseLock();
   }
-  if (envelope.type === "agent.content.receipt") {
-    const device = await stores.devices.get(deviceId);
-    if (device === void 0 || device.revoked || envelope.payload.eventId !== envelope.payload.requestId || !hasCapabilities(device.capabilities, [contentReadCapability(envelope.payload.surface), AGENT_EGRESS_RELIABLE_ACK_CAPABILITY])) {
-      return "rejected";
+  return { tooLarge: false, data: data.subarray(0, offset) };
+}
+function blobDownloadContentHandler(deps) {
+  return async (c) => {
+    const blobId = c.req.param("id") ?? "";
+    const query = SignedUrlQuerySchema.safeParse({ sig: c.req.query("sig"), exp: c.req.query("exp") });
+    if (!query.success || !await deps.contentProxy.verifySignedUrl(blobId, "get", query.data.sig, query.data.exp)) {
+      return c.json({ error: "invalid or expired signature" }, 401);
     }
-    const request = await readContentRequest(stores, deviceId, envelope.payload.agentRef, envelope.payload.requestId);
-    if (request === void 0 || !matchesContentReadReceipt(request, envelope.payload)) return "rejected";
-    const key = contentReceiptKey(deviceId, envelope.payload.agentRef, envelope.payload.requestId);
-    const body = JSON.stringify(envelope.payload);
-    const receipt = await stores.receipts.record({ key, body });
-    if (!receipt.created && receipt.receipt.body !== body) return "rejected";
-    return completeInboundEnvelope(stores, deviceId, envelope.id, envelope.payload.agentRef);
+    const result = await deps.contentProxy.readContent(blobId);
+    if (result === void 0) return c.json({ error: "blob not found" }, 404);
+    if (!result.ok) return c.json({ error: result.code }, BLOB_READ_ERROR_HTTP_STATUS[result.code]);
+    return c.body(new Uint8Array(result.content.data), 200, { "content-type": result.content.contentType });
+  };
+}
+var BLOB_READ_ERROR_HTTP_STATUS = {
+  blob_upstream_unavailable: 502,
+  blob_upstream_stream_interrupted: 502
+};
+function idempotencyKey(c) {
+  const value = c.req.header("Idempotency-Key");
+  if (value === void 0 || value.length === 0 || value.length > 200) return void 0;
+  return value;
+}
+function renderStorageError(c, error) {
+  if (!isCoreError(error)) return void 0;
+  if (STORAGE_ERROR_CODES.includes(error.code)) {
+    const code = error.code;
+    return c.json({ error: code }, STORAGE_ERROR_HTTP_STATUS[code]);
   }
-  const taskId = envelope.task_id;
-  if (taskId === void 0) return "rejected";
-  const attempt = await stores.tasks.get(taskId);
-  if (attempt === void 0 || attempt.deviceId !== deviceId) return "rejected";
-  if (attempt?.ownerDeviceId !== void 0 && attempt.ownerDeviceId !== deviceId) return "rejected";
-  if (envelope.type === "task.claim" && envelope.payload.deviceId !== deviceId) return "rejected";
-  if (envelope.type === "task.claim") {
-    const harnessId = envelope.payload.harnessId;
-    if (harnessId !== void 0 && envelope.payload.runtime !== void 0) return "rejected";
-    if (attempt.ownerDeviceId !== void 0 && (harnessId !== void 0 || attempt.claimedHarnessId !== void 0) && harnessId !== attempt.claimedHarnessId) return "rejected";
-    const device = await stores.devices.get(deviceId);
-    if (harnessId !== void 0 && (!device?.capabilities?.includes("custom-harness") || !device.harnesses?.some((harness) => harness.id === harnessId))) return "rejected";
-    const messageId = await taskOfferMessageId(stores.tenant, taskId, deviceId, attempt.agentRef, hashOfferBytes);
-    const offer = await stores.receipts.get(`task-offer:${messageId}`);
-    if (offer !== void 0) {
-      const sealed = JSON.parse(offer.body);
-      if (harnessId !== void 0 && (sealed.payload.runtime !== void 0 || sealed.payload.dispatchSelection !== void 0)) return "rejected";
-      if (sealed.payload.harnessId !== void 0 && sealed.payload.harnessId !== harnessId) return "rejected";
-    } else if (harnessId !== void 0) return "rejected";
+  if (error.code === "storage_reservation_not_found" || error.code === "object_not_found") {
+    return c.json({ error: error.code }, 404);
   }
-  let unclaimedInterruption = false;
-  if (envelope.type === "task.fail" && envelope.payload.recovery !== void 0) {
-    if (envelope.payload.reason !== "daemon_interrupted" || envelope.payload.retryable !== false) return "rejected";
-    const messageId = await taskOfferMessageId(stores.tenant, taskId, deviceId, attempt.agentRef, hashOfferBytes);
-    if (envelope.payload.recovery.offerId !== messageId) return "rejected";
-    const offer = await stores.receipts.get(`task-offer:${messageId}`);
-    if (offer === void 0) return "rejected";
-    const sealed = JSON.parse(offer.body);
-    const harnessId = envelope.payload.harnessId;
-    if (sealed.payload.harnessId !== void 0 && sealed.payload.harnessId !== harnessId) return "rejected";
-    if (harnessId !== void 0 && (sealed.payload.runtime !== void 0 || sealed.payload.dispatchSelection !== void 0)) return "rejected";
-    unclaimedInterruption = attempt.ownerDeviceId === void 0 && attempt.claimedHarnessId === void 0;
+  if (error.code === "storage_entitlement_missing" || error.code === "object_state_invalid") {
+    return c.json({ error: error.code }, 409);
   }
-  if ((envelope.type === "task.complete" || envelope.type === "task.fail" || envelope.type === "task.cancelled") && !unclaimedInterruption && envelope.payload.harnessId !== attempt.claimedHarnessId) return "rejected";
-  if (attempt?.agentRef !== void 0 && agentRefEchoRequired(envelope) && !sameAgentRef(attempt.agentRef, inboundAgentRef(envelope))) {
-    return "rejected";
+  if (error.code === "content_hash_invalid") {
+    return c.json({ error: error.code }, 400);
   }
-  if (envelope.type === "task.progress" && envelope.payload.events.length > 0) {
-    try {
-      validateActivityBatch(
-        {
-          taskId,
-          sourceEnvelopeId: envelope.id,
-          batchSeq: envelope.payload.seq,
-          events: envelope.payload.events,
-          dropped: 0
+  return void 0;
+}
+
+// src/handlers/capabilities.ts
+function capabilitiesHandler(deps) {
+  return async (c) => c.json(deps.declaration, 200);
+}
+var AUTH_JSON_BODY_MAX_BYTES = 16 * 1024;
+function pairHandler(deps) {
+  return async (c) => {
+    const body = await readBoundedJsonBody(c, AUTH_JSON_BODY_MAX_BYTES);
+    if (body.tooLarge) return c.json({ error: "request body too large" }, 413);
+    const parsed = PairRequestSchema.safeParse(body.body);
+    if (!parsed.success) {
+      return c.json(
+        {
+          error: "pairingCode, deviceName, and devicePublicKey are required strings; optional machineId must be 64 lowercase hex characters"
         },
-        activityBounds
+        400
       );
-    } catch (caught) {
-      if (isCloudError(caught, "activity_batch_too_large") || isCloudError(caught, "coordination_input_invalid")) {
-        return "rejected";
-      }
-      throw caught;
     }
-  }
-  const approvalInput = approvalTimelineAppendInput(taskId, envelope);
-  if (approvalInput !== void 0) {
-    try {
-      validateApprovalTimelineAppend(approvalInput);
-    } catch (caught) {
-      if (isCloudError(caught, "coordination_input_invalid")) return "rejected";
-      throw caught;
+    const device = await deps.auth.redeemAndRegister(parsed.data);
+    if (device === void 0) return c.json({ error: "invalid pairing code" }, 401);
+    const { accessToken, expiresAt } = await deps.auth.mintAccessToken(device);
+    const response = PairResponseSchema.parse({
+      deviceId: device.deviceId,
+      accessToken,
+      refreshHint: expiresAt,
+      tenantId: device.tenantId
+    });
+    return c.json(response, 200);
+  };
+}
+function challengeHandler(deps) {
+  return async (c) => {
+    const body = await readBoundedJsonBody(c, AUTH_JSON_BODY_MAX_BYTES);
+    if (body.tooLarge) return c.json({ error: "request body too large" }, 413);
+    const parsed = ChallengeRequestSchema.safeParse(body.body);
+    if (!parsed.success) return c.json({ error: "deviceId is required" }, 400);
+    const device = await deps.auth.resolveDevice(parsed.data.deviceId);
+    if (device === void 0) return c.json({ error: "unknown or revoked device" }, 401);
+    const response = { nonce: await deps.auth.issueNonce(device) };
+    return c.json(response, 200);
+  };
+}
+function tokenHandler(deps) {
+  return async (c) => {
+    const body = await readBoundedJsonBody(c, AUTH_JSON_BODY_MAX_BYTES);
+    if (body.tooLarge) return c.json({ error: "request body too large" }, 413);
+    const parsed = TokenRequestSchema.safeParse(body.body);
+    if (!parsed.success) return c.json({ error: "deviceId, nonce, and signature are required" }, 400);
+    const { deviceId, nonce, signature } = parsed.data;
+    const device = await deps.auth.resolveDevice(deviceId);
+    if (device === void 0) return c.json({ error: "unknown or revoked device" }, 401);
+    if (!await deps.auth.verifySignature(device, nonce, signature)) {
+      return c.json({ error: "invalid signature" }, 401);
     }
-  }
-  const lifecycleOutcome = await applyLifecycle(stores, deviceId, taskId, envelope, activityBounds, attempt?.agentRef);
-  if (lifecycleOutcome === "rejected") return "rejected";
-  return completeInboundEnvelope(stores, deviceId, envelope.id, attempt?.agentRef);
+    if (!await deps.auth.consumeNonceIfValid(device, nonce)) {
+      return c.json({ error: "invalid, expired, or already-used nonce" }, 401);
+    }
+    const { accessToken, expiresAt } = await deps.auth.mintAccessToken(device);
+    const response = { accessToken, expiresAt };
+    return c.json(response, 200);
+  };
 }
-async function completeInboundEnvelope(stores, deviceId, envelopeId, agentRef) {
-  const duplicate = agentRef === void 0 ? await stores.dedup.checkAndRecord(deviceId, envelopeId) : await stores.dedup.checkAndRecordAgent(deviceId, agentRef, envelopeId);
-  return duplicate ? "duplicate" : "accepted";
+var CLOUD_PROTOCOL_CAPABILITIES = [
+  "custom-harness",
+  MAILBOX_READ_AHEAD_CAPABILITY,
+  "result-document",
+  // The kernel's inbound handles `task.approval_resolved` on both the plain
+  // and the approval-timeline paths (`packages/cloud/src/inbound.ts:576,610`).
+  // Without this flag `TaskRunner.sendApprovalResolved` returns early and a
+  // locally-resolved approval is never reported on the wire at all.
+  "approval_resolved",
+  "agent-home-contract",
+  "agent-home-projection",
+  "agent-egress-policy",
+  "agent-egress-reliable-ack",
+  "agent-egress-fresh-session",
+  // `handleAgentMessagePublish` accepts `agent.message_egress` gated on exactly
+  // this capability (`packages/cloud/src/inbound.ts:124`) — the same inbound
+  // family as the three egress flags above, omitted by the same drift.
+  "agent-message-egress",
+  "agent-content-workspace-read",
+  "agent-content-transcript-read",
+  "agent-content-artifact-read"
+];
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function applyLifecycle(stores, deviceId, taskId, envelope, activityBounds, persistedAgentRef) {
-  switch (envelope.type) {
-    case "task.claim": {
-      const claimed = await stores.tasks.claim({
-        taskId,
-        deviceId,
-        ...envelope.payload.runtime === void 0 ? {} : { runtime: envelope.payload.runtime },
-        ...envelope.payload.harnessId === void 0 ? {} : { harnessId: envelope.payload.harnessId },
-        ...envelope.payload.capabilities === void 0 ? {} : { capabilities: envelope.payload.capabilities }
-      });
-      if (claimed === void 0 || claimed.ownerDeviceId !== deviceId || claimed.claimedRuntime !== envelope.payload.runtime || claimed.claimedHarnessId !== envelope.payload.harnessId) return "rejected";
-      return;
+function eventsHandler(deps) {
+  return async (c) => {
+    const authenticated = await authenticateDevice(c, deps);
+    if (authenticated === void 0) return c.json({ error: "unauthorized" }, 401);
+    const { device, stores } = authenticated;
+    const cursorRaw = c.req.query("cursor");
+    let cursor = 0;
+    if (cursorRaw !== void 0) {
+      const parsedCursor = Number(cursorRaw);
+      if (!Number.isSafeInteger(parsedCursor) || parsedCursor < 0) {
+        return c.json({ error: "invalid cursor" }, 400);
+      }
+      cursor = parsedCursor;
     }
-    case "task.started":
-      await stores.tasks.recordStatus({
-        taskId,
-        status: "running",
-        ...persistedAgentRef === void 0 ? {} : { agentRef: persistedAgentRef }
-      });
-      return;
-    case "task.decline":
-      await recordTerminal(stores, taskId, envelope);
-      return;
-    case "task.progress":
-      if (envelope.payload.events.length > 0) {
-        await appendActivityEvents(
-          stores.activity,
-          {
-            taskId,
-            sourceEnvelopeId: envelope.id,
-            batchSeq: envelope.payload.seq,
-            events: envelope.payload.events,
-            dropped: 0
-          },
-          activityBounds
-        );
+    const afterRaw = c.req.query("afterSeq");
+    const afterSeq = afterRaw === void 0 ? cursor : Number(afterRaw);
+    if (!Number.isSafeInteger(afterSeq) || afterSeq < cursor || afterSeq - cursor > MAILBOX_READ_AHEAD_MAX_SEQS) {
+      return c.json({ error: "invalid read-ahead offset" }, 400);
+    }
+    const acked = await stores.mailbox.readCursor(device.deviceId);
+    if (afterRaw !== void 0 && afterSeq > acked.deliveredSeq) return c.json({ error: "read offset exceeds delivered watermark" }, 409);
+    if (cursor > acked.ackedSeq) {
+      try {
+        await stores.mailbox.advanceCursor({ deviceId: device.deviceId, ackedSeq: cursor });
+      } catch (caught) {
+        if (isCoreConflictError(caught, "mailbox_cursor_ahead_of_delivery")) {
+          return c.json({ error: "cursor exceeds delivered watermark" }, 409);
+        }
+        throw caught;
       }
-      return;
-    case "task.await_approval":
-      await stores.approvals.append(approvalTimelineAppendInput(taskId, envelope));
-      return;
-    case "task.approval_resolved":
-      await stores.approvals.append(approvalTimelineAppendInput(taskId, envelope));
-      return;
-    case "task.complete":
-      await recordTerminal(stores, taskId, envelope);
-      return;
-    case "task.fail":
-      await recordTerminal(stores, taskId, envelope);
-      return;
-    case "task.cancelled":
-      await recordTerminal(stores, taskId, envelope);
-      return;
-    default:
-      return;
-  }
-}
-function approvalTimelineAppendInput(taskId, envelope) {
-  switch (envelope.type) {
-    case "task.await_approval":
-      return {
-        taskId,
-        sourceEnvelopeId: envelope.id,
-        event: {
-          type: "approval_requested",
-          summary: envelope.payload.summary,
-          ...envelope.payload.approvalId === void 0 ? {} : { approvalId: envelope.payload.approvalId }
+    }
+    const attempts = Math.max(1, Math.ceil(deps.longPollHoldMs / deps.longPollIntervalMs));
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+      let scanCursor = afterSeq;
+      while (true) {
+        const page = await stores.mailbox.readAfter({
+          deviceId: device.deviceId,
+          afterSeq: scanCursor,
+          limit: deps.pageLimit
+        });
+        if (cursor < page.recoverableFrom - 1) {
+          return c.json({ error: "cursor_too_old", recoverableFrom: page.recoverableFrom }, 409);
         }
-      };
-    case "task.approval_resolved":
-      return {
-        taskId,
-        sourceEnvelopeId: envelope.id,
-        event: {
-          type: "approval_resolved",
-          approvalId: envelope.payload.approvalId,
-          decision: envelope.payload.decision,
-          resolvedBy: envelope.payload.resolvedBy,
-          at: envelope.payload.at
+        if (page.messages.length === 0) break;
+        const decoded = page.messages.map((message) => decodeEnvelope(message.body));
+        const offeredTaskIds = decoded.flatMap(
+          (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 (!isTaskOfferType(event.type)) return true;
+          return event.task_id === void 0 || attemptsByTaskId[event.task_id]?.cancellation === void 0;
+        });
+        if (events.length === 0 && page.hasMore) {
+          scanCursor = page.nextSeq;
+          continue;
         }
-      };
-    default:
-      return void 0;
-  }
-}
-async function recordTerminal(stores, taskId, envelope) {
-  const receipt = await stores.receipts.record({
-    key: terminalReceiptKey(taskId),
-    body: encodeEnvelope(envelope)
-  });
-  const winner = terminalReceiptBinding(taskId, receipt.receipt.body);
-  if (winner === void 0) {
-    throw new Error(`terminal receipt for ${taskId} is not a canonical terminal binding`);
-  }
-  const attempt = await stores.tasks.get(taskId);
-  if (attempt?.cancellation !== void 0) {
-    await stores.tasks.recordStatus({
-      taskId,
-      status: "cancelled",
-      ...attempt.agentRef === void 0 ? {} : { agentRef: attempt.agentRef }
-    });
-    return;
-  }
-  const recordedAttempt = await stores.tasks.recordStatus({
-    taskId,
-    status: winner.status,
-    ...attempt?.agentRef === void 0 ? {} : { agentRef: attempt.agentRef },
-    ...winner.cause === void 0 ? {} : { terminalCause: winner.cause }
-  });
-  if (recordedAttempt?.cancellation !== void 0 || recordedAttempt?.status !== winner.status) {
-    if (recordedAttempt?.cancellation !== void 0) {
-      await stores.tasks.recordStatus({
-        taskId,
-        status: "cancelled",
-        ...recordedAttempt.agentRef === void 0 ? {} : { agentRef: recordedAttempt.agentRef }
-      });
+        if (events.length === 0) break;
+        const response2 = {
+          events,
+          cursor: page.nextSeq,
+          capabilities: CLOUD_PROTOCOL_CAPABILITIES
+        };
+        await stores.mailbox.recordDelivery({
+          deviceId: device.deviceId,
+          deliveredSeq: response2.cursor
+        });
+        return c.json(response2, 200);
+      }
+      if (attempt < attempts - 1) await sleep(deps.longPollIntervalMs);
     }
-    return;
-  }
-  await projectTerminalToReview(stores.board, taskId);
-}
-function terminalStatus(envelope) {
-  switch (envelope.type) {
-    case "task.complete":
-      return "complete";
-    case "task.fail":
-    case "task.decline":
-      return "failed";
-    case "task.cancelled":
-      return "cancelled";
-    default:
-      return void 0;
-  }
-}
-function terminalReceiptBinding(taskId, body) {
-  let envelope;
-  try {
-    envelope = decodeEnvelope(body);
-  } catch {
-    return void 0;
-  }
-  const status = terminalStatus(envelope);
-  if (status === void 0 || envelope.task_id !== taskId || encodeEnvelope(envelope) !== body) return void 0;
-  const cause = envelope.type === "task.fail" || envelope.type === "task.cancelled" || envelope.type === "task.decline" ? envelope.payload.reason : void 0;
-  return { status, ...cause === void 0 ? {} : { cause } };
+    const response = {
+      events: [],
+      cursor: afterSeq,
+      capabilities: CLOUD_PROTOCOL_CAPABILITIES
+    };
+    return c.json(response, 200);
+  };
 }
-
-// src/handlers/messages.ts
 var MESSAGES_JSON_BODY_MAX_BYTES = 2 * 1024 * 1024;
 function messagesHandler(deps) {
   return async (c) => {
@@ -1775,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) => {
@@ -2661,6 +2814,135 @@ 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") {
+    throw new ByokCloudError("terminal_receipt_unreadable", "Device terminal receipt identity or type is invalid.");
+  }
+  return { envelope, recordedAt: receipt.recordedAt };
+}
 function projectTerminalResult(taskId, receipt) {
   let envelope;
   try {
@@ -2830,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,
@@ -3340,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);
@@ -3474,6 +3788,36 @@ function createByokCloud(options) {
       throw new ByokCloudError("mailbox_receipt_mismatch", "Agent message disposition mailbox readback mismatched.");
     }
   }
+  async function enqueueFreshAgentEgressOffer(tenant, deviceId, input) {
+    await assertAgentCapabilities(tenant, deviceId, [
+      AGENT_HOME_CONTRACT_CAPABILITY,
+      AGENT_EGRESS_POLICY_CAPABILITY,
+      AGENT_EGRESS_RELIABLE_ACK_CAPABILITY,
+      AGENT_EGRESS_FRESH_SESSION_CAPABILITY,
+      ...input.payload.messageEgress === void 0 ? [] : [AGENT_MESSAGE_EGRESS_CAPABILITY],
+      ...input.payload.terminalProjection === void 0 ? [] : [TERMINAL_PROJECTION_SELECTION_CAPABILITY]
+    ]);
+    const payload = TaskOfferForAgentWithEgressFreshPayloadSchema.parse(input.payload);
+    if (payload.messageEgress === void 0 && input.agentMessageContext !== void 0) {
+      throw new Error("agentMessageContext requires messageEgress");
+    }
+    const messageContext = payload.messageEgress === void 0 ? void 0 : AgentMessageServerContextSchema.parse(input.agentMessageContext);
+    const enqueued = await enqueueTaskEnvelope(
+      tenant,
+      deviceId,
+      input.taskId,
+      payload.agentRef,
+      (taskId, seq, messageId) => createEnvelope("task.offer_for_agent_with_egress_fresh", payload, { id: messageId, taskId, seq }),
+      payload.messageEgress === void 0 ? void 0 : async (stores, taskId) => {
+        const body = JSON.stringify({ agentRef: payload.agentRef, requirement: payload.messageEgress, context: messageContext });
+        const recorded = await stores.receipts.record({ key: `agent-message-offer:${deviceId}:${taskId}`, body });
+        if (!recorded.created && recorded.receipt.body !== body) {
+          throw new ByokCloudError("agent_content_request_mismatch", `Task ${taskId} already has a different Agent message context.`);
+        }
+      }
+    );
+    return enqueued;
+  }
   return {
     fetch: registry.fetch,
     routes: registry.routes,
@@ -3516,45 +3860,30 @@ function createByokCloud(options) {
         (taskId, seq, messageId) => createEnvelope("task.offer_for_agent", payload, { id: messageId, taskId, seq })
       );
     },
-    async enqueueAgentEgressOffer(tenant, deviceId, input) {
+    async enqueuePreparedOffer(tenant, deviceId, input) {
       await assertAgentCapabilities(tenant, deviceId, [
         AGENT_HOME_CONTRACT_CAPABILITY,
-        AGENT_EGRESS_POLICY_CAPABILITY,
-        AGENT_EGRESS_RELIABLE_ACK_CAPABILITY,
-        ...input.payload.messageEgress === void 0 ? [] : [AGENT_MESSAGE_EGRESS_CAPABILITY],
+        AGENT_INPUT_PREPARATION_CAPABILITY,
         ...input.payload.terminalProjection === void 0 ? [] : [TERMINAL_PROJECTION_SELECTION_CAPABILITY]
       ]);
-      const payload = TaskOfferForAgentWithEgressPayloadSchema.parse(input.payload);
-      if (payload.messageEgress === void 0 && input.agentMessageContext !== void 0) {
-        throw new Error("agentMessageContext requires messageEgress");
-      }
-      const messageContext = payload.messageEgress === void 0 ? void 0 : AgentMessageServerContextSchema.parse(input.agentMessageContext);
-      const enqueued = await enqueueTaskEnvelope(
+      const payload = TaskOfferPreparedPayloadSchema.parse(input.payload);
+      return enqueueTaskEnvelope(
         tenant,
         deviceId,
         input.taskId,
         payload.agentRef,
-        (taskId, seq, messageId) => createEnvelope("task.offer_for_agent_with_egress", payload, { id: messageId, taskId, seq }),
-        payload.messageEgress === void 0 ? void 0 : async (stores, taskId) => {
-          const body = JSON.stringify({ agentRef: payload.agentRef, sessionRef: payload.sessionRef, requirement: payload.messageEgress, context: messageContext });
-          const recorded = await stores.receipts.record({ key: `agent-message-offer:${deviceId}:${taskId}`, body });
-          if (!recorded.created && recorded.receipt.body !== body) {
-            throw new ByokCloudError("agent_content_request_mismatch", `Task ${taskId} already has a different Agent message context.`);
-          }
-        }
+        (taskId, seq, messageId) => createEnvelope("task.offer_prepared", payload, { id: messageId, taskId, seq })
       );
-      return enqueued;
     },
-    async enqueueFreshAgentEgressOffer(tenant, deviceId, input) {
+    async enqueueAgentEgressOffer(tenant, deviceId, input) {
       await assertAgentCapabilities(tenant, deviceId, [
         AGENT_HOME_CONTRACT_CAPABILITY,
         AGENT_EGRESS_POLICY_CAPABILITY,
         AGENT_EGRESS_RELIABLE_ACK_CAPABILITY,
-        AGENT_EGRESS_FRESH_SESSION_CAPABILITY,
         ...input.payload.messageEgress === void 0 ? [] : [AGENT_MESSAGE_EGRESS_CAPABILITY],
         ...input.payload.terminalProjection === void 0 ? [] : [TERMINAL_PROJECTION_SELECTION_CAPABILITY]
       ]);
-      const payload = TaskOfferForAgentWithEgressFreshPayloadSchema.parse(input.payload);
+      const payload = TaskOfferForAgentWithEgressPayloadSchema.parse(input.payload);
       if (payload.messageEgress === void 0 && input.agentMessageContext !== void 0) {
         throw new Error("agentMessageContext requires messageEgress");
       }
@@ -3564,9 +3893,9 @@ function createByokCloud(options) {
         deviceId,
         input.taskId,
         payload.agentRef,
-        (taskId, seq, messageId) => createEnvelope("task.offer_for_agent_with_egress_fresh", payload, { id: messageId, taskId, seq }),
+        (taskId, seq, messageId) => createEnvelope("task.offer_for_agent_with_egress", payload, { id: messageId, taskId, seq }),
         payload.messageEgress === void 0 ? void 0 : async (stores, taskId) => {
-          const body = JSON.stringify({ agentRef: payload.agentRef, requirement: payload.messageEgress, context: messageContext });
+          const body = JSON.stringify({ agentRef: payload.agentRef, sessionRef: payload.sessionRef, requirement: payload.messageEgress, context: messageContext });
           const recorded = await stores.receipts.record({ key: `agent-message-offer:${deviceId}:${taskId}`, body });
           if (!recorded.created && recorded.receipt.body !== body) {
             throw new ByokCloudError("agent_content_request_mismatch", `Task ${taskId} already has a different Agent message context.`);
@@ -3575,6 +3904,12 @@ function createByokCloud(options) {
       );
       return enqueued;
     },
+    enqueueFreshAgentEgressOffer,
+    async submitRecurringExecution(tenant, input) {
+      const validated = RecurringExecutionInputSchema.parse(input);
+      if (typeof options.agentMessage?.consume !== "function") throw new Error("Recurring execution requires a registered Agent message consumer.");
+      return enqueueFreshAgentEgressOffer(tenant, validated.deviceId, validated);
+    },
     async enqueueAgentContentRead(tenant, deviceId, input) {
       const payload = AgentContentReadPayloadSchema.parse(input.payload);
       await assertAgentCapabilities(tenant, deviceId, [
@@ -3668,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);
@@ -3752,6 +4139,17 @@ function createByokCloud(options) {
     readTerminalReceipt(tenant, taskId) {
       return tenantStoresFor(controlPlane(tenant), root).receipts.get(terminalReceiptKey(taskId));
     },
+    async readDeviceTerminal(tenant, taskId) {
+      const receipt = await tenantStoresFor(controlPlane(tenant), root).receipts.get(terminalReceiptKey(taskId));
+      return receipt === void 0 ? void 0 : readDeviceTerminalReceipt(taskId, receipt);
+    },
+    readTaskAgentMessage(tenant, deviceId, taskId, agentRef) {
+      return readTaskAgentMessage(tenantStoresFor(controlPlane(tenant), root), deviceId, taskId, agentRef);
+    },
+    readAgentMessageDisposition(tenant, deviceId, taskId, payload) {
+      const parsed = AgentMessagePublishPayloadSchema.parse(payload);
+      return readAgentMessageDisposition(tenantStoresFor(controlPlane(tenant), root), deviceId, taskId, parsed);
+    },
     readAgentEgress(tenant, deviceId, agentRef, eventId) {
       return tenantStoresFor(controlPlane(tenant), root).egress.get(deviceId, agentRef, eventId);
     },
@@ -4406,6 +4804,10 @@ var InMemoryTaskAttemptStore = class {
       return "reserved";
     });
   }
+  async readTaskAgentMessage(tenant, input) {
+    const admission = this.#state.messageAdmissions.get(tenantKey(tenant, input.taskId));
+    return admission?.deviceId === input.deviceId ? admission : void 0;
+  }
   async readAgentMessage(tenant, input) {
     const admission = this.#state.messageAdmissions.get(tenantKey(tenant, input.taskId));
     return admission !== void 0 && admission.deviceId === input.deviceId && admission.messageId === input.messageId && admission.payloadBody === input.payloadBody ? admission : void 0;
@@ -5065,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(),
@@ -5213,6 +5637,7 @@ var CLOUD_PORT_METHODS = {
     "reserveAgentOffer",
     "reserveAgentMessage",
     "readAgentMessage",
+    "readTaskAgentMessage",
     "finalizeAgentMessage",
     "get",
     "getMany",
@@ -5247,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, 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