@byok-sdk/cloud 0.6.0 → 0.7.0

package/dist/index.js

@@ -1,6 +1,6 @@
 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, DAEMON_TO_SERVER_TYPES, encodeEnvelope, decodeEnvelope, BYOK_PAIR_PATH, BYOK_CHALLENGE_PATH, BYOK_TOKEN_PATH, BYOK_CAPABILITIES_PATH, BYOK_EVENTS_PATH, BYOK_MESSAGES_PATH, 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, PairRequestSchema, ChallengeRequestSchema, TokenRequestSchema, MessagesSendRequestSchema, PresencePublishRequestSchema, CreateBlobRequestSchema, byokBlobContentPath } from '@byok-sdk/protocol';
+import { AgentEventOrUnknownSchema, PROTOCOL_VERSION, DAEMON_TO_SERVER_TYPES, AGENT_EGRESS_RELIABLE_ACK_CAPABILITY, encodeEnvelope, decodeEnvelope, BYOK_PAIR_PATH, BYOK_CHALLENGE_PATH, BYOK_TOKEN_PATH, BYOK_CAPABILITIES_PATH, BYOK_EVENTS_PATH, BYOK_MESSAGES_PATH, 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, AgentContentReadPayloadSchema, AGENT_EGRESS_POLICY_CAPABILITY, TaskOfferForAgentWithEgressPayloadSchema, TaskOfferForAgentPayloadSchema, AGENT_CONTENT_ARTIFACT_READ_CAPABILITY, AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY, AGENT_CONTENT_WORKSPACE_READ_CAPABILITY, PairRequestSchema, PairResponseSchema, ChallengeRequestSchema, TokenRequestSchema, MessagesSendRequestSchema, PresencePublishRequestSchema, CreateBlobRequestSchema, byokBlobContentPath, AgentEgressAckPayloadSchema, AgentContentReceiptPayloadSchema } from '@byok-sdk/protocol';
 import { z } from 'zod';
 import { Hono } from 'hono';
 
@@ -160,8 +160,8 @@ function createHmacTokenSigner(secret, clock) {
     }
   };
 }
-function verifyNonceSignature(crypto, devicePublicKey, nonce, signature) {
-  return crypto.verifyEd25519(devicePublicKey, NONCE_SIGNING_DOMAIN + nonce, signature);
+function verifyNonceSignature(crypto2, devicePublicKey, nonce, signature) {
+  return crypto2.verifyEd25519(devicePublicKey, NONCE_SIGNING_DOMAIN + nonce, signature);
 }
 
 // src/auth/plane.ts
@@ -170,13 +170,13 @@ var PAIRING_CODE_LENGTH = 8;
 var DEVICE_IDENTITY_PROOF_KEY_ID = "identity";
 var DEVICE_IDENTITY_PROOF_KEY_EPOCH = 0;
 function createAuthPlane(deps) {
-  const { stores, crypto, clock, tokenSigner } = deps;
+  const { stores, crypto: crypto2, clock, tokenSigner } = deps;
   const ttlSeconds = deps.accessTokenTtlSeconds ?? ACCESS_TOKEN_TTL_SECONDS;
   return {
     async createPairingCode(tenant, input) {
       const expiresAt = new Date(clock.now().getTime() + (input.ttlMs ?? PAIRING_CODE_TTL_MS)).toISOString();
       return stores.pairingCodes.issue(tenant, {
-        code: crypto.randomPairingCode(PAIRING_CODE_LENGTH),
+        code: crypto2.randomPairingCode(PAIRING_CODE_LENGTH),
         productId: input.productId,
         expiresAt
       });
@@ -186,7 +186,7 @@ function createAuthPlane(deps) {
       if (claims === void 0) return void 0;
       return stores.devices.register(claims.tenantId, {
         productId: claims.productId,
-        deviceId: `dev_${crypto.randomUuid()}`,
+        deviceId: `dev_${crypto2.randomUuid()}`,
         deviceName: input.deviceName,
         devicePublicKey: input.devicePublicKey,
         proofKeyId: DEVICE_IDENTITY_PROOF_KEY_ID,
@@ -208,7 +208,7 @@ function createAuthPlane(deps) {
       return stores.nonces.markUsed(device.tenantId, nonce);
     },
     verifySignature(device, nonce, signature) {
-      return verifyNonceSignature(crypto, device.devicePublicKey, nonce, signature);
+      return verifyNonceSignature(crypto2, device.devicePublicKey, nonce, signature);
     },
     async mintAccessToken(device) {
       const accessToken = await tokenSigner.sign(
@@ -319,7 +319,17 @@ var CLOUD_ERROR_CODES = {
   /** A progress/activity batch exceeded the configured event or byte ceiling. */
   activity_batch_too_large: "activity_batch_too_large",
   /** Host control-plane task lookup is tenant-closed and found no task. */
-  task_not_found: "task_not_found"
+  task_not_found: "task_not_found",
+  /** Durable target-device capability is absent, revoked, or unavailable. */
+  agent_capability_missing: "agent_capability_missing",
+  /** Inbound Agent identity did not exactly match the offered identity. */
+  agent_ref_mismatch: "agent_ref_mismatch",
+  /** A strict Agent task id already names a durable attempt and cannot be re-enqueued. */
+  agent_task_already_exists: "agent_task_already_exists",
+  /** A first-write-wins Agent control record was replayed with a different body. */
+  agent_content_request_mismatch: "agent_content_request_mismatch",
+  /** A durable mailbox receipt id resolved to an envelope other than its exact acknowledgement. */
+  mailbox_receipt_mismatch: "mailbox_receipt_mismatch"
 };
 var ByokCloudError = class extends Error {
   code;
@@ -527,10 +537,15 @@ function tenantStoresFor(principal, root) {
       get: (deviceId) => cloud.devices.get(tenant, deviceId),
       list: () => cloud.devices.list(tenant),
       revoke: (deviceId) => cloud.devices.revoke(tenant, deviceId),
+      recordCapabilities: (input) => principal.kind === "device" ? cloud.devices.recordCapabilities(tenant, {
+        deviceId: principal.deviceId,
+        capabilities: input.capabilities
+      }) : Promise.resolve(void 0),
       readiness: () => cloud.devices.readiness(tenant, core.presence)
     },
     tasks: {
       open: (input) => cloud.tasks.open(tenant, input),
+      reserveAgentOffer: (input) => cloud.tasks.reserveAgentOffer(tenant, input),
       get: (taskId) => cloud.tasks.get(tenant, taskId),
       getMany: (taskIds) => cloud.tasks.getMany(tenant, taskIds),
       claim: (input) => cloud.tasks.claim(tenant, input),
@@ -546,6 +561,10 @@ function tenantStoresFor(principal, root) {
       record: (input) => cloud.receipts.record(tenant, input),
       get: (key) => cloud.receipts.get(tenant, key)
     },
+    egress: {
+      record: (input) => cloud.egress.record(tenant, input),
+      get: (deviceId, eventId) => cloud.egress.get(tenant, deviceId, eventId)
+    },
     blobs: {
       createUpload: (reservation) => cloud.blobs.createUpload(tenant, reservation),
       observeUpload: (blobId, reservation) => cloud.blobs.observeUpload(tenant, blobId, reservation),
@@ -685,11 +704,16 @@ function blobDownloadContentHandler(deps) {
     if (!query.success || !await deps.contentProxy.verifySignedUrl(blobId, "get", query.data.sig, query.data.exp)) {
       return c.json({ error: "invalid or expired signature" }, 401);
     }
-    const content = await deps.contentProxy.readContent(blobId);
-    if (content === void 0) return c.json({ error: "blob not found" }, 404);
-    return c.body(new Uint8Array(content.data), 200, { "content-type": content.contentType });
+    const result = await deps.contentProxy.readContent(blobId);
+    if (result === void 0) return c.json({ error: "blob not found" }, 404);
+    if (!result.ok) return c.json({ error: result.code }, BLOB_READ_ERROR_HTTP_STATUS[result.code]);
+    return c.body(new Uint8Array(result.content.data), 200, { "content-type": result.content.contentType });
   };
 }
+var BLOB_READ_ERROR_HTTP_STATUS = {
+  blob_upstream_unavailable: 502,
+  blob_upstream_stream_interrupted: 502
+};
 function idempotencyKey(c) {
   const value = c.req.header("Idempotency-Key");
   if (value === void 0 || value.length === 0 || value.length > 200) return void 0;
@@ -726,7 +750,12 @@ function pairHandler(deps) {
     const device = await deps.auth.redeemAndRegister(parsed.data);
     if (device === void 0) return c.json({ error: "invalid pairing code" }, 401);
     const { accessToken, expiresAt } = await deps.auth.mintAccessToken(device);
-    const response = { deviceId: device.deviceId, accessToken, refreshHint: expiresAt };
+    const response = PairResponseSchema.parse({
+      deviceId: device.deviceId,
+      accessToken,
+      refreshHint: expiresAt,
+      tenantId: device.tenantId
+    });
     return c.json(response, 200);
   };
 }
@@ -759,7 +788,15 @@ function tokenHandler(deps) {
     return c.json(response, 200);
   };
 }
-var CLOUD_PROTOCOL_CAPABILITIES = ["result-document"];
+var CLOUD_PROTOCOL_CAPABILITIES = [
+  "result-document",
+  "agent-home-contract",
+  "agent-egress-policy",
+  "agent-egress-reliable-ack",
+  "agent-content-workspace-read",
+  "agent-content-transcript-read",
+  "agent-content-artifact-read"
+];
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -791,13 +828,15 @@ function eventsHandler(deps) {
         if (page.messages.length === 0) break;
         const decoded = page.messages.map((message) => decodeEnvelope(message.body));
         const offeredTaskIds = decoded.flatMap(
-          (event) => (event.type === "task.offer" || event.type === "task.offer_with_toolsets") && event.task_id !== void 0 ? [event.task_id] : []
+          (event) => (event.type === "task.offer" || event.type === "task.offer_with_toolsets" || event.type === "task.offer_for_agent" || event.type === "task.offer_for_agent_with_egress") && event.task_id !== void 0 ? [event.task_id] : []
         );
         const attemptsByTaskId = Object.fromEntries(
           (await stores.tasks.getMany(offeredTaskIds)).map((attempt2) => [attempt2.taskId, attempt2])
         );
         const events = decoded.filter((event) => {
-          if (event.type !== "task.offer" && event.type !== "task.offer_with_toolsets") return true;
+          if (event.type !== "task.offer" && event.type !== "task.offer_with_toolsets" && event.type !== "task.offer_for_agent" && event.type !== "task.offer_for_agent_with_egress") {
+            return true;
+          }
           return event.task_id === void 0 || attemptsByTaskId[event.task_id]?.cancellation === void 0;
         });
         if (events.length === 0 && page.hasMore) {
@@ -910,13 +949,103 @@ async function projectTerminalToReview(board, taskId) {
 function terminalReceiptKey(taskId) {
   return `task:${taskId}:terminal`;
 }
+function sameAgentRef(expected, actual) {
+  return actual?.agentId === expected.agentId && actual.profileRevision === expected.profileRevision;
+}
+function sameReliableEgress(expected, actual) {
+  return sameAgentRef(expected.agentRef, actual.agentRef) && expected.sessionRef === actual.sessionRef && expected.policyRevision === actual.policyRevision && expected.eventId === actual.eventId && expected.cursor === actual.cursor && expected.contentHash === actual.contentHash && expected.byteCount === actual.byteCount && JSON.stringify(expected.payload) === JSON.stringify(actual.payload);
+}
+function contentReadCapability(surface) {
+  switch (surface) {
+    case "workspace":
+      return AGENT_CONTENT_WORKSPACE_READ_CAPABILITY;
+    case "transcript":
+      return AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY;
+    case "artifact":
+      return AGENT_CONTENT_ARTIFACT_READ_CAPABILITY;
+  }
+}
+function hasCapabilities(capabilities, required) {
+  return capabilities !== void 0 && required.every((capability) => capabilities.includes(capability));
+}
+function contentRequestReceiptKey(deviceId, requestId) {
+  return `agent-content-request:${deviceId}:${requestId}`;
+}
+function contentReceiptKey(deviceId, requestId) {
+  return `agent-content:${deviceId}:${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));
+  if (stored === void 0) return void 0;
+  try {
+    return AgentContentReadPayloadSchema.parse(JSON.parse(stored.body));
+  } catch {
+    return void 0;
+  }
+}
+function inboundAgentRef(envelope) {
+  switch (envelope.type) {
+    case "task.claim":
+    case "task.decline":
+    case "task.complete":
+    case "task.fail":
+    case "task.cancelled":
+      return envelope.payload.agentRef;
+    default:
+      return void 0;
+  }
+}
+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) {
   if (!await stores.rateLimiter.consume(deviceId)) return "rate_limited";
+  if (envelope.type === "conn.hello") {
+    if (envelope.payload.deviceId !== deviceId) return "rejected";
+    if (!envelope.payload.protocolVersions.includes(PROTOCOL_VERSION)) return "rejected";
+    const device = await stores.devices.get(deviceId);
+    if (device === void 0 || device.revoked || device.productId !== envelope.payload.productId) {
+      return "rejected";
+    }
+    if (await stores.dedup.checkAndRecord(deviceId, envelope.id)) return "duplicate";
+    return await stores.devices.recordCapabilities({ capabilities: envelope.payload.capabilities }) === void 0 ? "rejected" : "accepted";
+  }
   if (!DAEMON_TO_SERVER_TYPES.includes(envelope.type)) return "rejected";
+  if (envelope.type === "agent.egress.reliable") {
+    const device = await stores.devices.get(deviceId);
+    if (device === void 0 || device.revoked || !hasCapabilities(device.capabilities, [AGENT_EGRESS_POLICY_CAPABILITY, AGENT_EGRESS_RELIABLE_ACK_CAPABILITY])) {
+      return "rejected";
+    }
+    const outcome = await stores.egress.record({
+      deviceId,
+      payload: envelope.payload,
+      receiptId: crypto.randomUUID()
+    });
+    return outcome.created || sameReliableEgress(outcome.record.payload, envelope.payload) ? outcome.created ? "accepted" : "duplicate" : "rejected";
+  }
+  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);
+    if (request === void 0 || !matchesContentReadReceipt(request, envelope.payload)) return "rejected";
+    const key = contentReceiptKey(deviceId, 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";
+  }
   const taskId = envelope.task_id;
   if (taskId === void 0) return "rejected";
   const attempt = await stores.tasks.get(taskId);
+  if (attempt?.agentRef !== void 0 && attempt.deviceId !== deviceId) return "rejected";
   if (attempt?.ownerDeviceId !== void 0 && attempt.ownerDeviceId !== deviceId) return "rejected";
+  if (attempt?.agentRef !== void 0 && agentRefEchoRequired(envelope) && !sameAgentRef(attempt.agentRef, inboundAgentRef(envelope))) {
+    return "rejected";
+  }
   if (envelope.type === "task.progress" && envelope.payload.events.length > 0) {
     try {
       validateActivityBatch(
@@ -946,19 +1075,27 @@ async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds
     }
   }
   if (await stores.dedup.checkAndRecord(deviceId, envelope.id)) return "duplicate";
-  await applyLifecycle(stores, deviceId, taskId, envelope, activityBounds);
+  await applyLifecycle(stores, deviceId, taskId, envelope, activityBounds, attempt?.agentRef);
   return "accepted";
 }
-async function applyLifecycle(stores, deviceId, taskId, envelope, activityBounds) {
+async function applyLifecycle(stores, deviceId, taskId, envelope, activityBounds, persistedAgentRef) {
   switch (envelope.type) {
     case "task.claim":
       await stores.tasks.claim({ taskId, deviceId });
       return;
     case "task.started":
-      await stores.tasks.recordStatus({ taskId, status: "running" });
+      await stores.tasks.recordStatus({
+        taskId,
+        status: "running",
+        ...persistedAgentRef === void 0 ? {} : { agentRef: persistedAgentRef }
+      });
       return;
     case "task.decline":
-      await stores.tasks.recordStatus({ taskId, status: "failed" });
+      await stores.tasks.recordStatus({
+        taskId,
+        status: "failed",
+        ...persistedAgentRef === void 0 ? {} : { agentRef: persistedAgentRef }
+      });
       return;
     case "task.progress":
       if (envelope.payload.events.length > 0) {
@@ -1030,12 +1167,22 @@ async function recordTerminal(stores, taskId, envelope, status) {
   });
   if (attempt?.cancellation !== void 0) {
     if (status === "cancelled") {
-      await stores.tasks.recordStatus({ taskId, status: "cancelled" });
+      await stores.tasks.recordStatus({
+        taskId,
+        status: "cancelled",
+        ...attempt.agentRef === void 0 ? {} : { agentRef: attempt.agentRef }
+      });
     }
     return;
   }
   if (!created) return;
-  const recordedAttempt = await stores.tasks.recordStatus({ taskId, status });
+  const cause = envelope.type === "task.fail" || envelope.type === "task.cancelled" ? envelope.payload.reason : void 0;
+  const recordedAttempt = await stores.tasks.recordStatus({
+    taskId,
+    status,
+    ...attempt?.agentRef === void 0 ? {} : { agentRef: attempt.agentRef },
+    ...cause === void 0 ? {} : { terminalCause: cause }
+  });
   if (recordedAttempt?.status !== status || recordedAttempt.cancellation !== void 0) return;
   await projectTerminalToReview(stores.board, taskId);
 }
@@ -1058,6 +1205,16 @@ function messagesHandler(deps) {
         deps.activityBounds
       );
       if (outcome === "rate_limited") return c.json({ error: "rate limit exceeded" }, 429);
+      if (envelope.type === "agent.egress.reliable" && (outcome === "accepted" || outcome === "duplicate")) {
+        const record = await stores.egress.get(device.deviceId, envelope.payload.eventId);
+        if (record === void 0) {
+          throw new Error(`Accepted reliable egress ${envelope.payload.eventId} has no durable receipt record.`);
+        }
+        await deps.appendReliableEgressAck(stores, record);
+      }
+      if (envelope.type === "agent.content.receipt" && (outcome === "accepted" || outcome === "duplicate")) {
+        await deps.appendContentReceiptAck(stores, device.deviceId, envelope.payload);
+      }
       if (outcome === "rejected") rejected += 1;
       else accepted += 1;
     }
@@ -1825,6 +1982,7 @@ function projectTerminalResult(taskId, receipt) {
       return {
         taskId,
         state: "complete",
+        ...envelope.payload.agentRef === void 0 ? {} : { agentRef: envelope.payload.agentRef },
         summary: envelope.payload.summary,
         sessionRef: envelope.payload.sessionRef,
         ...envelope.payload.artifactRefs !== void 0 ? { artifactRefs: envelope.payload.artifactRefs } : {},
@@ -1836,7 +1994,9 @@ function projectTerminalResult(taskId, receipt) {
       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 } : {},
         ...envelope.payload.usage !== void 0 ? { usage: envelope.payload.usage } : {},
         recordedAt: receipt.recordedAt
@@ -1845,7 +2005,9 @@ function projectTerminalResult(taskId, receipt) {
       return {
         taskId,
         state: "cancelled",
+        ...envelope.payload.agentRef === void 0 ? {} : { agentRef: envelope.payload.agentRef },
         ...envelope.payload.reason !== void 0 ? { reason: envelope.payload.reason } : {},
+        ...envelope.payload.reason === void 0 ? {} : { terminalCause: envelope.payload.reason },
         ...envelope.payload.usage !== void 0 ? { usage: envelope.payload.usage } : {},
         recordedAt: receipt.recordedAt
       };
@@ -1862,6 +2024,10 @@ var DEFAULT_MAX_BLOB_SIZE_BYTES = 100 * 1024 * 1024;
 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 sameAgentRef2(expected, actual) {
+  return actual?.agentId === expected.agentId && actual.profileRevision === expected.profileRevision;
+}
 function createByokCloud(options) {
   const declaration = parseDeclaration(options.capabilities);
   assertNoOverDeclaration(
@@ -1911,7 +2077,12 @@ function createByokCloud(options) {
   if (declares(declaration, CLOUD_CAPABILITIES.messagesBatch)) {
     registry.register(
       { method: "POST", path: BYOK_MESSAGES_PATH, class: "device" },
-      messagesHandler({ ...deviceRouteDeps, activityBounds })
+      messagesHandler({
+        ...deviceRouteDeps,
+        activityBounds,
+        appendReliableEgressAck: enqueueReliableEgressAck,
+        appendContentReceiptAck: enqueueContentReceiptAck
+      })
     );
   }
   if (declares(declaration, CLOUD_CAPABILITIES.boardCoordination)) {
@@ -2029,16 +2200,98 @@ function createByokCloud(options) {
   function controlPlane(tenant) {
     return { kind: "control-plane", tenantId: tenant, operatorId };
   }
-  async function enqueueTaskEnvelope(tenant, deviceId, requestedTaskId, buildEnvelope) {
+  async function enqueueTaskEnvelope(tenant, deviceId, requestedTaskId, agentRef, buildEnvelope) {
     const stores = tenantStoresFor(controlPlane(tenant), root);
     const taskId = requestedTaskId ?? `task_${options.crypto.randomUuid()}`;
     const messageId = options.crypto.randomUuid();
+    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))) {
+      throw new ByokCloudError(
+        "agent_ref_mismatch",
+        `Task ${taskId} already has a different durable Agent identity or target device.`
+      );
+    }
+    if (reservation !== void 0 && !reservation.created) {
+      throw new ByokCloudError(
+        "agent_task_already_exists",
+        `Task ${taskId} already has a durable Agent attempt and cannot be enqueued again.`
+      );
+    }
+    let message;
+    try {
+      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 envelope = decodeEnvelope(message.body);
+    if (envelope.seq !== message.seq) {
+      throw new ByokCloudError(
+        "mailbox_seq_mismatch",
+        `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 };
+  }
+  async function assertAgentCapabilities(tenant, deviceId, required) {
+    const device = await options.cloud.devices.get(tenant, deviceId);
+    if (device === void 0 || device.revoked || !device.capabilities || !required.every((capability) => device.capabilities.includes(capability))) {
+      const missing = required.filter((capability) => !device?.capabilities?.includes(capability));
+      throw new ByokCloudError(
+        "agent_capability_missing",
+        `Device ${deviceId} lacks durable Agent capabilities (${missing.join(", ")}); refusing before mailbox append.`
+      );
+    }
+  }
+  function contentReadCapability2(surface) {
+    switch (surface) {
+      case "workspace":
+        return AGENT_CONTENT_WORKSPACE_READ_CAPABILITY;
+      case "transcript":
+        return AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY;
+      case "artifact":
+        return AGENT_CONTENT_ARTIFACT_READ_CAPABILITY;
+    }
+  }
+  async function enqueueAgentControlEnvelope(tenant, deviceId, messageId, buildEnvelope) {
+    const stores = tenantStoresFor(controlPlane(tenant), root);
     const message = await stores.mailbox.append({
       deviceId,
       messageId,
       materialize: async (seq) => {
-        const envelope2 = buildEnvelope(taskId, seq, messageId);
-        const body = encodeEnvelope(envelope2);
+        const body = encodeEnvelope(buildEnvelope(seq));
         const bytes = new TextEncoder().encode(body);
         return {
           body,
@@ -2051,11 +2304,77 @@ function createByokCloud(options) {
     if (envelope.seq !== message.seq) {
       throw new ByokCloudError(
         "mailbox_seq_mismatch",
-        `Mailbox stored offer seq ${String(envelope.seq)} at row ${message.seq}; the daemon's redelivery cursor would be wrong.`
+        `Mailbox stored Agent control seq ${String(envelope.seq)} at row ${message.seq}.`
+      );
+    }
+    return { seq: message.seq, envelope };
+  }
+  async function enqueueReliableEgressAck(stores, record) {
+    const payload = AgentEgressAckPayloadSchema.parse({
+      agentRef: record.payload.agentRef,
+      sessionRef: record.payload.sessionRef,
+      policyRevision: record.payload.policyRevision,
+      eventId: record.payload.eventId,
+      cursor: record.payload.cursor,
+      receiptId: record.receiptId
+    });
+    const message = await stores.mailbox.append({
+      deviceId: record.deviceId,
+      messageId: record.receiptId,
+      materialize: async (seq) => {
+        const body = encodeEnvelope(createEnvelope("agent.egress.ack", payload, { id: record.receiptId, seq }));
+        const bytes = new TextEncoder().encode(body);
+        return {
+          body,
+          bodyHash: contentHash(await options.crypto.sha256(bytes)),
+          byteSize: BigInt(bytes.length)
+        };
+      }
+    });
+    const decoded = decodeEnvelope(message.body);
+    if (decoded.type !== "agent.egress.ack" || decoded.seq !== message.seq || JSON.stringify(decoded.payload) !== JSON.stringify(payload)) {
+      throw new ByokCloudError(
+        "mailbox_receipt_mismatch",
+        `Mailbox receipt ${record.receiptId} does not exactly acknowledge Agent egress ${record.payload.eventId}.`
+      );
+    }
+  }
+  async function enqueueContentReceiptAck(stores, deviceId, receipt) {
+    const exactReceipt = AgentContentReceiptPayloadSchema.parse(receipt);
+    if (exactReceipt.eventId !== exactReceipt.requestId) {
+      throw new ByokCloudError("mailbox_receipt_mismatch", "Content receipt eventId must equal requestId.");
+    }
+    const payload = AgentEgressAckPayloadSchema.parse({
+      agentRef: exactReceipt.agentRef,
+      sessionRef: exactReceipt.sessionRef,
+      policyRevision: exactReceipt.policyRevision,
+      eventId: exactReceipt.eventId,
+      cursor: exactReceipt.cursor,
+      receiptId: exactReceipt.requestId
+    });
+    const message = await stores.mailbox.append({
+      deviceId,
+      // The request itself already occupies its bare request id in this
+      // mailbox. A namespaced producer key keeps the ack idempotent without
+      // returning that control envelope on duplicate receipt delivery.
+      messageId: `agent-content-ack:${exactReceipt.requestId}`,
+      materialize: async (seq) => {
+        const body = encodeEnvelope(createEnvelope("agent.egress.ack", payload, { id: exactReceipt.requestId, seq }));
+        const bytes = new TextEncoder().encode(body);
+        return {
+          body,
+          bodyHash: contentHash(await options.crypto.sha256(bytes)),
+          byteSize: BigInt(bytes.length)
+        };
+      }
+    });
+    const decoded = decodeEnvelope(message.body);
+    if (decoded.type !== "agent.egress.ack" || decoded.seq !== message.seq || JSON.stringify(decoded.payload) !== JSON.stringify(payload)) {
+      throw new ByokCloudError(
+        "mailbox_receipt_mismatch",
+        `Mailbox content receipt ${exactReceipt.requestId} does not exactly acknowledge its durable content fact.`
       );
     }
-    const attempt = await stores.tasks.open({ taskId, deviceId });
-    return { taskId, seq: message.seq, envelope, attempt };
   }
   return {
     fetch: registry.fetch,
@@ -2070,6 +2389,7 @@ function createByokCloud(options) {
         tenant,
         deviceId,
         input.taskId,
+        void 0,
         (taskId, seq, messageId) => createEnvelope("task.offer", input.payload, { id: messageId, taskId, seq })
       );
     },
@@ -2078,9 +2398,69 @@ function createByokCloud(options) {
         tenant,
         deviceId,
         input.taskId,
+        void 0,
         (taskId, seq, messageId) => createEnvelope("task.offer_with_toolsets", input.payload, { id: messageId, taskId, seq })
       );
     },
+    async enqueueAgentOffer(tenant, deviceId, input) {
+      await assertAgentCapabilities(tenant, deviceId, [AGENT_HOME_CONTRACT_CAPABILITY]);
+      const payload = TaskOfferForAgentPayloadSchema.parse(input.payload);
+      return enqueueTaskEnvelope(
+        tenant,
+        deviceId,
+        input.taskId,
+        payload.agentRef,
+        (taskId, seq, messageId) => createEnvelope("task.offer_for_agent", payload, { id: messageId, taskId, seq })
+      );
+    },
+    async enqueueAgentEgressOffer(tenant, deviceId, input) {
+      await assertAgentCapabilities(tenant, deviceId, [
+        AGENT_HOME_CONTRACT_CAPABILITY,
+        AGENT_EGRESS_POLICY_CAPABILITY,
+        AGENT_EGRESS_RELIABLE_ACK_CAPABILITY
+      ]);
+      const payload = TaskOfferForAgentWithEgressPayloadSchema.parse(input.payload);
+      return enqueueTaskEnvelope(
+        tenant,
+        deviceId,
+        input.taskId,
+        payload.agentRef,
+        (taskId, seq, messageId) => createEnvelope("task.offer_for_agent_with_egress", payload, { id: messageId, taskId, seq })
+      );
+    },
+    async enqueueAgentContentRead(tenant, deviceId, input) {
+      const payload = AgentContentReadPayloadSchema.parse(input.payload);
+      await assertAgentCapabilities(tenant, deviceId, [
+        AGENT_HOME_CONTRACT_CAPABILITY,
+        AGENT_EGRESS_POLICY_CAPABILITY,
+        AGENT_EGRESS_RELIABLE_ACK_CAPABILITY,
+        contentReadCapability2(payload.surface)
+      ]);
+      const stores = tenantStoresFor(controlPlane(tenant), root);
+      const persisted = await stores.receipts.record({
+        key: `agent-content-request:${deviceId}:${payload.requestId}`,
+        body: JSON.stringify(payload)
+      });
+      if (!persisted.created && persisted.receipt.body !== JSON.stringify(payload)) {
+        throw new ByokCloudError(
+          "agent_content_request_mismatch",
+          `Request ${payload.requestId} already exists with a different immutable content-read body.`
+        );
+      }
+      const control = await enqueueAgentControlEnvelope(
+        tenant,
+        deviceId,
+        payload.requestId,
+        (seq) => createEnvelope("agent.content.read", payload, { id: payload.requestId, seq })
+      );
+      if (control.envelope.type !== "agent.content.read" || JSON.stringify(control.envelope.payload) !== JSON.stringify(payload)) {
+        throw new ByokCloudError(
+          "agent_content_request_mismatch",
+          `Request ${payload.requestId} already exists with a different immutable content-read body.`
+        );
+      }
+      return control;
+    },
     async cancelTask(tenant, taskId, reason) {
       const stores = tenantStoresFor(controlPlane(tenant), root);
       const proposedMessageId = options.crypto.randomUuid();
@@ -2123,6 +2503,9 @@ function createByokCloud(options) {
     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);
+    },
     async readTaskResult(tenant, taskId) {
       const stores = tenantStoresFor(controlPlane(tenant), root);
       const attempt = await stores.tasks.get(taskId);
@@ -2130,7 +2513,9 @@ function createByokCloud(options) {
         return {
           taskId,
           state: "cancelled",
+          ...attempt.agentRef === void 0 ? {} : { agentRef: attempt.agentRef },
           ...attempt.cancellation.reason === void 0 ? {} : { reason: attempt.cancellation.reason },
+          ...attempt.cancellation.reason === void 0 ? {} : { terminalCause: attempt.cancellation.reason },
           recordedAt: attempt.cancellation.requestedAt
         };
       }
@@ -2235,9 +2620,9 @@ var InMemoryBlobRegistry = class {
   crypto;
   secret;
   urlTtlMs;
-  constructor(clock, crypto, options) {
+  constructor(clock, crypto2, options) {
     this.clock = clock;
-    this.crypto = crypto;
+    this.crypto = crypto2;
     this.secret = globalThis.crypto.getRandomValues(new Uint8Array(SIGNING_SECRET_BYTES));
     this.urlTtlMs = options.urlTtlMs ?? BLOB_URL_TTL_MS;
   }
@@ -2342,14 +2727,20 @@ var InMemoryBlobContentProxy = class {
     record.uploaded = true;
     return { ok: true };
   }
+  /**
+   * Never returns `{ok:false}`: this composition holds the bytes in the same
+   * process, so there is no upstream to be unreachable and no stream to be
+   * interrupted. Both `BlobReadErrorCode`s are structurally unreachable here
+   * — a proxy that fetches from object storage is where they become live.
+   */
   async readContent(blobId) {
     const record = this.#registry.blobs.get(blobId);
     if (record === void 0 || !record.uploaded || record.data === void 0) return void 0;
-    return { data: record.data, contentType: record.contentType };
+    return { ok: true, content: { data: record.data, contentType: record.contentType } };
   }
 };
-function createInMemoryBlobs(clock, crypto, objects, options = {}) {
-  const registry = new InMemoryBlobRegistry(clock, crypto, options);
+function createInMemoryBlobs(clock, crypto2, objects, options = {}) {
+  const registry = new InMemoryBlobRegistry(clock, crypto2, options);
   return {
     blobs: new InMemoryCloudBlobStore(registry, objects),
     contentProxy: new InMemoryBlobContentProxy(registry)
@@ -2392,6 +2783,17 @@ var InMemoryDeviceDirectory = class {
     if (record === void 0) return;
     this.#byTenant.set(key, { ...record, revoked: true });
   }
+  async recordCapabilities(tenant, input) {
+    const key = tenantKey(tenant, input.deviceId);
+    const record = this.#byTenant.get(key);
+    if (record === void 0 || record.revoked) return void 0;
+    const updated = {
+      ...record,
+      capabilities: Object.freeze([...input.capabilities])
+    };
+    this.#byTenant.set(key, updated);
+    return updated;
+  }
   async list(tenant) {
     const prefix = tenantKey(tenant, "");
     return [...this.#byTenant.entries()].filter(([key]) => key.startsWith(prefix)).map(([, record]) => record);
@@ -2477,9 +2879,9 @@ var InMemoryNonceStore = class {
   #clock;
   #crypto;
   #ttlMs;
-  constructor(clock, crypto, ttlMs = NONCE_TTL_MS) {
+  constructor(clock, crypto2, ttlMs = NONCE_TTL_MS) {
     this.#clock = clock;
-    this.#crypto = crypto;
+    this.#crypto = crypto2;
     this.#ttlMs = ttlMs;
   }
   /** Number of records currently held (post-sweep). Test-facing only. */
@@ -2583,6 +2985,9 @@ var InMemoryProofRequestReceiptStore = class {
     return this.#receipts.get(tenantKey(tenant, deviceId, requestId));
   }
 };
+function sameAgentRef3(left, right) {
+  return left?.agentId === right?.agentId && left?.profileRevision === right?.profileRevision;
+}
 var InMemoryTaskAttemptStore = class {
   #state;
   constructor(clock, state = new InMemoryTaskAttemptState(clock)) {
@@ -2597,6 +3002,7 @@ var InMemoryTaskAttemptStore = class {
         tenantId: tenant,
         taskId: input.taskId,
         deviceId: input.deviceId,
+        ...input.agentRef === void 0 ? {} : { agentRef: { ...input.agentRef } },
         status: "offered",
         updatedAt: this.#now()
       };
@@ -2604,6 +3010,23 @@ var InMemoryTaskAttemptStore = class {
       return attempt;
     });
   }
+  async reserveAgentOffer(tenant, input) {
+    const key = tenantKey(tenant, input.taskId);
+    return this.#state.mutate(key, () => {
+      const existing = this.#state.attempts.get(key);
+      if (existing !== void 0) return { attempt: existing, created: false };
+      const attempt = {
+        tenantId: tenant,
+        taskId: input.taskId,
+        deviceId: input.deviceId,
+        agentRef: { ...input.agentRef },
+        status: "offered",
+        updatedAt: this.#now()
+      };
+      this.#state.attempts.set(key, attempt);
+      return { attempt, created: true };
+    });
+  }
   async get(tenant, taskId) {
     return this.#state.attempts.get(tenantKey(tenant, taskId));
   }
@@ -2634,12 +3057,18 @@ var InMemoryTaskAttemptStore = class {
     return this.#state.mutate(key, () => {
       const existing = this.#state.attempts.get(key);
       if (existing === void 0) return void 0;
+      if (existing.agentRef === void 0 !== (input.agentRef === void 0) || existing.agentRef !== void 0 && !sameAgentRef3(existing.agentRef, input.agentRef)) return existing;
       if (existing.cancellation !== void 0) {
         if (input.status !== "cancelled" || existing.status === "cancelled") return existing;
       } else if (existing.status === "complete" || existing.status === "failed" || existing.status === "cancelled") {
         return existing;
       }
-      const updated = { ...existing, status: input.status, updatedAt: this.#now() };
+      const updated = {
+        ...existing,
+        status: input.status,
+        ...input.terminalCause === void 0 ? {} : { terminalCause: input.terminalCause },
+        updatedAt: this.#now()
+      };
       this.#state.attempts.set(key, updated);
       return updated;
     });
@@ -2839,10 +3268,34 @@ var InMemoryApprovalTimelineStore = class {
     return tail;
   }
 };
+var InMemoryAgentEgressStore = class {
+  #records = /* @__PURE__ */ new Map();
+  #clock;
+  constructor(clock) {
+    this.#clock = clock;
+  }
+  async record(tenant, input) {
+    const key = tenantKey(tenant, `${input.deviceId}\0${input.payload.eventId}`);
+    const existing = this.#records.get(key);
+    if (existing !== void 0) return { record: existing, created: false };
+    const record = {
+      tenantId: tenant,
+      deviceId: input.deviceId,
+      payload: input.payload,
+      receiptId: input.receiptId,
+      recordedAt: this.#clock.now().toISOString()
+    };
+    this.#records.set(key, record);
+    return { record, created: true };
+  }
+  async get(tenant, deviceId, eventId) {
+    return this.#records.get(tenantKey(tenant, `${deviceId}\0${eventId}`));
+  }
+};
 
 // src/stores/in-memory/index.ts
-function createInMemoryCloudStores(clock, crypto, objects, mailbox) {
-  const blobs = createInMemoryBlobs(clock, crypto, objects);
+function createInMemoryCloudStores(clock, crypto2, objects, mailbox) {
+  const blobs = createInMemoryBlobs(clock, crypto2, objects);
   const taskState = new InMemoryTaskAttemptState(clock);
   const tasks = new InMemoryTaskAttemptStore(clock, taskState);
   return {
@@ -2851,11 +3304,12 @@ function createInMemoryCloudStores(clock, crypto, objects, mailbox) {
       approvals: new InMemoryApprovalTimelineStore(clock),
       devices: new InMemoryDeviceDirectory(),
       pairingCodes: new InMemoryPairingCodeStore(clock),
-      nonces: new InMemoryNonceStore(clock, crypto),
+      nonces: new InMemoryNonceStore(clock, crypto2),
       dedup: new InMemoryInboundDedupStore(),
       tasks,
       cancellations: new InMemoryTaskCancellationStore(taskState, mailbox),
       receipts: new InMemoryRequestReceiptStore(clock),
+      egress: new InMemoryAgentEgressStore(clock),
       proofReceipts: new InMemoryProofRequestReceiptStore(clock),
       blobs: blobs.blobs,
       rateLimiter: new AllowAllRateLimiter()
@@ -2871,11 +3325,11 @@ function systemClock() {
 }
 function createInMemoryByokCloud(options = {}) {
   const clock = options.clock ?? systemClock();
-  const crypto = options.crypto ?? createWebCrypto();
+  const crypto2 = options.crypto ?? createWebCrypto();
   const core = createInMemoryCoreStores({ clock }).stores;
   const { stores, blobContentProxy } = createInMemoryCloudStores(
     clock,
-    crypto,
+    crypto2,
     core.objects,
     core.mailbox
   );
@@ -2888,7 +3342,7 @@ function createInMemoryByokCloud(options = {}) {
     // pairing is what keeps hosted-in-memory behavior identical to what it was
     // before the port narrowed.
     blobContentProxy,
-    crypto,
+    crypto: crypto2,
     tokenSigner,
     clock,
     capabilities: options.capabilities ?? fullCapabilityDeclaration(),
@@ -2917,7 +3371,7 @@ function createInMemoryByokCloud(options = {}) {
     ...options.skillPacks === void 0 ? {} : { skillPacks: options.skillPacks },
     ...options.skillPackPageLimit === void 0 ? {} : { skillPackPageLimit: options.skillPackPageLimit }
   });
-  return { cloud, core, stores, blobContentProxy, clock, crypto };
+  return { cloud, core, stores, blobContentProxy, clock, crypto: crypto2 };
 }
 function authenticateHostedDeviceAssertion(input, deps) {
   return authenticateDeviceAssertion(input, {
@@ -3085,6 +3539,7 @@ var TASK_ATTEMPT_STATUSES = [
   "failed",
   "cancelled"
 ];
+var BLOB_READ_ERROR_CODES = ["blob_upstream_unavailable", "blob_upstream_stream_interrupted"];
 var CLOUD_STORE_NAMES = [
   "activity",
   "approvals",
@@ -3095,6 +3550,7 @@ var CLOUD_STORE_NAMES = [
   "tasks",
   "cancellations",
   "receipts",
+  "egress",
   "proofReceipts",
   "blobs",
   "rateLimiter"
@@ -3104,13 +3560,14 @@ var CLOUD_STORE_NAMES = [
 var CLOUD_PORT_METHODS = {
   activity: ["append", "read"],
   approvals: ["append", "read"],
-  devices: ["register", "get", "revoke", "list", "readiness", "resolveByDeviceId"],
+  devices: ["register", "get", "revoke", "list", "readiness", "recordCapabilities", "resolveByDeviceId"],
   pairingCodes: ["issue", "redeem"],
   nonces: ["issue", "validate", "markUsed"],
   dedup: ["checkAndRecord"],
-  tasks: ["open", "get", "getMany", "claim", "recordStatus"],
+  tasks: ["open", "reserveAgentOffer", "get", "getMany", "claim", "recordStatus"],
   cancellations: ["request"],
   receipts: ["record", "get"],
+  egress: ["record", "get"],
   proofReceipts: ["record", "get"],
   // Three methods, not six: the byte-proxy trio moved to `BlobContentProxy`,
   // which is a composition input rather than a port and therefore has no row
@@ -3128,11 +3585,12 @@ var CLOUD_PORT_INTERFACES = {
   tasks: "TaskAttemptStore",
   cancellations: "TaskCancellationStore",
   receipts: "RequestReceiptStore",
+  egress: "AgentEgressStore",
   proofReceipts: "ProofRequestReceiptStore",
   blobs: "CloudBlobStore",
   rateLimiter: "InboundRateLimiter"
 };
 
-export { ACCESS_TOKEN_TTL_SECONDS, APPROVAL_SUMMARY_MAX_BYTES, ActivityAppendRequestSchema, AllowAllRateLimiter, ApprovalObservationSchema, ApprovalTimelineEventSchema, 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, 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, approvalTimelineCursor, authenticateBearer, authenticateDeviceProof, authenticateHostedDeviceAssertion, createAuthPlane, createByokCloud, createHmacTokenSigner, createInMemoryBlobs, createInMemoryByokCloud, createInMemoryCloudStores, createWebCrypto, declares, extractBearerToken, fullCapabilityDeclaration, handleInboundEnvelope, isCloudError, isTruthCommitError, parseApprovalObservations, parseTimelineEvents, projectTerminalResult, projectTimelineEvents, 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, 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, approvalTimelineCursor, authenticateBearer, authenticateDeviceProof, authenticateHostedDeviceAssertion, createAuthPlane, createByokCloud, createHmacTokenSigner, createInMemoryBlobs, createInMemoryByokCloud, createInMemoryCloudStores, createWebCrypto, declares, extractBearerToken, fullCapabilityDeclaration, handleInboundEnvelope, isCloudError, isTruthCommitError, parseApprovalObservations, parseTimelineEvents, projectTerminalResult, projectTimelineEvents, routeKey, tenantStoresFor, terminalReceiptKey, truthManifestMetadata, truthRecordMetadata, validateActivityAppend, validateApprovalTimelineAppend, verifyNonceSignature };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map