@byok-sdk/cloud 0.5.0 → 0.6.1

package/dist/index.js

@@ -1,6 +1,6 @@
-import { BOARD_STATUSES, PRESENCE_LEVELS, CapabilityDeclarationSchema, NONCE_SIGNING_DOMAIN, hasCapability, isTenantId, tenantId, principalTenant, parseDeviceProofEnvelope, deviceProofSigningInput, parseCapabilityDeclaration, ByokCoreError, tenantKey, createInMemoryCoreStores, authenticateDeviceAssertion, assertCapability, contentHash, isCoreConflictError, isCoreError, DEVICE_PROOF_HEADER, TRUTH_RECORD_KINDS, STORAGE_ERROR_CODES, STORAGE_ERROR_HTTP_STATUS } from '@byok-sdk/core';
+import { BOARD_STATUSES, CapabilityDeclarationSchema, NONCE_SIGNING_DOMAIN, hasCapability, isTenantId, tenantId, principalTenant, parseDeviceProofEnvelope, deviceProofSigningInput, contentHash, parseCapabilityDeclaration, ByokCoreError, tenantKey, PRESENCE_LEVELS, createInMemoryCoreStores, authenticateDeviceAssertion, 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, ConfiguredToolsetsSchema, 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, 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, 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(
@@ -317,7 +317,19 @@ var CLOUD_ERROR_CODES = {
    */
   terminal_receipt_unreadable: "terminal_receipt_unreadable",
   /** A progress/activity batch exceeded the configured event or byte ceiling. */
-  activity_batch_too_large: "activity_batch_too_large"
+  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",
+  /** 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;
@@ -524,14 +536,24 @@ function tenantStoresFor(principal, root) {
     devices: {
       get: (deviceId) => cloud.devices.get(tenant, deviceId),
       list: () => cloud.devices.list(tenant),
-      revoke: (deviceId) => cloud.devices.revoke(tenant, deviceId)
+      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),
       recordStatus: (input) => cloud.tasks.recordStatus(tenant, input)
     },
+    cancellations: {
+      request: (input) => cloud.cancellations.request(tenant, input)
+    },
     dedup: {
       checkAndRecord: (deviceId, envelopeId) => cloud.dedup.checkAndRecord(tenant, deviceId, envelopeId)
     },
@@ -539,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),
@@ -678,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;
@@ -752,7 +783,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));
 }
@@ -774,13 +813,32 @@ function eventsHandler(deps) {
     }
     const attempts = Math.max(1, Math.ceil(deps.longPollHoldMs / deps.longPollIntervalMs));
     for (let attempt = 0; attempt < attempts; attempt += 1) {
-      const page = await stores.mailbox.readAfter({
-        deviceId: device.deviceId,
-        afterSeq: cursor,
-        limit: deps.pageLimit
-      });
-      if (page.messages.length > 0) {
-        const events = page.messages.map((message) => decodeEnvelope(message.body));
+      let scanCursor = cursor;
+      while (true) {
+        const page = await stores.mailbox.readAfter({
+          deviceId: device.deviceId,
+          afterSeq: scanCursor,
+          limit: deps.pageLimit
+        });
+        if (page.messages.length === 0) break;
+        const decoded = page.messages.map((message) => decodeEnvelope(message.body));
+        const offeredTaskIds = decoded.flatMap(
+          (event) => (event.type === "task.offer" || event.type === "task.offer_with_toolsets" || event.type === "task.offer_for_agent" || event.type === "task.offer_for_agent_with_egress") && event.task_id !== void 0 ? [event.task_id] : []
+        );
+        const attemptsByTaskId = Object.fromEntries(
+          (await stores.tasks.getMany(offeredTaskIds)).map((attempt2) => [attempt2.taskId, attempt2])
+        );
+        const events = decoded.filter((event) => {
+          if (event.type !== "task.offer" && event.type !== "task.offer_with_toolsets" && event.type !== "task.offer_for_agent" && event.type !== "task.offer_for_agent_with_egress") {
+            return true;
+          }
+          return event.task_id === void 0 || attemptsByTaskId[event.task_id]?.cancellation === void 0;
+        });
+        if (events.length === 0 && page.hasMore) {
+          scanCursor = page.nextSeq;
+          continue;
+        }
+        if (events.length === 0) break;
         const response2 = {
           events,
           cursor: page.nextSeq,
@@ -886,13 +944,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(
@@ -922,19 +1070,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) {
@@ -999,12 +1155,30 @@ function approvalTimelineAppendInput(taskId, envelope) {
   }
 }
 async function recordTerminal(stores, taskId, envelope, status) {
+  const attempt = await stores.tasks.get(taskId);
   const { created } = await stores.receipts.record({
     key: terminalReceiptKey(taskId),
     body: encodeEnvelope(envelope)
   });
+  if (attempt?.cancellation !== void 0) {
+    if (status === "cancelled") {
+      await stores.tasks.recordStatus({
+        taskId,
+        status: "cancelled",
+        ...attempt.agentRef === void 0 ? {} : { agentRef: attempt.agentRef }
+      });
+    }
+    return;
+  }
   if (!created) return;
-  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);
 }
 
@@ -1026,6 +1200,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;
     }
@@ -1271,11 +1455,7 @@ function boardFailure(c, caught) {
   if (isCoreError(caught, "board_not_held")) return c.json({ error: caught.code }, 409);
   throw caught;
 }
-var PresenceBodySchema = z.object({
-  level: z.enum(PRESENCE_LEVELS),
-  detail: z.string().optional(),
-  configuredToolsets: ConfiguredToolsetsSchema.optional()
-});
+var PresenceBodySchema = PresencePublishRequestSchema;
 function presencePublishHandler(deps) {
   return async (c) => {
     const authenticated = await authenticateDevice(c, deps);
@@ -1292,6 +1472,15 @@ function presencePublishHandler(deps) {
           level: parsed.data.level,
           ...parsed.data.detail === void 0 ? {} : { detail: parsed.data.detail },
           ...parsed.data.configuredToolsets === void 0 ? {} : { configuredToolsets: parsed.data.configuredToolsets },
+          ...parsed.data.clientVersion === void 0 ? {} : { clientVersion: parsed.data.clientVersion },
+          ...parsed.data.protocolVersions === void 0 ? {} : { protocolVersions: parsed.data.protocolVersions },
+          ...parsed.data.runtimes === void 0 ? {} : {
+            runtimes: parsed.data.runtimes.map(({ id, version, authPresent }) => ({
+              id,
+              ...version === void 0 ? {} : { version },
+              ...authPresent === void 0 ? {} : { authPresent }
+            }))
+          },
           ttlMs: deps.ttlMs,
           minimumIntervalMs: deps.minimumIntervalMs
         }),
@@ -1788,25 +1977,33 @@ 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 } : {},
         ...envelope.payload.document !== void 0 ? { document: envelope.payload.document } : {},
+        ...envelope.payload.usage !== void 0 ? { usage: envelope.payload.usage } : {},
         recordedAt: receipt.recordedAt
       };
     case "task.fail":
       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
       };
     case "task.cancelled":
       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
       };
     default:
@@ -1822,6 +2019,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(
@@ -1871,7 +2072,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)) {
@@ -1989,16 +2195,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,
@@ -2011,11 +2299,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,
@@ -2030,6 +2384,7 @@ function createByokCloud(options) {
         tenant,
         deviceId,
         input.taskId,
+        void 0,
         (taskId, seq, messageId) => createEnvelope("task.offer", input.payload, { id: messageId, taskId, seq })
       );
     },
@@ -2038,17 +2393,128 @@ 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();
+      const mutation = await stores.cancellations.request({
+        taskId,
+        proposedMessageId,
+        ...reason === void 0 ? {} : { reason },
+        materialize: async (seq, messageId) => {
+          const envelope = createEnvelope("task.cancel", reason === void 0 ? {} : { reason }, {
+            id: messageId,
+            taskId,
+            seq
+          });
+          const body = encodeEnvelope(envelope);
+          const bytes = new TextEncoder().encode(body);
+          return {
+            body,
+            bodyHash: contentHash(await options.crypto.sha256(bytes)),
+            byteSize: BigInt(bytes.length)
+          };
+        }
+      });
+      if (mutation === void 0) {
+        throw new ByokCloudError("task_not_found", `Task ${taskId} was not found for this tenant.`);
+      }
+      if (mutation.message !== void 0) {
+        const envelope = decodeEnvelope(mutation.message.body);
+        if (envelope.seq !== mutation.message.seq || envelope.type !== "task.cancel") {
+          throw new ByokCloudError(
+            "mailbox_seq_mismatch",
+            `Mailbox stored cancellation seq ${String(envelope.seq)} at row ${mutation.message.seq}.`
+          );
+        }
+      }
+      return mutation.attempt;
+    },
     readTaskAttempt(tenant, taskId) {
       return tenantStoresFor(controlPlane(tenant), root).tasks.get(taskId);
     },
     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 receipt = await tenantStoresFor(controlPlane(tenant), root).receipts.get(
+      const stores = tenantStoresFor(controlPlane(tenant), root);
+      const attempt = await stores.tasks.get(taskId);
+      if (attempt?.cancellation !== void 0) {
+        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
+        };
+      }
+      const receipt = await stores.receipts.get(
         terminalReceiptKey(taskId)
       );
       return receipt === void 0 ? void 0 : projectTerminalResult(taskId, receipt);
@@ -2079,6 +2545,9 @@ function createByokCloud(options) {
     listPresence(tenant) {
       return tenantStoresFor(controlPlane(tenant), root).presence.list();
     },
+    readTenantReadiness(tenant) {
+      return tenantStoresFor(controlPlane(tenant), root).devices.readiness();
+    },
     readActivity(tenant, taskId) {
       return tenantStoresFor(controlPlane(tenant), root).activity.read(taskId);
     },
@@ -2146,9 +2615,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;
   }
@@ -2253,14 +2722,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)
@@ -2303,10 +2778,67 @@ 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);
   }
+  async readiness(tenant, presence) {
+    const devices = await this.list(tenant);
+    const livePresence = await presence.list(tenant);
+    const presenceByDevice = new Map(livePresence.map((hint) => [hint.deviceId, hint]));
+    const activeDeviceIds = new Set(
+      devices.filter((device) => !device.revoked).map((device) => device.deviceId)
+    );
+    const observedPresenceByLevel = Object.fromEntries(
+      PRESENCE_LEVELS.map((level) => [level, 0])
+    );
+    for (const hint of livePresence) {
+      if (!activeDeviceIds.has(hint.deviceId)) continue;
+      observedPresenceByLevel[hint.level] += 1;
+    }
+    return {
+      tenantId: tenant,
+      activePairedDeviceCount: devices.filter((device) => !device.revoked).length,
+      revokedDeviceCount: devices.filter((device) => device.revoked).length,
+      observedPresenceCount: Object.values(observedPresenceByLevel).reduce(
+        (total, count) => total + count,
+        0
+      ),
+      observedPresenceByLevel,
+      devices: [...devices].sort((left, right) => left.deviceId.localeCompare(right.deviceId)).map((device) => {
+        const hint = device.revoked ? void 0 : presenceByDevice.get(device.deviceId);
+        return {
+          deviceId: device.deviceId,
+          productId: device.productId,
+          deviceName: device.deviceName,
+          revoked: device.revoked,
+          ...hint === void 0 ? {} : {
+            presence: {
+              level: hint.level,
+              ...hint.detail === void 0 ? {} : { detail: hint.detail },
+              ...hint.configuredToolsets === void 0 ? {} : { configuredToolsets: hint.configuredToolsets },
+              ...hint.clientVersion === void 0 ? {} : { clientVersion: hint.clientVersion },
+              ...hint.protocolVersions === void 0 ? {} : { protocolVersions: hint.protocolVersions },
+              ...hint.runtimes === void 0 ? {} : { runtimes: hint.runtimes },
+              observedAt: hint.observedAt,
+              expiresAt: hint.expiresAt
+            }
+          }
+        };
+      })
+    };
+  }
   async resolveByDeviceId(deviceId) {
     const key = this.#byDeviceId.get(deviceId);
     return key === void 0 ? void 0 : this.#byTenant.get(key);
@@ -2342,9 +2874,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. */
@@ -2448,54 +2980,171 @@ 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 {
-  #attempts = /* @__PURE__ */ new Map();
-  #clock;
-  constructor(clock) {
-    this.#clock = clock;
+  #state;
+  constructor(clock, state = new InMemoryTaskAttemptState(clock)) {
+    this.#state = state;
   }
   async open(tenant, input) {
     const key = tenantKey(tenant, input.taskId);
-    const existing = this.#attempts.get(key);
-    if (existing !== void 0) return existing;
-    const attempt = {
-      tenantId: tenant,
-      taskId: input.taskId,
-      deviceId: input.deviceId,
-      status: "offered",
-      updatedAt: this.#now()
-    };
-    this.#attempts.set(key, attempt);
-    return attempt;
+    return this.#state.mutate(key, () => {
+      const existing = this.#state.attempts.get(key);
+      if (existing !== void 0) return existing;
+      const attempt = {
+        tenantId: tenant,
+        taskId: input.taskId,
+        deviceId: input.deviceId,
+        ...input.agentRef === void 0 ? {} : { agentRef: { ...input.agentRef } },
+        status: "offered",
+        updatedAt: this.#now()
+      };
+      this.#state.attempts.set(key, attempt);
+      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.#attempts.get(tenantKey(tenant, taskId));
+    return this.#state.attempts.get(tenantKey(tenant, taskId));
+  }
+  async getMany(tenant, taskIds) {
+    return taskIds.flatMap((taskId) => {
+      const attempt = this.#state.attempts.get(tenantKey(tenant, taskId));
+      return attempt === void 0 ? [] : [attempt];
+    });
   }
   async claim(tenant, input) {
     const key = tenantKey(tenant, input.taskId);
-    const existing = this.#attempts.get(key);
-    if (existing === void 0) return void 0;
-    if (existing.ownerDeviceId !== void 0) return existing;
-    const claimed = {
-      ...existing,
-      ownerDeviceId: input.deviceId,
-      status: "claimed",
-      updatedAt: this.#now()
-    };
-    this.#attempts.set(key, claimed);
-    return claimed;
+    return this.#state.mutate(key, () => {
+      const existing = this.#state.attempts.get(key);
+      if (existing === void 0) return void 0;
+      if (existing.ownerDeviceId !== void 0 || existing.cancellation !== void 0 || existing.status !== "offered") return existing;
+      const claimed = {
+        ...existing,
+        ownerDeviceId: input.deviceId,
+        status: "claimed",
+        updatedAt: this.#now()
+      };
+      this.#state.attempts.set(key, claimed);
+      return claimed;
+    });
   }
   async recordStatus(tenant, input) {
     const key = tenantKey(tenant, input.taskId);
-    const existing = this.#attempts.get(key);
-    if (existing === void 0) return void 0;
-    const updated = { ...existing, status: input.status, updatedAt: this.#now() };
-    this.#attempts.set(key, updated);
-    return updated;
+    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,
+        ...input.terminalCause === void 0 ? {} : { terminalCause: input.terminalCause },
+        updatedAt: this.#now()
+      };
+      this.#state.attempts.set(key, updated);
+      return updated;
+    });
   }
   #now() {
+    return this.#state.now();
+  }
+};
+var InMemoryTaskAttemptState = class {
+  attempts = /* @__PURE__ */ new Map();
+  #clock;
+  #mutationTails = /* @__PURE__ */ new Map();
+  constructor(clock) {
+    this.#clock = clock;
+  }
+  now() {
     return this.#clock.now().toISOString();
   }
+  /** Serialize every state-changing operation for one tenant/task key. */
+  async mutate(key, operation) {
+    const previous = this.#mutationTails.get(key) ?? Promise.resolve();
+    const result = previous.then(operation);
+    const tail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    this.#mutationTails.set(key, tail);
+    try {
+      return await result;
+    } finally {
+      if (this.#mutationTails.get(key) === tail) this.#mutationTails.delete(key);
+    }
+  }
+};
+var InMemoryTaskCancellationStore = class {
+  #state;
+  #mailbox;
+  #messageIds = /* @__PURE__ */ new Map();
+  #inFlight = /* @__PURE__ */ new Map();
+  constructor(state, mailbox) {
+    this.#state = state;
+    this.#mailbox = mailbox;
+  }
+  request(tenant, input) {
+    const key = tenantKey(tenant, input.taskId);
+    const running = this.#inFlight.get(key);
+    if (running !== void 0) return running;
+    const operation = this.#request(tenant, key, input).finally(() => {
+      this.#inFlight.delete(key);
+    });
+    this.#inFlight.set(key, operation);
+    return operation;
+  }
+  async #request(tenant, key, input) {
+    return this.#state.mutate(key, async () => {
+      const existing = this.#state.attempts.get(key);
+      if (existing === void 0) return void 0;
+      if (existing.cancellation === void 0 && (existing.status === "complete" || existing.status === "failed" || existing.status === "cancelled")) {
+        return { attempt: existing };
+      }
+      const messageId = this.#messageIds.get(key) ?? input.proposedMessageId;
+      const message = await this.#mailbox.append(tenant, {
+        deviceId: existing.deviceId,
+        messageId,
+        materialize: (seq) => input.materialize(seq, messageId)
+      });
+      const requestedAt = this.#state.now();
+      const attempt = existing.cancellation === void 0 ? {
+        ...existing,
+        status: existing.ownerDeviceId === void 0 ? "cancelled" : "cancel_requested",
+        cancellation: {
+          requestedAt,
+          ...input.reason === void 0 ? {} : { reason: input.reason }
+        },
+        updatedAt: requestedAt
+      } : existing;
+      this.#state.attempts.set(key, attempt);
+      this.#messageIds.set(key, messageId);
+      return { attempt, message };
+    });
+  }
 };
 
 // src/stores/in-memory/activity.ts
@@ -2614,20 +3263,48 @@ 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) {
-  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 {
     stores: {
       activity: new InMemoryActivityStore(clock),
       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: new InMemoryTaskAttemptStore(clock),
+      tasks,
+      cancellations: new InMemoryTaskCancellationStore(taskState, mailbox),
       receipts: new InMemoryRequestReceiptStore(clock),
+      egress: new InMemoryAgentEgressStore(clock),
       proofReceipts: new InMemoryProofRequestReceiptStore(clock),
       blobs: blobs.blobs,
       rateLimiter: new AllowAllRateLimiter()
@@ -2643,9 +3320,14 @@ 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, core.objects);
+  const { stores, blobContentProxy } = createInMemoryCloudStores(
+    clock,
+    crypto2,
+    core.objects,
+    core.mailbox
+  );
   const tokenSigner = options.tokenSigner ?? createHmacTokenSigner(globalThis.crypto.getRandomValues(new Uint8Array(TOKEN_SECRET_BYTES)), clock);
   const cloud = createByokCloud({
     core,
@@ -2655,7 +3337,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(),
@@ -2684,7 +3366,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, {
@@ -2847,10 +3529,12 @@ 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",
@@ -2859,7 +3543,9 @@ var CLOUD_STORE_NAMES = [
   "nonces",
   "dedup",
   "tasks",
+  "cancellations",
   "receipts",
+  "egress",
   "proofReceipts",
   "blobs",
   "rateLimiter"
@@ -2869,12 +3555,14 @@ var CLOUD_STORE_NAMES = [
 var CLOUD_PORT_METHODS = {
   activity: ["append", "read"],
   approvals: ["append", "read"],
-  devices: ["register", "get", "revoke", "list", "resolveByDeviceId"],
+  devices: ["register", "get", "revoke", "list", "readiness", "recordCapabilities", "resolveByDeviceId"],
   pairingCodes: ["issue", "redeem"],
   nonces: ["issue", "validate", "markUsed"],
   dedup: ["checkAndRecord"],
-  tasks: ["open", "get", "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
@@ -2890,12 +3578,14 @@ var CLOUD_PORT_INTERFACES = {
   nonces: "NonceStore",
   dedup: "InboundDedupStore",
   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, 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