@byok-sdk/cloud 0.11.0 → 0.13.0

package/dist/index.js

@@ -1,11 +1,73 @@
 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';
 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, AgentHomeProjectionCompletionRequestSchema, decodeEnvelope, 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, 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, STRICT_AGENT_ONLY_CAPABILITY, AGENT_CONTENT_ARTIFACT_READ_CAPABILITY, AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY, AGENT_CONTENT_WORKSPACE_READ_CAPABILITY, AGENT_HOME_PROJECTION_CAPABILITY, PairRequestSchema, PairResponseSchema, ChallengeRequestSchema, TokenRequestSchema, AgentMemoryProjectionCommitRequestSchema, agentMemoryProjectionBase64UrlByteLength, MessagesSendRequestSchema, PresencePublishRequestSchema, CreateBlobRequestSchema, byokBlobContentPath, AgentEgressAckPayloadSchema, AgentContentReceiptPayloadSchema } from '@byok-sdk/protocol';
+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, 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, 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, MessagesSendRequestSchema, PresencePublishRequestSchema, CreateBlobRequestSchema, byokBlobContentPath, AgentEgressAckPayloadSchema, AgentContentReceiptPayloadSchema } from '@byok-sdk/protocol';
 import { z } from 'zod';
 import { Hono } from 'hono';
 
 // src/index.ts
 
+// 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 (pending === void 0) continue;
+    if (pending.approvalId === void 0 || pending.approvalId === event.approvalId) {
+      pending = void 0;
+    }
+  }
+  return pending;
+}
+
+// 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`;
+  }
+}
+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";
@@ -182,10 +244,8 @@ function createAuthPlane(deps) {
       });
     },
     async redeemAndRegister(input) {
-      const claims = await stores.pairingCodes.redeem(input.pairingCode);
-      if (claims === void 0) return void 0;
-      return stores.devices.register(claims.tenantId, {
-        productId: claims.productId,
+      return stores.pairing.redeemAndRegister({
+        pairingCode: input.pairingCode,
         deviceId: `dev_${crypto2.randomUuid()}`,
         deviceName: input.deviceName,
         devicePublicKey: input.devicePublicKey,
@@ -202,11 +262,8 @@ function createAuthPlane(deps) {
     issueNonce(device) {
       return stores.nonces.issue(device.tenantId, device.deviceId);
     },
-    validateNonce(device, nonce) {
-      return stores.nonces.validate(device.tenantId, device.deviceId, nonce);
-    },
-    consumeNonce(device, nonce) {
-      return stores.nonces.markUsed(device.tenantId, nonce);
+    consumeNonceIfValid(device, nonce) {
+      return stores.nonces.consumeIfValid(device.tenantId, device.deviceId, nonce);
     },
     verifySignature(device, nonce, signature) {
       return verifyNonceSignature(crypto2, device.devicePublicKey, nonce, signature);
@@ -326,6 +383,15 @@ var CLOUD_ERROR_CODES = {
   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. */
@@ -392,6 +458,12 @@ var TimelineEventSchema = z.object({
   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
 });
@@ -425,11 +497,24 @@ function projectTimelineEvents(input, receivedAt) {
       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";
+    }
+  }
+  return "same";
+}
 function parseTimelineEvents(value) {
   return z.array(TimelineEventSchema).parse(value);
 }
@@ -474,6 +559,14 @@ function assertBoardLabels(channel, title, limits) {
     );
   }
 }
+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 validateActivityEvents(events, dropped, bounds) {
   if (!Number.isSafeInteger(dropped) || dropped < 0) {
     throw new ByokCloudError(
@@ -525,6 +618,9 @@ async function authenticateBearer(header, deps) {
   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,
@@ -541,6 +637,7 @@ function tenantStoresFor(principal, root) {
     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)
     },
@@ -578,8 +675,12 @@ function tenantStoresFor(principal, root) {
     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)
     },
@@ -587,7 +688,8 @@ function tenantStoresFor(principal, root) {
       request: (input) => cloud.cancellations.request(tenant, input)
     },
     dedup: {
-      checkAndRecord: (deviceId, envelopeId) => cloud.dedup.checkAndRecord(tenant, deviceId, envelopeId)
+      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),
@@ -595,7 +697,7 @@ function tenantStoresFor(principal, root) {
     },
     egress: {
       record: (input) => cloud.egress.record(tenant, input),
-      get: (deviceId, eventId) => cloud.egress.get(tenant, deviceId, eventId)
+      get: (deviceId, agentRef, eventId) => cloud.egress.get(tenant, deviceId, agentRef, eventId)
     },
     blobs: {
       createUpload: (reservation) => cloud.blobs.createUpload(tenant, reservation),
@@ -627,6 +729,7 @@ async function readBoundedJsonBody(c, maximum) {
   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 };
     }
   }
@@ -640,10 +743,7 @@ async function readBoundedJsonBody(c, maximum) {
       const { done, value } = await reader.read();
       if (done) break;
       if (value.byteLength > maximum - total) {
-        try {
-          await reader.cancel();
-        } catch {
-        }
+        cancelBody(reader);
         return { body: void 0, tooLarge: true };
       }
       if (value.byteLength === 0) continue;
@@ -663,6 +763,14 @@ async function readBoundedJsonBody(c, maximum) {
   }
   return { body: parseJsonBytes(bytes), tooLarge: false };
 }
+function cancelBody(body) {
+  if (body === null) return;
+  try {
+    void Promise.resolve(body.cancel()).catch(() => {
+    });
+  } catch {
+  }
+}
 function parseContentLength(value) {
   const normalized = value.trim();
   if (!/^\d+$/u.test(normalized)) return void 0;
@@ -781,11 +889,43 @@ function blobUploadContentHandler(deps) {
     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 result = await deps.contentProxy.writeContent(blobId, new Uint8Array(await c.req.arrayBuffer()));
+    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);
+    }
+    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;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return { tooLarge: false, data: data.subarray(0, offset) };
+}
 function blobDownloadContentHandler(deps) {
   return async (c) => {
     const blobId = c.req.param("id") ?? "";
@@ -830,9 +970,12 @@ function renderStorageError(c, error) {
 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 parsed = PairRequestSchema.safeParse(await readJsonBody(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(
         {
@@ -855,7 +998,9 @@ function pairHandler(deps) {
 }
 function challengeHandler(deps) {
   return async (c) => {
-    const parsed = ChallengeRequestSchema.safeParse(await readJsonBody(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);
@@ -865,18 +1010,19 @@ function challengeHandler(deps) {
 }
 function tokenHandler(deps) {
   return async (c) => {
-    const parsed = TokenRequestSchema.safeParse(await readJsonBody(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.validateNonce(device, nonce)) {
-      return c.json({ error: "invalid, expired, or already-used nonce" }, 401);
-    }
     if (!await deps.auth.verifySignature(device, nonce, signature)) {
       return c.json({ error: "invalid signature" }, 401);
     }
-    await deps.auth.consumeNonce(device, nonce);
+    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);
@@ -884,11 +1030,20 @@ function tokenHandler(deps) {
 }
 var CLOUD_PROTOCOL_CAPABILITIES = [
   "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"
@@ -905,12 +1060,21 @@ function eventsHandler(deps) {
     let cursor = 0;
     if (cursorRaw !== void 0) {
       const parsedCursor = Number(cursorRaw);
-      if (!Number.isInteger(parsedCursor) || parsedCursor < 0) return c.json({ error: "invalid cursor" }, 400);
+      if (!Number.isSafeInteger(parsedCursor) || parsedCursor < 0) {
+        return c.json({ error: "invalid cursor" }, 400);
+      }
       cursor = parsedCursor;
     }
     const acked = await stores.mailbox.readCursor(device.deviceId);
     if (cursor > acked.ackedSeq) {
-      await stores.mailbox.advanceCursor({ deviceId: device.deviceId, ackedSeq: cursor });
+      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) {
@@ -921,6 +1085,9 @@ function eventsHandler(deps) {
           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(
@@ -945,6 +1112,10 @@ function eventsHandler(deps) {
           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);
@@ -962,19 +1133,45 @@ 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 ApprovalTimelineEventSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("approval_requested"),
-    summary: z.string(),
-    approvalId: NonBlankIdSchema.optional()
-  }),
-  z.object({
-    type: z.literal("approval_resolved"),
-    approvalId: NonBlankIdSchema,
-    decision: z.enum(["approve", "reject"]),
-    resolvedBy: z.enum(["local"]),
-    at: z.iso.datetime({ offset: true })
-  })
+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,
@@ -1017,6 +1214,20 @@ function validateApprovalTimelineAppend(input) {
   }
   return { capacity, ttlMs, event: parsed.data.event };
 }
+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 approvalTimelineKey(tenant, taskId) {
   return tenantKey(tenant, taskId);
 }
@@ -1040,13 +1251,17 @@ async function projectTerminalToReview(board, taskId) {
     throw caught;
   }
 }
+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) {
+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 || !sameAgentRef(attempt.agentRef, payload.agentRef)) return { outcome: "rejected" };
+  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);
@@ -1054,19 +1269,38 @@ async function handleAgentMessagePublish(stores, deviceId, taskId, payload, cons
     return { outcome: "rejected" };
   }
   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 taskMessageKey = `agent-message-task:${deviceId}:${taskId}`;
-  const taskMessageBody = JSON.stringify(payload);
-  const lockedTaskMessage = await stores.receipts.record({ key: taskMessageKey, body: taskMessageBody });
-  if (!lockedTaskMessage.created && lockedTaskMessage.receipt.body !== taskMessageBody) return { outcome: "rejected" };
-  const receiptKey2 = `agent-message:${deviceId}:${payload.messageId}`;
-  const previous = await stores.receipts.get(receiptKey2);
-  if (previous !== void 0) {
-    const decoded = JSON.parse(previous.body);
-    if (JSON.stringify(decoded.payload) !== JSON.stringify(payload)) return { outcome: "rejected" };
-    return { outcome: "duplicate", disposition: decoded.disposition };
-  }
-  const decision = consume === void 0 ? { outcome: "held", reasonCode: "consumer_unavailable" } : await consume({ tenant: stores.tenant, deviceId, taskId, context: frozen.context, payload });
-  const disposition = {
+  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 agentMessageDisposition(payload, decision) {
+  return {
     agentRef: payload.agentRef,
     sessionRef: payload.sessionRef,
     contract: payload.contract,
@@ -1077,9 +1311,23 @@ async function handleAgentMessagePublish(stores, deviceId, taskId, payload, cons
     receiptId: crypto.randomUUID(),
     ...decision.reasonCode === void 0 ? {} : { reasonCode: decision.reasonCode }
   };
-  const recorded = await stores.receipts.record({ key: receiptKey2, body: JSON.stringify({ payload, disposition }) });
-  if (!recorded.created && recorded.receipt.body !== JSON.stringify({ payload, disposition })) return { outcome: "rejected" };
-  return { outcome: "accepted", disposition };
+}
+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) {
+  try {
+    const decoded = JSON.parse(terminalBody);
+    return decoded.disposition !== void 0 && JSON.stringify(decoded.payload) === JSON.stringify(payload) ? decoded.disposition : void 0;
+  } catch {
+    return void 0;
+  }
 }
 function terminalReceiptKey(taskId) {
   return `task:${taskId}:terminal`;
@@ -1103,17 +1351,17 @@ function contentReadCapability(surface) {
 function hasCapabilities(capabilities, required) {
   return capabilities !== void 0 && required.every((capability) => capabilities.includes(capability));
 }
-function contentRequestReceiptKey(deviceId, requestId) {
-  return `agent-content-request:${deviceId}:${requestId}`;
+function contentRequestReceiptKey(deviceId, agentRef, requestId) {
+  return agentReliabilityKey("agent-content-request", deviceId, agentRef, requestId);
 }
-function contentReceiptKey(deviceId, requestId) {
-  return `agent-content:${deviceId}:${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, requestId) {
-  const stored = await stores.receipts.get(contentRequestReceiptKey(deviceId, requestId));
+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));
@@ -1136,7 +1384,23 @@ function inboundAgentRef(envelope) {
 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) {
+async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds = DEFAULT_ACTIVITY_BOUNDS, agentMessageConsume, observer) {
+  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 {
+    }
+  }
+  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";
@@ -1145,10 +1409,21 @@ async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds
     if (device === void 0 || device.revoked || device.productId !== envelope.payload.productId) {
       return "rejected";
     }
-    if (await stores.dedup.checkAndRecord(deviceId, envelope.id)) return "duplicate";
-    return await stores.devices.recordCapabilities({ capabilities: envelope.payload.capabilities }) === void 0 ? "rejected" : "accepted";
+    if (await stores.devices.recordCapabilities({ capabilities: envelope.payload.capabilities }) === void 0) {
+      return "rejected";
+    }
+    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])) {
@@ -1159,19 +1434,21 @@ async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds
       payload: envelope.payload,
       receiptId: crypto.randomUUID()
     });
-    return outcome.created || sameReliableEgress(outcome.record.payload, envelope.payload) ? outcome.created ? "accepted" : "duplicate" : "rejected";
+    if (!outcome.created && !sameReliableEgress(outcome.record.payload, envelope.payload)) return "rejected";
+    return completeInboundEnvelope(stores, deviceId, envelope.id, envelope.payload.agentRef);
   }
   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.requestId);
+    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.requestId);
+    const key = contentReceiptKey(deviceId, envelope.payload.agentRef, envelope.payload.requestId);
     const body = JSON.stringify(envelope.payload);
     const receipt = await stores.receipts.record({ key, body });
-    return receipt.created ? "accepted" : receipt.receipt.body === body ? "duplicate" : "rejected";
+    if (!receipt.created && receipt.receipt.body !== body) return "rejected";
+    return completeInboundEnvelope(stores, deviceId, envelope.id, envelope.payload.agentRef);
   }
   const taskId = envelope.task_id;
   if (taskId === void 0) return "rejected";
@@ -1181,6 +1458,7 @@ async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds
   if (attempt?.agentRef !== void 0 && agentRefEchoRequired(envelope) && !sameAgentRef(attempt.agentRef, inboundAgentRef(envelope))) {
     return "rejected";
   }
+  if (terminalStatus(envelope) !== void 0 && attempt === void 0) return "rejected";
   if (envelope.type === "task.progress" && envelope.payload.events.length > 0) {
     try {
       validateActivityBatch(
@@ -1209,14 +1487,22 @@ async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds
       throw caught;
     }
   }
-  if (await stores.dedup.checkAndRecord(deviceId, envelope.id)) return "duplicate";
   await applyLifecycle(stores, deviceId, taskId, envelope, activityBounds, attempt?.agentRef);
-  return "accepted";
+  return completeInboundEnvelope(stores, deviceId, envelope.id, attempt?.agentRef);
+}
+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";
 }
 async function applyLifecycle(stores, deviceId, taskId, envelope, activityBounds, persistedAgentRef) {
   switch (envelope.type) {
     case "task.claim":
-      await stores.tasks.claim({ taskId, deviceId });
+      await stores.tasks.claim({
+        taskId,
+        deviceId,
+        ...envelope.payload.runtime === void 0 ? {} : { runtime: envelope.payload.runtime },
+        ...envelope.payload.capabilities === void 0 ? {} : { capabilities: envelope.payload.capabilities }
+      });
       return;
     case "task.started":
       await stores.tasks.recordStatus({
@@ -1226,11 +1512,7 @@ async function applyLifecycle(stores, deviceId, taskId, envelope, activityBounds
       });
       return;
     case "task.decline":
-      await stores.tasks.recordStatus({
-        taskId,
-        status: "failed",
-        ...persistedAgentRef === void 0 ? {} : { agentRef: persistedAgentRef }
-      });
+      await recordTerminal(stores, taskId, envelope);
       return;
     case "task.progress":
       if (envelope.payload.events.length > 0) {
@@ -1254,13 +1536,13 @@ async function applyLifecycle(stores, deviceId, taskId, envelope, activityBounds
       await stores.approvals.append(approvalTimelineAppendInput(taskId, envelope));
       return;
     case "task.complete":
-      await recordTerminal(stores, taskId, envelope, "complete");
+      await recordTerminal(stores, taskId, envelope);
       return;
     case "task.fail":
-      await recordTerminal(stores, taskId, envelope, "failed");
+      await recordTerminal(stores, taskId, envelope);
       return;
     case "task.cancelled":
-      await recordTerminal(stores, taskId, envelope, "cancelled");
+      await recordTerminal(stores, taskId, envelope);
       return;
     default:
       return;
@@ -1294,14 +1576,18 @@ function approvalTimelineAppendInput(taskId, envelope) {
       return void 0;
   }
 }
-async function recordTerminal(stores, taskId, envelope, status) {
-  const attempt = await stores.tasks.get(taskId);
-  const { created } = await stores.receipts.record({
+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) {
-    if (status === "cancelled") {
+    if (winner.status === "cancelled") {
       await stores.tasks.recordStatus({
         taskId,
         status: "cancelled",
@@ -1310,48 +1596,72 @@ async function recordTerminal(stores, taskId, envelope, status) {
     }
     return;
   }
-  if (!created) return;
-  const cause = envelope.type === "task.fail" || envelope.type === "task.cancelled" ? envelope.payload.reason : void 0;
   const recordedAttempt = await stores.tasks.recordStatus({
     taskId,
-    status,
+    status: winner.status,
     ...attempt?.agentRef === void 0 ? {} : { agentRef: attempt.agentRef },
-    ...cause === void 0 ? {} : { terminalCause: cause }
+    ...winner.cause === void 0 ? {} : { terminalCause: winner.cause }
   });
-  if (recordedAttempt?.status !== status || recordedAttempt.cancellation !== void 0) return;
+  if (recordedAttempt?.status !== winner.status || recordedAttempt.cancellation !== void 0) 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 } };
+}
 
 // src/handlers/messages.ts
+var MESSAGES_JSON_BODY_MAX_BYTES = 2 * 1024 * 1024;
 function messagesHandler(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 parsed = MessagesSendRequestSchema.safeParse(await readJsonBody(c));
+    const body = await readBoundedJsonBody(c, MESSAGES_JSON_BODY_MAX_BYTES);
+    if (body.tooLarge) return c.json({ error: "request body too large" }, 413);
+    const parsed = MessagesSendRequestSchema.safeParse(body.body);
     if (!parsed.success) return c.json({ error: "messages must be an array of envelopes" }, 400);
     let accepted = 0;
     let rejected = 0;
     for (const envelope of parsed.data.messages) {
-      const messageResult = envelope.type === "agent.message.publish" ? await handleAgentMessagePublish(
-        stores,
-        device.deviceId,
-        envelope.task_id,
-        envelope.payload,
-        deps.agentMessage?.consume
-      ) : void 0;
-      const outcome = messageResult?.outcome ?? await handleInboundEnvelope(
+      const outcome = await handleInboundEnvelope(
         stores,
         device.deviceId,
         envelope,
-        deps.activityBounds
+        deps.activityBounds,
+        envelope.type === "agent.message.publish" ? deps.agentMessage?.consume : void 0,
+        deps.observer
       );
       if (outcome === "rate_limited") return c.json({ error: "rate limit exceeded" }, 429);
-      if (envelope.type === "agent.message.publish" && messageResult?.disposition !== void 0) {
-        await deps.appendAgentMessageDisposition(stores, device.deviceId, envelope.task_id, messageResult.disposition);
+      if (envelope.type === "agent.message.publish") {
+        const disposition = await readAgentMessageDisposition(stores, device.deviceId, envelope.task_id, envelope.payload);
+        if (disposition !== void 0) {
+          await deps.appendAgentMessageDisposition(stores, device.deviceId, envelope.task_id, disposition);
+        }
       }
       if (envelope.type === "agent.egress.reliable" && (outcome === "accepted" || outcome === "duplicate")) {
-        const record = await stores.egress.get(device.deviceId, envelope.payload.eventId);
+        const record = await stores.egress.get(device.deviceId, envelope.payload.agentRef, envelope.payload.eventId);
         if (record === void 0) {
           throw new Error(`Accepted reliable egress ${envelope.payload.eventId} has no durable receipt record.`);
         }
@@ -1961,7 +2271,7 @@ function truthGetHandler(deps) {
 }
 function truthPutHandler(deps) {
   return async (c) => {
-    const body = await readBoundedBody(c, deps.maxRequestBytes);
+    const body = await readBoundedBody2(c, deps.maxRequestBytes);
     if (body === "too_large") return c.json({ error: "truth request body too large" }, 413);
     if (body === void 0) return c.json({ error: "invalid truth request body" }, 400);
     const authenticated = await authenticateTruthRequest(c, deps, {
@@ -2093,7 +2403,7 @@ function decodeProofHeader(value) {
     return void 0;
   }
 }
-async function readBoundedBody(c, maximum) {
+async function readBoundedBody2(c, maximum) {
   const length = c.req.header("content-length");
   if (length !== void 0) {
     const parsed = Number(length);
@@ -2170,11 +2480,11 @@ var CloudRouteRegistry = class {
     return this.#app.fetch;
   }
 };
-function agentHomeProjectionRequestKey(deviceId, requestId) {
-  return `agent-home-projection:v1:${deviceId}:${requestId}:request`;
+function agentHomeProjectionRequestKey(deviceId, agentRef, requestId) {
+  return agentReliabilityKey("agent-home-projection-request", deviceId, agentRef, requestId);
 }
-function agentHomeProjectionCompletionKey(deviceId, requestId) {
-  return `agent-home-projection:v1:${deviceId}:${requestId}:completion`;
+function agentHomeProjectionCompletionKey(deviceId, agentRef, requestId) {
+  return agentReliabilityKey("agent-home-projection-completion", deviceId, agentRef, requestId);
 }
 function sameAgentHomeProjectionRequest(expected, actual) {
   return expected.requestId === actual.requestId && expected.agentRef.agentId === actual.agentRef.agentId && expected.agentRef.profileRevision === actual.agentRef.profileRevision && expected.projectionHash === actual.projectionHash && JSON.stringify(expected.projection) === JSON.stringify(actual.projection);
@@ -2208,7 +2518,7 @@ function parseCompletionBody(body) {
   }
 }
 async function readAgentHomeProjectionStatus(receipts, tenant, deviceId, input) {
-  const storedRequest = await receipts.get(agentHomeProjectionRequestKey(deviceId, input.requestId));
+  const storedRequest = await receipts.get(agentHomeProjectionRequestKey(deviceId, input.agentRef, input.requestId));
   if (storedRequest === void 0) return void 0;
   const request = parseRequestBody(storedRequest.body);
   if (!statusInputMatchesAgentHomeProjection(request, input)) {
@@ -2217,7 +2527,7 @@ async function readAgentHomeProjectionStatus(receipts, tenant, deviceId, input)
       `Agent-home projection request ${input.requestId} does not match its immutable desired fact.`
     );
   }
-  const storedCompletion = await receipts.get(agentHomeProjectionCompletionKey(deviceId, input.requestId));
+  const storedCompletion = await receipts.get(agentHomeProjectionCompletionKey(deviceId, request.agentRef, input.requestId));
   if (storedCompletion === void 0) {
     return {
       tenantId: tenant,
@@ -2247,7 +2557,7 @@ async function readAgentHomeProjectionStatus(receipts, tenant, deviceId, input)
 }
 async function recordAgentHomeProjectionCompletion(receipts, tenant, deviceId, receiptInput) {
   const receipt = AgentHomeProjectionCompletionRequestSchema.parse(receiptInput);
-  const storedRequest = await receipts.get(agentHomeProjectionRequestKey(deviceId, receipt.requestId));
+  const storedRequest = await receipts.get(agentHomeProjectionRequestKey(deviceId, receipt.agentRef, receipt.requestId));
   if (storedRequest === void 0) {
     throw new ByokCloudError(
       "agent_home_projection_request_not_found",
@@ -2263,7 +2573,7 @@ async function recordAgentHomeProjectionCompletion(receipts, tenant, deviceId, r
   }
   const body = JSON.stringify(receipt);
   const storedCompletion = await receipts.record({
-    key: agentHomeProjectionCompletionKey(deviceId, receipt.requestId),
+    key: agentHomeProjectionCompletionKey(deviceId, request.agentRef, receipt.requestId),
     body
   });
   if (!storedCompletion.created && storedCompletion.receipt.body !== body) {
@@ -2317,6 +2627,21 @@ function projectTerminalResult(taskId, receipt) {
         ...envelope.payload.usage !== void 0 ? { usage: envelope.payload.usage } : {},
         recordedAt: receipt.recordedAt
       };
+    // `task.decline` is the pre-claim terminal (§3.2, `Offered -> Failed`).
+    // It projects onto the same `failed` state as `task.fail` — there is no
+    // separate declined state — and carries the device's own `retryable`
+    // verbatim, exactly like `task.fail` does; this projection never decides
+    // that a decline is retryable on the device's behalf.
+    case "task.decline":
+      return {
+        taskId,
+        state: "failed",
+        ...envelope.payload.agentRef === void 0 ? {} : { agentRef: envelope.payload.agentRef },
+        reason: envelope.payload.reason,
+        terminalCause: envelope.payload.reason,
+        ...envelope.payload.retryable !== void 0 ? { retryable: envelope.payload.retryable } : {},
+        recordedAt: receipt.recordedAt
+      };
     case "task.cancelled":
       return {
         taskId,
@@ -2341,9 +2666,25 @@ var DEFAULT_LONG_POLL_HOLD_MS = 5e4;
 var DEFAULT_LONG_POLL_INTERVAL_MS = 250;
 var DEFAULT_EVENTS_PAGE_LIMIT = 50;
 var AGENT_HOME_CONTRACT_CAPABILITY = "agent-home-contract";
+function isTerminalAttemptStatus(status) {
+  return status === "complete" || status === "failed" || status === "cancelled";
+}
 function sameAgentRef2(expected, actual) {
   return actual?.agentId === expected.agentId && actual.profileRevision === expected.profileRevision;
 }
+function uuidFromSha256(value) {
+  const match = /^sha256:([0-9a-f]{64})$/.exec(value);
+  if (match === null) throw new Error("CloudCrypto.sha256 must return canonical sha256 hex");
+  const digest = match[1];
+  if (digest === void 0) throw new Error("CloudCrypto.sha256 must return canonical sha256 hex");
+  const hex = digest.slice(0, 32).split("");
+  hex[12] = "8";
+  hex[16] = ["8", "9", "a", "b"][Number.parseInt(hex[16], 16) & 3];
+  return `${hex.slice(0, 8).join("")}-${hex.slice(8, 12).join("")}-${hex.slice(12, 16).join("")}-${hex.slice(16, 20).join("")}-${hex.slice(20).join("")}`;
+}
+function sameOfferEnvelope(expected, actual) {
+  return expected.id === actual.id && expected.type === actual.type && expected.task_id === actual.task_id && JSON.stringify(expected.payload) === JSON.stringify(actual.payload);
+}
 function createByokCloud(options) {
   const declaration = parseDeclaration(options.capabilities);
   assertNoOverDeclaration(
@@ -2365,7 +2706,11 @@ function createByokCloud(options) {
   });
   const deviceRouteDeps = {
     root,
-    bearer: { tokenSigner: options.tokenSigner, devices: options.cloud.devices }
+    bearer: {
+      tokenSigner: options.tokenSigner,
+      devices: options.cloud.devices,
+      ...options.instanceProductId === void 0 ? {} : { instanceProductId: options.instanceProductId }
+    }
   };
   const registry = new CloudRouteRegistry();
   const activityBounds = {
@@ -2410,7 +2755,8 @@ function createByokCloud(options) {
         appendReliableEgressAck: enqueueReliableEgressAck,
         appendContentReceiptAck: enqueueContentReceiptAck,
         agentMessage: options.agentMessage,
-        appendAgentMessageDisposition: enqueueAgentMessageDisposition
+        appendAgentMessageDisposition: enqueueAgentMessageDisposition,
+        observer: options.observer
       })
     );
   }
@@ -2522,7 +2868,10 @@ function createByokCloud(options) {
   }
   const contentProxy = options.blobContentProxy;
   if (contentProxy !== void 0 && declares(declaration, CLOUD_CAPABILITIES.blobsContentProxy)) {
-    const contentDeps = { contentProxy };
+    const contentDeps = {
+      contentProxy,
+      maxUploadBytes: options.maxBlobSizeBytes ?? DEFAULT_MAX_BLOB_SIZE_BYTES
+    };
     registry.register(
       { method: "PUT", path: BYOK_BLOB_CONTENT_ROUTE, class: "presigned" },
       blobUploadContentHandler(contentDeps)
@@ -2539,56 +2888,60 @@ function createByokCloud(options) {
   async function enqueueTaskEnvelope(tenant, deviceId, requestedTaskId, agentRef, buildEnvelope, beforeMailbox) {
     const stores = tenantStoresFor(controlPlane(tenant), root);
     const taskId = requestedTaskId ?? `task_${options.crypto.randomUuid()}`;
-    const messageId = options.crypto.randomUuid();
+    const messageId = uuidFromSha256(
+      await options.crypto.sha256(
+        new TextEncoder().encode(
+          JSON.stringify({ domain: "byok:task-offer", tenant, taskId, deviceId, agentRef })
+        )
+      )
+    );
     const reservation = agentRef === void 0 ? void 0 : await stores.tasks.reserveAgentOffer({ taskId, deviceId, agentRef });
-    const openedBeforeAppend = reservation?.attempt;
-    if (agentRef !== void 0 && (openedBeforeAppend === void 0 || openedBeforeAppend.deviceId !== deviceId || openedBeforeAppend.agentRef === void 0 || !sameAgentRef2(agentRef, openedBeforeAppend.agentRef))) {
+    const openedBeforeAppend = reservation?.attempt ?? (agentRef === void 0 ? await stores.tasks.open({ taskId, deviceId }) : void 0);
+    if (openedBeforeAppend === void 0 || openedBeforeAppend.deviceId !== deviceId || (agentRef === void 0 ? openedBeforeAppend.agentRef !== void 0 : openedBeforeAppend.agentRef === void 0 || !sameAgentRef2(agentRef, openedBeforeAppend.agentRef))) {
       throw new ByokCloudError(
-        "agent_ref_mismatch",
-        `Task ${taskId} already has a different durable Agent identity or target device.`
+        agentRef === void 0 ? "coordination_input_invalid" : "agent_ref_mismatch",
+        `Task ${taskId} already has a different durable target or Agent identity.`
       );
     }
-    if (reservation !== void 0 && !reservation.created) {
+    const offerReceiptKey = `task-offer:${messageId}`;
+    const deliveryReceiptKey = `task-offer-delivered:${messageId}`;
+    if (agentRef !== void 0 && reservation?.created === false && await stores.receipts.get(deliveryReceiptKey) !== void 0) {
       throw new ByokCloudError(
         "agent_task_already_exists",
         `Task ${taskId} already has a durable Agent attempt and cannot be enqueued again.`
       );
     }
-    let message;
-    try {
-      await beforeMailbox?.(stores, taskId);
-      message = await stores.mailbox.append({
-        deviceId,
-        messageId,
-        materialize: async (seq) => {
-          const envelope2 = buildEnvelope(taskId, seq, messageId);
-          const body = encodeEnvelope(envelope2);
-          const bytes = new TextEncoder().encode(body);
-          return {
-            body,
-            bodyHash: contentHash(await options.crypto.sha256(bytes)),
-            byteSize: BigInt(bytes.length)
-          };
-        }
-      });
-    } catch (error) {
-      if (openedBeforeAppend !== void 0) {
-        try {
-          await stores.tasks.recordStatus({
-            taskId,
-            status: "failed",
-            agentRef,
-            terminalCause: "mailbox append failed before Agent offer delivery"
-          });
-        } catch (cleanupError) {
-          throw new AggregateError(
-            [error, cleanupError],
-            `Agent task ${taskId} could not be delivered or durably closed`
-          );
-        }
-      }
-      throw error;
+    const proposed = buildEnvelope(taskId, 0, messageId);
+    const proposedBody = JSON.stringify({
+      deviceId,
+      type: proposed.type,
+      payload: proposed.payload
+    });
+    const recorded = await stores.receipts.record({
+      key: offerReceiptKey,
+      body: proposedBody
+    });
+    if (!recorded.created && recorded.receipt.body !== proposedBody) {
+      throw new ByokCloudError(
+        "coordination_input_invalid",
+        `Task ${taskId} already has a different executable offer body.`
+      );
     }
+    await beforeMailbox?.(stores, taskId);
+    const message = await stores.mailbox.append({
+      deviceId,
+      messageId,
+      materialize: async (seq) => {
+        const envelope2 = buildEnvelope(taskId, seq, messageId);
+        const body = encodeEnvelope(envelope2);
+        const bytes = new TextEncoder().encode(body);
+        return {
+          body,
+          bodyHash: contentHash(await options.crypto.sha256(bytes)),
+          byteSize: BigInt(bytes.length)
+        };
+      }
+    });
     const envelope = decodeEnvelope(message.body);
     if (envelope.seq !== message.seq) {
       throw new ByokCloudError(
@@ -2596,11 +2949,22 @@ function createByokCloud(options) {
         `Mailbox stored offer seq ${String(envelope.seq)} at row ${message.seq}; the daemon's redelivery cursor would be wrong.`
       );
     }
-    const attempt = openedBeforeAppend ?? await stores.tasks.open({
-      taskId,
-      deviceId
-    });
-    return { taskId, seq: message.seq, envelope, attempt };
+    if (!sameOfferEnvelope(buildEnvelope(taskId, message.seq, messageId), envelope)) {
+      throw new ByokCloudError(
+        "coordination_input_invalid",
+        `Task ${taskId} already has a different executable offer body.`
+      );
+    }
+    if (agentRef !== void 0) {
+      const delivered = await stores.receipts.record({ key: deliveryReceiptKey, body: messageId });
+      if (reservation?.created === false && !delivered.created) {
+        throw new ByokCloudError(
+          "agent_task_already_exists",
+          `Task ${taskId} already has a durable Agent attempt and cannot be enqueued again.`
+        );
+      }
+    }
+    return { taskId, seq: message.seq, envelope, attempt: openedBeforeAppend };
   }
   async function assertAgentCapabilities(tenant, deviceId, required) {
     const device = await options.cloud.devices.get(tenant, deviceId);
@@ -2655,6 +3019,236 @@ function createByokCloud(options) {
     }
     return { seq: message.seq, envelope };
   }
+  async function agentControlEnvelopeId(domain, tenant, deviceId, agentRef, logicalRequestId) {
+    return uuidFromSha256(
+      await options.crypto.sha256(
+        new TextEncoder().encode(
+          JSON.stringify({ domain, tenant, deviceId, agentRef, logicalRequestId })
+        )
+      )
+    );
+  }
+  async function approvalDecisionSource(tenant, taskId, attempt, pending, decision) {
+    const agent = attempt.agentRef;
+    return uuidFromSha256(
+      await options.crypto.sha256(
+        new TextEncoder().encode(
+          JSON.stringify({
+            domain: "byok:approval-decision",
+            tenant,
+            taskId,
+            deviceId: attempt.deviceId,
+            ownerDeviceId: attempt.ownerDeviceId,
+            agentRef: agent,
+            requestSourceEnvelopeId: pending.sourceEnvelopeId,
+            requestRevision: pending.revision,
+            decision
+          })
+        )
+      )
+    );
+  }
+  function latestApprovalRequest(tail) {
+    if (tail === void 0) return void 0;
+    for (let index = tail.entries.length - 1; index >= 0; index -= 1) {
+      const entry = tail.entries[index];
+      if (entry.event.type !== "approval_requested") continue;
+      return {
+        sourceEnvelopeId: entry.sourceEnvelopeId,
+        revision: entry.revision,
+        ...entry.event.approvalId === void 0 ? {} : { approvalId: entry.event.approvalId }
+      };
+    }
+    return void 0;
+  }
+  async function recordedHostDecision(tenant, taskId, attempt, tail, request) {
+    for (const decision of ["approve", "reject"]) {
+      const sourceEnvelopeId = await approvalDecisionSource(tenant, taskId, attempt, request, decision);
+      const index = tail?.entries.findIndex((candidate) => candidate.sourceEnvelopeId === sourceEnvelopeId) ?? -1;
+      const entry = index < 0 ? void 0 : tail.entries[index];
+      if (entry?.event.type !== "approval_resolved" || entry.event.resolvedBy !== "host") continue;
+      const laterResolution = tail.entries.slice(index + 1).some(
+        (candidate) => candidate.event.type === "approval_resolved" && (request.approvalId === void 0 || candidate.event.approvalId === request.approvalId)
+      );
+      if (!laterResolution) {
+        if (entry.event.decision === "reject") {
+          return {
+            decision: "reject",
+            ...entry.event.approvalId === void 0 ? {} : { approvalId: entry.event.approvalId },
+            reason: entry.event.reason
+          };
+        }
+        return {
+          decision: "approve",
+          ...entry.event.approvalId === void 0 ? {} : { approvalId: entry.event.approvalId }
+        };
+      }
+    }
+    return void 0;
+  }
+  async function resolveApproval(tenant, taskId, decision, opts) {
+    const stores = tenantStoresFor(controlPlane(tenant), root);
+    const attempt = await stores.tasks.get(taskId);
+    if (attempt === void 0) {
+      throw new ByokCloudError("task_not_found", `Task ${taskId} was not found for this tenant.`);
+    }
+    if (isTerminalAttemptStatus(attempt.status)) {
+      throw new ByokCloudError(
+        "task_not_awaiting_approval",
+        `Task ${taskId} already reached ${attempt.status}; there is no approval left to ${decision}.`
+      );
+    }
+    const tail = await stores.approvals.read(taskId);
+    const pending = pendingApproval(tail);
+    const latestRequest = latestApprovalRequest(tail);
+    if (pending === void 0) {
+      if (latestRequest !== void 0) {
+        const recorded = await recordedHostDecision(tenant, taskId, attempt, tail, latestRequest);
+        if (recorded !== void 0) {
+          if (recorded.decision !== decision) {
+            throw new ByokCloudError(
+              "coordination_input_invalid",
+              `Task ${taskId} already has the opposite host approval decision.`
+            );
+          }
+          if (recorded.decision === "reject" && recorded.reason !== (opts?.reason ?? null)) {
+            throw new ByokCloudError(
+              "coordination_input_invalid",
+              `Task ${taskId} already has a host rejection with a different immutable reason.`
+            );
+          }
+          const ownerDeviceId2 = attempt.ownerDeviceId;
+          if (ownerDeviceId2 === void 0) {
+            throw new ByokCloudError(
+              "task_not_awaiting_approval",
+              `Task ${taskId} has no owning device to receive its recorded ${decision}.`
+            );
+          }
+          const messageId2 = await approvalDecisionSource(tenant, taskId, attempt, latestRequest, decision);
+          const targeting2 = recorded.approvalId === void 0 ? {} : { approvalId: recorded.approvalId };
+          const recordedReason = recorded.decision === "reject" ? recorded.reason : void 0;
+          return enqueueAgentControlEnvelope(
+            tenant,
+            ownerDeviceId2,
+            messageId2,
+            (seq) => decision === "approve" ? createEnvelope("task.approve", targeting2, { id: messageId2, taskId, seq }) : createEnvelope(
+              "task.reject",
+              { ...targeting2, ...recordedReason === null || recordedReason === void 0 ? {} : { reason: recordedReason } },
+              { id: messageId2, taskId, seq }
+            )
+          );
+        }
+      }
+      throw new ByokCloudError(
+        "task_not_awaiting_approval",
+        `Task ${taskId} has no pending approval to ${decision}.`
+      );
+    }
+    if (opts?.approvalId !== void 0 && pending.approvalId !== void 0 && opts.approvalId !== pending.approvalId) {
+      throw new StaleApprovalError(taskId, opts.approvalId, pending.approvalId);
+    }
+    const ownerDeviceId = attempt.ownerDeviceId;
+    if (ownerDeviceId === void 0) {
+      throw new ByokCloudError(
+        "task_not_awaiting_approval",
+        `Task ${taskId} has no owning device; no runtime is paused on an approval to ${decision}.`
+      );
+    }
+    const approvalId = pending.approvalId;
+    const messageId = await approvalDecisionSource(tenant, taskId, attempt, pending, decision);
+    const event = decision === "reject" ? {
+      type: "approval_resolved",
+      ...approvalId === void 0 ? {} : { approvalId },
+      decision: "reject",
+      resolvedBy: "host",
+      reason: opts?.reason ?? null,
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    } : {
+      type: "approval_resolved",
+      ...approvalId === void 0 ? {} : { approvalId },
+      decision: "approve",
+      resolvedBy: "host",
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const resolved = await root.cloud.approvals.resolvePending(tenant, {
+      taskId,
+      sourceEnvelopeId: messageId,
+      expectedSourceEnvelopeId: pending.sourceEnvelopeId,
+      expectedRevision: pending.revision,
+      event
+    });
+    let deliveredApprovalId = approvalId;
+    let deliveredReason = decision === "reject" ? opts?.reason ?? null : void 0;
+    if (resolved.status === "conflict" || resolved.status === "superseded" || resolved.status === "absent") {
+      const currentTail = resolved.tail ?? await stores.approvals.read(taskId);
+      const currentPending = pendingApproval(currentTail);
+      const recorded = await recordedHostDecision(tenant, taskId, attempt, currentTail, pending);
+      if (recorded?.decision === decision) {
+        deliveredApprovalId = recorded.approvalId;
+        if (recorded.decision === "reject") {
+          if (recorded.reason !== deliveredReason) {
+            throw new ByokCloudError(
+              "coordination_input_invalid",
+              `Task ${taskId} already has a host rejection with a different immutable reason.`
+            );
+          }
+          deliveredReason = recorded.reason;
+        }
+      } else if (recorded !== void 0) {
+        throw new ByokCloudError(
+          "coordination_input_invalid",
+          `Task ${taskId} already has the opposite host approval decision.`
+        );
+      } else if (currentPending !== void 0 && opts?.approvalId !== void 0 && currentPending.approvalId !== void 0 && currentPending.approvalId !== opts.approvalId) {
+        throw new StaleApprovalError(taskId, opts.approvalId, currentPending.approvalId);
+      } else {
+        throw new ByokCloudError(
+          "task_not_awaiting_approval",
+          `Task ${taskId} no longer has the pending approval to ${decision}.`
+        );
+      }
+    }
+    const targeting = deliveredApprovalId === void 0 ? {} : { approvalId: deliveredApprovalId };
+    return enqueueAgentControlEnvelope(
+      tenant,
+      ownerDeviceId,
+      messageId,
+      (seq) => decision === "approve" ? createEnvelope("task.approve", targeting, { id: messageId, taskId, seq }) : createEnvelope(
+        "task.reject",
+        { ...targeting, ...deliveredReason === null || deliveredReason === void 0 ? {} : { reason: deliveredReason } },
+        { id: messageId, taskId, seq }
+      )
+    );
+  }
+  async function steerTask(tenant, taskId, payload) {
+    const stores = tenantStoresFor(controlPlane(tenant), root);
+    const attempt = await stores.tasks.get(taskId);
+    if (attempt === void 0) {
+      throw new ByokCloudError("task_not_found", `Task ${taskId} was not found for this tenant.`);
+    }
+    if (isTerminalAttemptStatus(attempt.status)) {
+      throw new SteerRejectedError(taskId, "task_terminal", attempt.status, attempt.claimedRuntime);
+    }
+    const ownerDeviceId = attempt.ownerDeviceId;
+    if (attempt.status !== "running" || ownerDeviceId === void 0) {
+      throw new SteerRejectedError(taskId, "task_not_running", attempt.status, attempt.claimedRuntime);
+    }
+    if (attempt.claimedRuntimeCapabilities?.steer !== true) {
+      throw new SteerRejectedError(
+        taskId,
+        "steer_unsupported_runtime",
+        attempt.status,
+        attempt.claimedRuntime
+      );
+    }
+    const messageId = options.crypto.randomUuid();
+    return enqueueAgentControlEnvelope(
+      tenant,
+      ownerDeviceId,
+      messageId,
+      (seq) => createEnvelope("task.steer", { text: payload.text }, { id: messageId, taskId, seq })
+    );
+  }
   async function getAgentHomeProjectionStatus(tenant, deviceId, input) {
     return readAgentHomeProjectionStatus(
       tenantStoresFor(controlPlane(tenant), root).receipts,
@@ -2928,7 +3522,7 @@ function createByokCloud(options) {
       ]);
       const stores = tenantStoresFor(controlPlane(tenant), root);
       const persisted = await stores.receipts.record({
-        key: `agent-content-request:${deviceId}:${payload.requestId}`,
+        key: agentReliabilityKey("agent-content-request", deviceId, payload.agentRef, payload.requestId),
         body: JSON.stringify(payload)
       });
       if (!persisted.created && persisted.receipt.body !== JSON.stringify(payload)) {
@@ -2937,11 +3531,18 @@ function createByokCloud(options) {
           `Request ${payload.requestId} already exists with a different immutable content-read body.`
         );
       }
+      const messageId = await agentControlEnvelopeId(
+        "byok:agent-content-read",
+        tenant,
+        deviceId,
+        payload.agentRef,
+        payload.requestId
+      );
       const control = await enqueueAgentControlEnvelope(
         tenant,
         deviceId,
-        payload.requestId,
-        (seq) => createEnvelope("agent.content.read", payload, { id: payload.requestId, seq })
+        messageId,
+        (seq) => createEnvelope("agent.content.read", payload, { id: messageId, seq })
       );
       if (control.envelope.type !== "agent.content.read" || JSON.stringify(control.envelope.payload) !== JSON.stringify(payload)) {
         throw new ByokCloudError(
@@ -2960,7 +3561,7 @@ function createByokCloud(options) {
       const stores = tenantStoresFor(controlPlane(tenant), root);
       const requestBody = JSON.stringify(payload);
       const persisted = await stores.receipts.record({
-        key: agentHomeProjectionRequestKey(deviceId, payload.requestId),
+        key: agentHomeProjectionRequestKey(deviceId, payload.agentRef, payload.requestId),
         body: requestBody
       });
       const persistedPayload = AgentHomeProjectionPayloadSchema.parse(JSON.parse(persisted.receipt.body));
@@ -2970,11 +3571,18 @@ function createByokCloud(options) {
           `Agent-home projection request ${payload.requestId} already exists with a different immutable desired body.`
         );
       }
+      const messageId = await agentControlEnvelopeId(
+        "byok:agent-home-projection",
+        tenant,
+        deviceId,
+        payload.agentRef,
+        payload.requestId
+      );
       const control = await enqueueAgentControlEnvelope(
         tenant,
         deviceId,
-        payload.requestId,
-        (seq) => createEnvelope("agent.home.projection", payload, { id: payload.requestId, seq })
+        messageId,
+        (seq) => createEnvelope("agent.home.projection", payload, { id: messageId, seq })
       );
       if (control.envelope.type !== "agent.home.projection" || !sameAgentHomeProjectionRequest(payload, control.envelope.payload)) {
         throw new ByokCloudError(
@@ -2998,6 +3606,13 @@ function createByokCloud(options) {
     getAgentHomeProjectionStatus,
     completeAgentHomeProjection,
     eraseAgentMemoryProjection,
+    approveTask(tenant, taskId, opts) {
+      return resolveApproval(tenant, taskId, "approve", opts);
+    },
+    rejectTask(tenant, taskId, opts) {
+      return resolveApproval(tenant, taskId, "reject", opts);
+    },
+    steerTask,
     async cancelTask(tenant, taskId, reason) {
       const stores = tenantStoresFor(controlPlane(tenant), root);
       const proposedMessageId = options.crypto.randomUuid();
@@ -3037,11 +3652,14 @@ function createByokCloud(options) {
     readTaskAttempt(tenant, taskId) {
       return tenantStoresFor(controlPlane(tenant), root).tasks.get(taskId);
     },
+    listTaskAttempts(tenant, query) {
+      return tenantStoresFor(controlPlane(tenant), root).tasks.list(query);
+    },
     readTerminalReceipt(tenant, taskId) {
       return tenantStoresFor(controlPlane(tenant), root).receipts.get(terminalReceiptKey(taskId));
     },
-    readAgentEgress(tenant, deviceId, eventId) {
-      return tenantStoresFor(controlPlane(tenant), root).egress.get(deviceId, eventId);
+    readAgentEgress(tenant, deviceId, agentRef, eventId) {
+      return tenantStoresFor(controlPlane(tenant), root).egress.get(deviceId, agentRef, eventId);
     },
     async readTaskResult(tenant, taskId) {
       const stores = tenantStoresFor(controlPlane(tenant), root);
@@ -3256,6 +3874,9 @@ var InMemoryBlobContentProxy = class {
     const expected = await this.#registry.computeSig(blobId, action, exp);
     return this.#registry.crypto.timingSafeEqual(expected, sig);
   }
+  async expectedUploadBytes(blobId) {
+    return this.#registry.blobs.get(blobId)?.byteSize;
+  }
   async writeContent(blobId, data) {
     const record = this.#registry.blobs.get(blobId);
     if (record === void 0) return { ok: false, reason: "unknown blobId" };
@@ -3425,7 +4046,15 @@ var InMemoryInboundDedupStore = class {
     this.#capacity = capacity;
   }
   async checkAndRecord(tenant, deviceId, envelopeId) {
-    const key = tenantKey(tenant, deviceId);
+    return this.#checkAndRecord(tenantKey(tenant, deviceId), envelopeId);
+  }
+  async checkAndRecordAgent(tenant, deviceId, agentRef, envelopeId) {
+    return this.#checkAndRecord(
+      tenantKey(tenant, agentReliabilityKey("inbound-dedup", deviceId, agentRef, "")),
+      envelopeId
+    );
+  }
+  #checkAndRecord(key, envelopeId) {
     let ring = this.#rings.get(key);
     if (ring === void 0) {
       ring = /* @__PURE__ */ new Set();
@@ -3469,27 +4098,38 @@ var InMemoryNonceStore = class {
     });
     return nonce;
   }
-  async validate(tenant, deviceId, nonce) {
+  async consumeIfValid(tenant, deviceId, nonce) {
     const record = this.#nonces.get(nonce);
     if (record === void 0) return false;
     if (record.used) return false;
     if (record.owner !== tenantKey(tenant, deviceId)) return false;
-    return this.#clock.now().getTime() <= record.expiresAtMs;
-  }
-  async markUsed(tenant, nonce) {
-    const record = this.#nonces.get(nonce);
-    if (record === void 0) return;
-    if (!record.owner.startsWith(tenantKey(tenant, ""))) return;
+    if (this.#clock.now().getTime() > record.expiresAtMs) return false;
     record.used = true;
+    return true;
   }
 };
 
 // src/stores/in-memory/pairing-codes.ts
+function bindingOf(input) {
+  return {
+    deviceName: input.deviceName,
+    devicePublicKey: input.devicePublicKey,
+    proofKeyId: input.proofKeyId,
+    proofKeyEpoch: input.proofKeyEpoch,
+    ...input.machineId === void 0 ? {} : { machineId: input.machineId }
+  };
+}
+function sameBinding(left, right) {
+  return left.deviceName === right.deviceName && left.devicePublicKey === right.devicePublicKey && left.proofKeyId === right.proofKeyId && left.proofKeyEpoch === right.proofKeyEpoch && left.machineId === right.machineId;
+}
 var InMemoryPairingCodeStore = class {
   #codes = /* @__PURE__ */ new Map();
+  #enrollmentTails = /* @__PURE__ */ new Map();
   #clock;
-  constructor(clock) {
+  #devices;
+  constructor(clock, devices) {
     this.#clock = clock;
+    this.#devices = devices;
   }
   async issue(tenant, input) {
     this.#codes.set(input.code, {
@@ -3499,13 +4139,42 @@ var InMemoryPairingCodeStore = class {
     });
     return { code: input.code, expiresAt: input.expiresAt };
   }
-  async redeem(code) {
-    const record = this.#codes.get(code);
-    if (record === void 0) return void 0;
-    if (record.used) return void 0;
-    if (this.#clock.now().getTime() > record.expiresAtMs) return void 0;
-    record.used = true;
-    return record.claims;
+  async redeemAndRegister(input) {
+    const previous = this.#enrollmentTails.get(input.pairingCode) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.#enrollmentTails.set(input.pairingCode, current);
+    await previous;
+    try {
+      const record = this.#codes.get(input.pairingCode);
+      if (record === void 0) return void 0;
+      if (record.used) {
+        const completion = record.completion;
+        if (completion === void 0 || !sameBinding(completion.binding, bindingOf(input))) return void 0;
+        const active = await this.#devices.get(completion.device.tenantId, completion.device.deviceId);
+        return active === void 0 ? void 0 : completion.device;
+      }
+      if (this.#clock.now().getTime() > record.expiresAtMs) return void 0;
+      const device = await this.#devices.register(record.claims.tenantId, {
+        productId: record.claims.productId,
+        deviceId: input.deviceId,
+        deviceName: input.deviceName,
+        devicePublicKey: input.devicePublicKey,
+        proofKeyId: input.proofKeyId,
+        proofKeyEpoch: input.proofKeyEpoch,
+        ...input.machineId === void 0 ? {} : { machineId: input.machineId }
+      });
+      record.used = true;
+      record.completion = { device, binding: bindingOf(input) };
+      return device;
+    } finally {
+      release();
+      if (this.#enrollmentTails.get(input.pairingCode) === current) {
+        this.#enrollmentTails.delete(input.pairingCode);
+      }
+    }
   }
 };
 var InMemoryRequestReceiptStore = class {
@@ -3553,6 +4222,36 @@ var InMemoryProofRequestReceiptStore = class {
     return this.#receipts.get(tenantKey(tenant, deviceId, requestId));
   }
 };
+
+// src/stores/ports.ts
+var TASK_ATTEMPT_STATUSES = [
+  "offered",
+  "claimed",
+  "running",
+  "cancel_requested",
+  "complete",
+  "failed",
+  "cancelled"
+];
+var BLOB_READ_ERROR_CODES = ["blob_upstream_unavailable", "blob_upstream_stream_interrupted"];
+var CLOUD_STORE_NAMES = [
+  "activity",
+  "approvals",
+  "devices",
+  "pairingCodes",
+  "pairing",
+  "nonces",
+  "dedup",
+  "tasks",
+  "cancellations",
+  "receipts",
+  "egress",
+  "proofReceipts",
+  "blobs",
+  "rateLimiter"
+];
+
+// src/stores/in-memory/task-attempts.ts
 function sameAgentRef3(left, right) {
   return left?.agentId === right?.agentId && left?.profileRevision === right?.profileRevision;
 }
@@ -3595,6 +4294,41 @@ var InMemoryTaskAttemptStore = class {
       return { attempt, created: true };
     });
   }
+  async reserveAgentMessage(tenant, input) {
+    const key = tenantKey(tenant, input.taskId);
+    return this.#state.mutate(key, () => {
+      const existing = this.#state.messageAdmissions.get(key);
+      if (existing !== void 0) {
+        return existing.deviceId === input.deviceId && existing.messageId === input.messageId && existing.payloadBody === input.payloadBody ? "pending" : "rejected";
+      }
+      const attempt = this.#state.attempts.get(key);
+      if (attempt === void 0 || attempt.deviceId !== input.deviceId || attempt.cancellation !== void 0 || !["offered", "claimed", "running"].includes(attempt.status)) return "rejected";
+      this.#state.messageAdmissions.set(key, {
+        deviceId: input.deviceId,
+        messageId: input.messageId,
+        payloadBody: input.payloadBody
+      });
+      return "reserved";
+    });
+  }
+  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;
+  }
+  async finalizeAgentMessage(tenant, input) {
+    const key = tenantKey(tenant, input.taskId);
+    return this.#state.mutate(key, () => this.#terminalize(key, input));
+  }
+  #terminalize(key, input) {
+    const admission = this.#state.messageAdmissions.get(key);
+    if (admission === void 0 || admission.deviceId !== input.deviceId || admission.messageId !== input.messageId || admission.payloadBody !== input.payloadBody) {
+      return void 0;
+    }
+    if (admission.terminalBody !== void 0) return admission;
+    const terminal = { ...admission, terminalBody: input.terminalBody };
+    this.#state.messageAdmissions.set(key, terminal);
+    return terminal;
+  }
   async get(tenant, taskId) {
     return this.#state.attempts.get(tenantKey(tenant, taskId));
   }
@@ -3604,6 +4338,18 @@ var InMemoryTaskAttemptStore = class {
       return attempt === void 0 ? [] : [attempt];
     });
   }
+  async list(tenant, query) {
+    assertTaskAttemptListLimit(query.limit);
+    const cursor = query.cursor;
+    const matches = [...this.#state.attempts.values()].filter((attempt) => attempt.tenantId === tenant).filter((attempt) => cursor === void 0 || attempt.taskId > cursor).sort((left, right) => left.taskId < right.taskId ? -1 : left.taskId > right.taskId ? 1 : 0);
+    const attempts = matches.slice(0, query.limit);
+    const hasMore = matches.length > attempts.length;
+    const last = attempts.at(-1);
+    return {
+      attempts,
+      ...hasMore && last !== void 0 ? { nextCursor: last.taskId } : {}
+    };
+  }
   async claim(tenant, input) {
     const key = tenantKey(tenant, input.taskId);
     return this.#state.mutate(key, () => {
@@ -3613,6 +4359,8 @@ var InMemoryTaskAttemptStore = class {
       const claimed = {
         ...existing,
         ownerDeviceId: input.deviceId,
+        ...input.runtime === void 0 ? {} : { claimedRuntime: input.runtime },
+        ...input.capabilities === void 0 ? {} : { claimedRuntimeCapabilities: { ...input.capabilities } },
         status: "claimed",
         updatedAt: this.#now()
       };
@@ -3647,6 +4395,7 @@ var InMemoryTaskAttemptStore = class {
 };
 var InMemoryTaskAttemptState = class {
   attempts = /* @__PURE__ */ new Map();
+  messageAdmissions = /* @__PURE__ */ new Map();
   #clock;
   #mutationTails = /* @__PURE__ */ new Map();
   constructor(clock) {
@@ -3734,6 +4483,14 @@ var InMemoryActivityStore = class {
     const key = activityTailKey(tenant, input.taskId);
     const existing = this.#tails.get(key);
     const live = existing !== void 0 && receivedAt < existing.expiresAt ? existing : void 0;
+    const sourceState = activitySourceBatchState(live?.entries ?? [], input);
+    if (sourceState === "same") return live;
+    if (sourceState === "conflict") {
+      throw new ByokCloudError(
+        "coordination_input_invalid",
+        `Activity source envelope ${input.sourceEnvelopeId} already belongs to another canonical batch.`
+      );
+    }
     const incoming = projectTimelineEvents(input, receivedAt);
     for (const next of incoming) {
       const collision = live?.entries.find(
@@ -3825,6 +4582,46 @@ var InMemoryApprovalTimelineStore = class {
     this.#tails.set(key, tail);
     return tail;
   }
+  async resolvePending(tenant, input) {
+    const { capacity, ttlMs, event } = validateApprovalTimelineResolve(input);
+    const now = this.clock.now();
+    const receivedAt = now.toISOString();
+    const key = approvalTimelineKey(tenant, input.taskId);
+    const existing = this.#tails.get(key);
+    const live = existing !== void 0 && receivedAt < existing.expiresAt ? existing : void 0;
+    if (live === void 0) return { status: "absent" };
+    const duplicate = live.entries.find((entry) => entry.sourceEnvelopeId === input.sourceEnvelopeId);
+    if (duplicate !== void 0) {
+      if (JSON.stringify(duplicate.event) !== JSON.stringify(event)) return { status: "conflict", tail: live };
+      return { status: "replayed", tail: live };
+    }
+    const pending = pendingObservation(live.entries);
+    if (pending === void 0) return { status: "absent", tail: live };
+    if (pending.sourceEnvelopeId !== input.expectedSourceEnvelopeId || pending.revision !== input.expectedRevision) {
+      return { status: "superseded", tail: live };
+    }
+    const revision = (live.cursor ?? 0) + 1;
+    const observation = ApprovalObservationSchema.parse({
+      taskId: input.taskId,
+      sourceEnvelopeId: input.sourceEnvelopeId,
+      revision,
+      receivedAt,
+      event
+    });
+    const allEntries = [...live.entries, observation];
+    const evicted = Math.max(allEntries.length - capacity, 0);
+    const tail = {
+      tenantId: tenant,
+      taskId: input.taskId,
+      entries: allEntries.slice(evicted),
+      cursor: revision,
+      dropped: live.dropped + evicted,
+      capacity,
+      expiresAt: new Date(now.getTime() + ttlMs).toISOString()
+    };
+    this.#tails.set(key, tail);
+    return { status: "applied", tail };
+  }
   async read(tenant, taskId) {
     const key = approvalTimelineKey(tenant, taskId);
     const tail = this.#tails.get(key);
@@ -3836,6 +4633,19 @@ var InMemoryApprovalTimelineStore = class {
     return tail;
   }
 };
+function pendingObservation(entries) {
+  let pending;
+  for (const entry of entries) {
+    if (entry.event.type === "approval_requested") {
+      pending = entry;
+      continue;
+    }
+    if (pending !== void 0 && (pending.event.approvalId === void 0 || pending.event.approvalId === entry.event.approvalId)) {
+      pending = void 0;
+    }
+  }
+  return pending;
+}
 var InMemoryAgentEgressStore = class {
   #records = /* @__PURE__ */ new Map();
   #clock;
@@ -3843,7 +4653,10 @@ var InMemoryAgentEgressStore = class {
     this.#clock = clock;
   }
   async record(tenant, input) {
-    const key = tenantKey(tenant, `${input.deviceId}\0${input.payload.eventId}`);
+    const key = tenantKey(
+      tenant,
+      agentReliabilityKey("agent-egress", input.deviceId, input.payload.agentRef, input.payload.eventId)
+    );
     const existing = this.#records.get(key);
     if (existing !== void 0) return { record: existing, created: false };
     const record = {
@@ -3856,8 +4669,8 @@ var InMemoryAgentEgressStore = class {
     this.#records.set(key, record);
     return { record, created: true };
   }
-  async get(tenant, deviceId, eventId) {
-    return this.#records.get(tenantKey(tenant, `${deviceId}\0${eventId}`));
+  async get(tenant, deviceId, agentRef, eventId) {
+    return this.#records.get(tenantKey(tenant, agentReliabilityKey("agent-egress", deviceId, agentRef, eventId)));
   }
 };
 
@@ -3866,12 +4679,17 @@ function createInMemoryCloudStores(clock, crypto2, objects, mailbox) {
   const blobs = createInMemoryBlobs(clock, crypto2, objects);
   const taskState = new InMemoryTaskAttemptState(clock);
   const tasks = new InMemoryTaskAttemptStore(clock, taskState);
+  const devices = new InMemoryDeviceDirectory();
+  const pairing = new InMemoryPairingCodeStore(clock, devices);
   return {
     stores: {
       activity: new InMemoryActivityStore(clock),
       approvals: new InMemoryApprovalTimelineStore(clock),
-      devices: new InMemoryDeviceDirectory(),
-      pairingCodes: new InMemoryPairingCodeStore(clock),
+      devices,
+      // One code/device authority, projected into issuance and consumption
+      // ports so neither side exposes the other's methods.
+      pairingCodes: { issue: pairing.issue.bind(pairing) },
+      pairing: { redeemAndRegister: pairing.redeemAndRegister.bind(pairing) },
       nonces: new InMemoryNonceStore(clock, crypto2),
       dedup: new InMemoryInboundDedupStore(),
       tasks,
@@ -3919,7 +4737,9 @@ function createInMemoryByokCloud(options = {}) {
     ...options.truthCommitter === void 0 ? {} : { truthCommitter: options.truthCommitter },
     ...options.truthObjectDownloads === void 0 ? {} : { truthObjectDownloads: options.truthObjectDownloads },
     ...options.operatorId !== void 0 ? { operatorId: options.operatorId } : {},
+    ...options.instanceProductId === void 0 ? {} : { instanceProductId: options.instanceProductId },
     ...options.agentMessage === void 0 ? {} : { agentMessage: options.agentMessage },
+    ...options.observer === void 0 ? {} : { observer: options.observer },
     ...options.agentMemoryProjectionAuthorizer === void 0 ? {} : { agentMemoryProjectionAuthorizer: options.agentMemoryProjectionAuthorizer },
     ...options.agentMemoryProjectionStore === void 0 ? {} : { agentMemoryProjectionStore: options.agentMemoryProjectionStore },
     ...options.maxBlobSizeBytes !== void 0 ? { maxBlobSizeBytes: options.maxBlobSizeBytes } : {},
@@ -4283,42 +5103,27 @@ function parseSseFrame(frame) {
   return { type: "board", item: BoardFeedItemSchema.parse(JSON.parse(data.join("\n"))) };
 }
 
-// src/stores/ports.ts
-var TASK_ATTEMPT_STATUSES = [
-  "offered",
-  "claimed",
-  "running",
-  "cancel_requested",
-  "complete",
-  "failed",
-  "cancelled"
-];
-var BLOB_READ_ERROR_CODES = ["blob_upstream_unavailable", "blob_upstream_stream_interrupted"];
-var CLOUD_STORE_NAMES = [
-  "activity",
-  "approvals",
-  "devices",
-  "pairingCodes",
-  "nonces",
-  "dedup",
-  "tasks",
-  "cancellations",
-  "receipts",
-  "egress",
-  "proofReceipts",
-  "blobs",
-  "rateLimiter"
-];
-
 // src/stores/ports-contract.ts
 var CLOUD_PORT_METHODS = {
   activity: ["append", "read"],
-  approvals: ["append", "read"],
+  approvals: ["append", "read", "resolvePending"],
   devices: ["register", "get", "revoke", "list", "readiness", "recordCapabilities", "resolveByDeviceId"],
-  pairingCodes: ["issue", "redeem"],
-  nonces: ["issue", "validate", "markUsed"],
-  dedup: ["checkAndRecord"],
-  tasks: ["open", "reserveAgentOffer", "get", "getMany", "claim", "recordStatus"],
+  pairingCodes: ["issue"],
+  pairing: ["redeemAndRegister"],
+  nonces: ["issue", "consumeIfValid"],
+  dedup: ["checkAndRecord", "checkAndRecordAgent"],
+  tasks: [
+    "open",
+    "reserveAgentOffer",
+    "reserveAgentMessage",
+    "readAgentMessage",
+    "finalizeAgentMessage",
+    "get",
+    "getMany",
+    "list",
+    "claim",
+    "recordStatus"
+  ],
   cancellations: ["request"],
   receipts: ["record", "get"],
   egress: ["record", "get"],
@@ -4334,6 +5139,7 @@ var CLOUD_PORT_INTERFACES = {
   approvals: "ApprovalTimelineStore",
   devices: "DeviceDirectory",
   pairingCodes: "PairingCodeStore",
+  pairing: "PairingEnrollment",
   nonces: "NonceStore",
   dedup: "InboundDedupStore",
   tasks: "TaskAttemptStore",
@@ -4345,6 +5151,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, 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, agentHomeProjectionCompletionKey, agentHomeProjectionRequestKey, approvalTimelineCursor, authenticateBearer, authenticateDeviceProof, authenticateHostedDeviceAssertion, createAuthPlane, createByokCloud, createHmacTokenSigner, createInMemoryBlobs, createInMemoryByokCloud, createInMemoryCloudStores, createWebCrypto, declares, extractBearerToken, fullCapabilityDeclaration, handleInboundEnvelope, isCloudError, isTruthCommitError, parseApprovalObservations, parseTimelineEvents, projectTerminalResult, projectTimelineEvents, readAgentHomeProjectionStatus, recordAgentHomeProjectionCompletion, routeKey, tenantStoresFor, terminalReceiptKey, truthManifestMetadata, truthRecordMetadata, validateActivityAppend, validateApprovalTimelineAppend, 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, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map