@byok-sdk/cloud 0.12.0 → 0.14.0

package/dist/index.js

@@ -1,11 +1,73 @@
 import { BOARD_STATUSES, CapabilityDeclarationSchema, NONCE_SIGNING_DOMAIN, hasCapability, isTenantId, tenantId, principalTenant, parseDeviceProofEnvelope, deviceProofSigningInput, contentHash, parseCapabilityDeclaration, ByokCoreError, tenantKey, PRESENCE_LEVELS, createInMemoryCoreStores, authenticateDeviceAssertion, assertCapability, isCoreConflictError, isCoreError, DEVICE_PROOF_HEADER, TRUTH_RECORD_KINDS, STORAGE_ERROR_CODES, STORAGE_ERROR_HTTP_STATUS } from '@byok-sdk/core';
 export { DEVICE_PROOF_HEADER, NONCE_SIGNING_DOMAIN, isTenantId, tenantId } from '@byok-sdk/core';
-import { AgentEventOrUnknownSchema, PROTOCOL_VERSION, DAEMON_TO_SERVER_TYPES, AGENT_EGRESS_RELIABLE_ACK_CAPABILITY, encodeEnvelope, AgentHomeProjectionCompletionRequestSchema, decodeEnvelope, BYOK_PAIR_PATH, BYOK_CHALLENGE_PATH, BYOK_TOKEN_PATH, BYOK_CAPABILITIES_PATH, BYOK_AGENT_MEMORY_PROJECTIONS_PATH, BYOK_EVENTS_PATH, BYOK_MESSAGES_PATH, BYOK_AGENT_HOME_PROJECTION_COMPLETION_ROUTE, BYOK_BOARD_PATH, BYOK_BOARD_CLAIM_ROUTE, BYOK_BOARD_UNCLAIM_ROUTE, BYOK_BOARD_STATUS_ROUTE, BYOK_BOARD_STREAM_PATH, BYOK_PRESENCE_PATH, BYOK_ACTIVITY_PATH, BYOK_RECORDS_PATH, BYOK_RECORD_ROUTE, BYOK_SKILL_PACKS_PATH, BYOK_SKILL_PACK_FILE_ROUTE, BYOK_BLOBS_PATH, BYOK_BLOB_FINALIZE_ROUTE, BYOK_BLOB_URL_ROUTE, BYOK_BLOB_CONTENT_ROUTE, createEnvelope, AgentHomeProjectionPayloadSchema, AgentContentReadPayloadSchema, AGENT_EGRESS_POLICY_CAPABILITY, AGENT_EGRESS_FRESH_SESSION_CAPABILITY, AGENT_MESSAGE_EGRESS_CAPABILITY, TERMINAL_PROJECTION_SELECTION_CAPABILITY, TaskOfferForAgentWithEgressFreshPayloadSchema, AgentMessageServerContextSchema, TaskOfferForAgentWithEgressPayloadSchema, TaskOfferForAgentPayloadSchema, AgentMemoryProjectionMutationSchema, AgentMemoryProjectionReceiptSchema, AGENT_MEMORY_PROJECTION_MAX_ORDERING_VALUE, AgentMemoryProjectionEraseResultSchema, STRICT_AGENT_ONLY_CAPABILITY, AGENT_CONTENT_ARTIFACT_READ_CAPABILITY, AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY, AGENT_CONTENT_WORKSPACE_READ_CAPABILITY, AGENT_HOME_PROJECTION_CAPABILITY, PairRequestSchema, PairResponseSchema, ChallengeRequestSchema, TokenRequestSchema, AgentMemoryProjectionCommitRequestSchema, agentMemoryProjectionBase64UrlByteLength, MessagesSendRequestSchema, PresencePublishRequestSchema, CreateBlobRequestSchema, byokBlobContentPath, AgentEgressAckPayloadSchema, AgentContentReceiptPayloadSchema } from '@byok-sdk/protocol';
+import { AgentEventOrUnknownSchema, PROTOCOL_VERSION, DAEMON_TO_SERVER_TYPES, AGENT_EGRESS_RELIABLE_ACK_CAPABILITY, encodeEnvelope, decodeEnvelope, AgentHomeProjectionCompletionRequestSchema, BYOK_PAIR_PATH, BYOK_CHALLENGE_PATH, BYOK_TOKEN_PATH, BYOK_CAPABILITIES_PATH, BYOK_AGENT_MEMORY_PROJECTIONS_PATH, BYOK_EVENTS_PATH, BYOK_MESSAGES_PATH, BYOK_AGENT_HOME_PROJECTION_COMPLETION_ROUTE, BYOK_BOARD_PATH, BYOK_BOARD_CLAIM_ROUTE, BYOK_BOARD_UNCLAIM_ROUTE, BYOK_BOARD_STATUS_ROUTE, BYOK_BOARD_STREAM_PATH, BYOK_PRESENCE_PATH, BYOK_ACTIVITY_PATH, BYOK_RECORDS_PATH, BYOK_RECORD_ROUTE, BYOK_SKILL_PACKS_PATH, BYOK_SKILL_PACK_FILE_ROUTE, BYOK_BLOBS_PATH, BYOK_BLOB_FINALIZE_ROUTE, BYOK_BLOB_URL_ROUTE, BYOK_BLOB_CONTENT_ROUTE, createEnvelope, AgentHomeProjectionPayloadSchema, AgentContentReadPayloadSchema, AGENT_EGRESS_POLICY_CAPABILITY, AGENT_EGRESS_FRESH_SESSION_CAPABILITY, AGENT_MESSAGE_EGRESS_CAPABILITY, TERMINAL_PROJECTION_SELECTION_CAPABILITY, TaskOfferForAgentWithEgressFreshPayloadSchema, AgentMessageServerContextSchema, TaskOfferForAgentWithEgressPayloadSchema, TaskOfferForAgentPayloadSchema, AgentMemoryProjectionMutationSchema, AgentMemoryProjectionReceiptSchema, AGENT_MEMORY_PROJECTION_MAX_ORDERING_VALUE, AgentMemoryProjectionEraseResultSchema, STRICT_AGENT_ONLY_CAPABILITY, AGENT_CONTENT_ARTIFACT_READ_CAPABILITY, AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY, AGENT_CONTENT_WORKSPACE_READ_CAPABILITY, AGENT_HOME_PROJECTION_CAPABILITY, AgentRefSchema, PairRequestSchema, PairResponseSchema, ChallengeRequestSchema, TokenRequestSchema, AgentMemoryProjectionCommitRequestSchema, agentMemoryProjectionBase64UrlByteLength, MessagesSendRequestSchema, PresencePublishRequestSchema, CreateBlobRequestSchema, byokBlobContentPath, AgentEgressAckPayloadSchema, AgentContentReceiptPayloadSchema } from '@byok-sdk/protocol';
 import { z } from 'zod';
 import { Hono } from 'hono';
 
 // src/index.ts
 
+// src/approval-control.ts
+var StaleApprovalError = class extends Error {
+  constructor(taskId, requestedApprovalId, currentApprovalId) {
+    super(
+      `cannot resolve approval ${requestedApprovalId} for task ${taskId}: the currently pending approval is ${currentApprovalId ?? "(none recorded)"}`
+    );
+    this.taskId = taskId;
+    this.requestedApprovalId = requestedApprovalId;
+    this.currentApprovalId = currentApprovalId;
+    this.name = "StaleApprovalError";
+  }
+  taskId;
+  requestedApprovalId;
+  currentApprovalId;
+};
+function pendingApproval(tail) {
+  if (tail === void 0) return void 0;
+  let pending;
+  for (const entry of tail.entries) {
+    const event = entry.event;
+    if (event.type === "approval_requested") {
+      pending = {
+        sourceEnvelopeId: entry.sourceEnvelopeId,
+        revision: entry.revision,
+        ...event.approvalId === void 0 ? {} : { approvalId: event.approvalId }
+      };
+      continue;
+    }
+    if (pending === void 0) continue;
+    if (pending.approvalId === void 0 || pending.approvalId === event.approvalId) {
+      pending = void 0;
+    }
+  }
+  return pending;
+}
+
+// src/steer-control.ts
+function steerRejectionMessage(taskId, code, status, runtime) {
+  switch (code) {
+    case "task_terminal":
+      return `cannot steer task ${taskId}: task is already terminal (status ${status})`;
+    case "task_not_running":
+      return `cannot steer task ${taskId}: not running (status ${status})`;
+    case "steer_unsupported_runtime":
+      return `cannot steer task ${taskId}: claimed runtime ${runtime ?? "(unknown)"} does not support steering`;
+  }
+}
+var SteerRejectedError = class extends Error {
+  constructor(taskId, code, status, runtime) {
+    super(steerRejectionMessage(taskId, code, status, runtime));
+    this.taskId = taskId;
+    this.code = code;
+    this.status = status;
+    this.runtime = runtime;
+    this.name = "SteerRejectedError";
+  }
+  taskId;
+  code;
+  status;
+  runtime;
+};
+
 // src/crypto/web-crypto.ts
 var PAIRING_CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
 var HEX_DIGITS = "0123456789abcdef";
@@ -321,6 +383,15 @@ var CLOUD_ERROR_CODES = {
   activity_batch_too_large: "activity_batch_too_large",
   /** Host control-plane task lookup is tenant-closed and found no task. */
   task_not_found: "task_not_found",
+  /**
+   * A host `approveTask`/`rejectTask` names a task with no approval to
+   * resolve: the durable timeline holds no unresolved `approval_requested`
+   * (including a tail that has expired or was never written), the attempt has
+   * already reached a terminal status, or no device ever claimed it so there
+   * is nothing to notify. Fail-closed by construction — cloud never invents a
+   * pending approval to make the call succeed.
+   */
+  task_not_awaiting_approval: "task_not_awaiting_approval",
   /** Durable target-device capability is absent, revoked, or unavailable. */
   agent_capability_missing: "agent_capability_missing",
   /** Inbound Agent identity did not exactly match the offered identity. */
@@ -387,6 +458,12 @@ var TimelineEventSchema = z.object({
   sourceEnvelopeId: SourceEnvelopeIdSchema,
   batchSeq: z.number().int().nonnegative(),
   eventIndex: z.number().int().nonnegative(),
+  /**
+   * The producer-declared loss attached to this source batch. It travels with
+   * every retained event so a replay includes it in the canonical batch
+   * binding rather than treating the aggregate as an incidental counter.
+   */
+  sourceDropped: z.number().int().nonnegative().optional(),
   receivedAt: z.iso.datetime(),
   event: AgentEventOrUnknownSchema
 });
@@ -420,11 +497,24 @@ function projectTimelineEvents(input, receivedAt) {
       sourceEnvelopeId: input.sourceEnvelopeId,
       batchSeq: input.batchSeq,
       eventIndex,
+      sourceDropped: input.dropped,
       receivedAt,
       event
     })
   );
 }
+function activitySourceBatchState(entries, input) {
+  const existing = entries.filter((entry) => entry.sourceEnvelopeId === input.sourceEnvelopeId).sort((left, right) => left.eventIndex - right.eventIndex);
+  if (existing.length === 0) return "absent";
+  if (existing.length !== input.events.length) return "conflict";
+  for (const [eventIndex, event] of input.events.entries()) {
+    const stored = existing[eventIndex];
+    if (stored === void 0 || stored.taskId !== input.taskId || stored.batchSeq !== input.batchSeq || stored.eventIndex !== eventIndex || stored.sourceDropped !== input.dropped || JSON.stringify(stored.event) !== JSON.stringify(event)) {
+      return "conflict";
+    }
+  }
+  return "same";
+}
 function parseTimelineEvents(value) {
   return z.array(TimelineEventSchema).parse(value);
 }
@@ -469,6 +559,14 @@ function assertBoardLabels(channel, title, limits) {
     );
   }
 }
+function assertTaskAttemptListLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new ByokCloudError(
+      "coordination_input_invalid",
+      `Task attempt list limit must be a positive integer; received ${String(limit)}.`
+    );
+  }
+}
 function validateActivityEvents(events, dropped, bounds) {
   if (!Number.isSafeInteger(dropped) || dropped < 0) {
     throw new ByokCloudError(
@@ -520,6 +618,9 @@ async function authenticateBearer(header, deps) {
   const device = await deps.devices.get(tenantId(claims.tenantId), claims.deviceId);
   if (device === void 0 || device.revoked) return void 0;
   if (device.productId !== claims.productId) return void 0;
+  if (deps.instanceProductId !== void 0 && claims.productId !== deps.instanceProductId) {
+    return void 0;
+  }
   return {
     kind: "device",
     tenantId: device.tenantId,
@@ -579,6 +680,7 @@ function tenantStoresFor(principal, root) {
       finalizeAgentMessage: (input) => cloud.tasks.finalizeAgentMessage(tenant, input),
       get: (taskId) => cloud.tasks.get(tenant, taskId),
       getMany: (taskIds) => cloud.tasks.getMany(tenant, taskIds),
+      list: (query) => cloud.tasks.list(tenant, query),
       claim: (input) => cloud.tasks.claim(tenant, input),
       recordStatus: (input) => cloud.tasks.recordStatus(tenant, input)
     },
@@ -586,7 +688,8 @@ function tenantStoresFor(principal, root) {
       request: (input) => cloud.cancellations.request(tenant, input)
     },
     dedup: {
-      checkAndRecord: (deviceId, envelopeId) => cloud.dedup.checkAndRecord(tenant, deviceId, envelopeId)
+      checkAndRecord: (deviceId, envelopeId) => cloud.dedup.checkAndRecord(tenant, deviceId, envelopeId),
+      checkAndRecordAgent: (deviceId, agentRef, envelopeId) => cloud.dedup.checkAndRecordAgent(tenant, deviceId, agentRef, envelopeId)
     },
     receipts: {
       record: (input) => cloud.receipts.record(tenant, input),
@@ -594,7 +697,7 @@ function tenantStoresFor(principal, root) {
     },
     egress: {
       record: (input) => cloud.egress.record(tenant, input),
-      get: (deviceId, eventId) => cloud.egress.get(tenant, deviceId, eventId)
+      get: (deviceId, agentRef, eventId) => cloud.egress.get(tenant, deviceId, agentRef, eventId)
     },
     blobs: {
       createUpload: (reservation) => cloud.blobs.createUpload(tenant, reservation),
@@ -927,11 +1030,20 @@ function tokenHandler(deps) {
 }
 var CLOUD_PROTOCOL_CAPABILITIES = [
   "result-document",
+  // The kernel's inbound handles `task.approval_resolved` on both the plain
+  // and the approval-timeline paths (`packages/cloud/src/inbound.ts:576,610`).
+  // Without this flag `TaskRunner.sendApprovalResolved` returns early and a
+  // locally-resolved approval is never reported on the wire at all.
+  "approval_resolved",
   "agent-home-contract",
   "agent-home-projection",
   "agent-egress-policy",
   "agent-egress-reliable-ack",
   "agent-egress-fresh-session",
+  // `handleAgentMessagePublish` accepts `agent.message_egress` gated on exactly
+  // this capability (`packages/cloud/src/inbound.ts:124`) — the same inbound
+  // family as the three egress flags above, omitted by the same drift.
+  "agent-message-egress",
   "agent-content-workspace-read",
   "agent-content-transcript-read",
   "agent-content-artifact-read"
@@ -973,6 +1085,9 @@ function eventsHandler(deps) {
           afterSeq: scanCursor,
           limit: deps.pageLimit
         });
+        if (cursor < page.recoverableFrom - 1) {
+          return c.json({ error: "cursor_too_old", recoverableFrom: page.recoverableFrom }, 409);
+        }
         if (page.messages.length === 0) break;
         const decoded = page.messages.map((message) => decodeEnvelope(message.body));
         const offeredTaskIds = decoded.flatMap(
@@ -1018,19 +1133,45 @@ var DEFAULT_APPROVAL_TIMELINE_TTL_MS = 10 * 60 * 1e3;
 var APPROVAL_SUMMARY_MAX_BYTES = 16 * 1024;
 var NonBlankIdSchema = z.string().max(200).regex(/\S/, "value must not be blank");
 var TaskIdSchema = z.string().min(1).max(200);
-var ApprovalTimelineEventSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("approval_requested"),
-    summary: z.string(),
-    approvalId: NonBlankIdSchema.optional()
-  }),
-  z.object({
-    type: z.literal("approval_resolved"),
-    approvalId: NonBlankIdSchema,
-    decision: z.enum(["approve", "reject"]),
-    resolvedBy: z.enum(["local"]),
-    at: z.iso.datetime({ offset: true })
-  })
+var ApprovalRequestedEventSchema = z.object({
+  type: z.literal("approval_requested"),
+  summary: z.string(),
+  approvalId: NonBlankIdSchema.optional()
+}).strict();
+var LocalApprovalResolutionEventSchema = z.object({
+  type: z.literal("approval_resolved"),
+  // Absent only when a daemon resolved the single outstanding request without
+  // native approval identity. No id is synthesized.
+  approvalId: NonBlankIdSchema.optional(),
+  decision: z.enum(["approve", "reject"]),
+  // A daemon's `task.approval_resolved` is pure wire observation; it cannot
+  // declare a host command payload.
+  resolvedBy: z.literal("local"),
+  at: z.iso.datetime({ offset: true })
+}).strict();
+var HostApprovalResolutionEventSchema = z.object({
+  type: z.literal("approval_resolved"),
+  approvalId: NonBlankIdSchema.optional(),
+  decision: z.literal("approve"),
+  resolvedBy: z.literal("host"),
+  at: z.iso.datetime({ offset: true })
+}).strict();
+var HostRejectResolutionEventSchema = z.object({
+  type: z.literal("approval_resolved"),
+  approvalId: NonBlankIdSchema.optional(),
+  decision: z.literal("reject"),
+  resolvedBy: z.literal("host"),
+  // Required even when the host deliberately omitted a wire reason. `null`
+  // records that complete payload, so a historical host reject with no field
+  // cannot be mistaken for a recoverable executable command.
+  reason: z.string().nullable(),
+  at: z.iso.datetime({ offset: true })
+}).strict();
+var ApprovalTimelineEventSchema = z.union([
+  ApprovalRequestedEventSchema,
+  LocalApprovalResolutionEventSchema,
+  HostApprovalResolutionEventSchema,
+  HostRejectResolutionEventSchema
 ]);
 var ApprovalObservationSchema = z.object({
   taskId: TaskIdSchema,
@@ -1073,6 +1214,20 @@ function validateApprovalTimelineAppend(input) {
   }
   return { capacity, ttlMs, event: parsed.data.event };
 }
+function validateApprovalTimelineResolve(input) {
+  const validated = validateApprovalTimelineAppend(input);
+  const expected = z.object({
+    expectedSourceEnvelopeId: NonBlankIdSchema,
+    expectedRevision: z.number().int().positive()
+  }).safeParse(input);
+  if (!expected.success || validated.event.type !== "approval_resolved" || validated.event.resolvedBy !== "host") {
+    throw new ByokCloudError(
+      "coordination_input_invalid",
+      "Host approval resolution requires an exact pending source/revision and a host resolution event."
+    );
+  }
+  return validated;
+}
 function approvalTimelineKey(tenant, taskId) {
   return tenantKey(tenant, taskId);
 }
@@ -1096,6 +1251,10 @@ async function projectTerminalToReview(board, taskId) {
     throw caught;
   }
 }
+function agentReliabilityKey(domain, deviceId, agentRef, id) {
+  const exact = AgentRefSchema.parse(agentRef);
+  return `${domain}:${JSON.stringify([deviceId, exact.agentId, exact.profileRevision, id])}`;
+}
 
 // src/inbound.ts
 async function handleAgentMessagePublish(stores, deviceId, taskId, payload, consume, alreadyDeduplicated) {
@@ -1112,7 +1271,6 @@ async function handleAgentMessagePublish(stores, deviceId, taskId, payload, cons
   if (!sameAgentRef(frozen.agentRef, payload.agentRef) || frozen.context === void 0 || frozen.requirement?.contract !== payload.contract || frozen.sessionRef !== void 0 && frozen.sessionRef !== payload.sessionRef || frozen.requirement.contentType !== payload.contentType || typeof frozen.requirement.maxBytes !== "number" || payload.byteCount > frozen.requirement.maxBytes) return { outcome: "rejected" };
   const priorDisposition = await readAgentMessageDisposition(stores, deviceId, taskId, payload);
   if (priorDisposition !== void 0) return { outcome: "duplicate", disposition: priorDisposition };
-  if (alreadyDeduplicated) return { outcome: "rejected" };
   const payloadBody = JSON.stringify(payload);
   const reservation = await stores.tasks.reserveAgentMessage({
     taskId,
@@ -1120,17 +1278,15 @@ async function handleAgentMessagePublish(stores, deviceId, taskId, payload, cons
     messageId: payload.messageId,
     payloadBody
   });
-  if (reservation === "pending") return { outcome: "rejected" };
-  if (reservation !== "reserved") return { outcome: "rejected" };
+  if (reservation !== "reserved" && reservation !== "pending") return { outcome: "rejected" };
   let decision;
   if (consume === void 0) {
+    if (reservation === "pending") {
+      throw new Error("Agent message consumer is unavailable while reconciling an exact pending admission.");
+    }
     decision = { outcome: "held", reasonCode: "consumer_unavailable" };
   } else {
-    try {
-      decision = await consume({ tenant: stores.tenant, deviceId, taskId, context: frozen.context, payload });
-    } catch {
-      decision = { outcome: "held", reasonCode: "consumer_failed" };
-    }
+    decision = await consume({ tenant: stores.tenant, deviceId, taskId, context: frozen.context, payload });
   }
   const disposition = agentMessageDisposition(payload, decision);
   const admission = await stores.tasks.finalizeAgentMessage({
@@ -1195,17 +1351,17 @@ function contentReadCapability(surface) {
 function hasCapabilities(capabilities, required) {
   return capabilities !== void 0 && required.every((capability) => capabilities.includes(capability));
 }
-function contentRequestReceiptKey(deviceId, requestId) {
-  return `agent-content-request:${deviceId}:${requestId}`;
+function contentRequestReceiptKey(deviceId, agentRef, requestId) {
+  return agentReliabilityKey("agent-content-request", deviceId, agentRef, requestId);
 }
-function contentReceiptKey(deviceId, requestId) {
-  return `agent-content:${deviceId}:${requestId}`;
+function contentReceiptKey(deviceId, agentRef, requestId) {
+  return agentReliabilityKey("agent-content-receipt", deviceId, agentRef, requestId);
 }
 function matchesContentReadReceipt(request, receipt) {
   return request.requestId === receipt.requestId && request.surface === receipt.surface && request.actor.kind === receipt.actor.kind && request.actor.id === receipt.actor.id && sameAgentRef(request.agentRef, receipt.agentRef) && request.sessionRef === receipt.sessionRef && request.runtime === receipt.runtime && request.cwd === receipt.cwd && request.policyRevision === receipt.policyRevision && request.target === receipt.target && request.mimeType === receipt.mimeType && request.decodeAs === receipt.decodeAs;
 }
-async function readContentRequest(stores, deviceId, requestId) {
-  const stored = await stores.receipts.get(contentRequestReceiptKey(deviceId, requestId));
+async function readContentRequest(stores, deviceId, agentRef, requestId) {
+  const stored = await stores.receipts.get(contentRequestReceiptKey(deviceId, agentRef, requestId));
   if (stored === void 0) return void 0;
   try {
     return AgentContentReadPayloadSchema.parse(JSON.parse(stored.body));
@@ -1228,7 +1384,23 @@ function inboundAgentRef(envelope) {
 function agentRefEchoRequired(envelope) {
   return envelope.type === "task.claim" || envelope.type === "task.decline" || envelope.type === "task.complete" || envelope.type === "task.fail" || envelope.type === "task.cancelled";
 }
-async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds = DEFAULT_ACTIVITY_BOUNDS, agentMessageConsume) {
+async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds = DEFAULT_ACTIVITY_BOUNDS, agentMessageConsume, observer) {
+  const outcome = await applyInboundGate(
+    stores,
+    deviceId,
+    envelope,
+    activityBounds,
+    agentMessageConsume
+  );
+  if (outcome === "accepted" && observer !== void 0) {
+    try {
+      observer.onInboundCommitted({ tenantId: stores.tenant, deviceId, envelope, outcome });
+    } catch {
+    }
+  }
+  return outcome;
+}
+async function applyInboundGate(stores, deviceId, envelope, activityBounds, agentMessageConsume) {
   if (!await stores.rateLimiter.consume(deviceId)) return "rate_limited";
   if (envelope.type === "conn.hello") {
     if (envelope.payload.deviceId !== deviceId) return "rejected";
@@ -1237,20 +1409,20 @@ async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds
     if (device === void 0 || device.revoked || device.productId !== envelope.payload.productId) {
       return "rejected";
     }
-    if (await stores.dedup.checkAndRecord(deviceId, envelope.id)) return "duplicate";
-    return await stores.devices.recordCapabilities({ capabilities: envelope.payload.capabilities }) === void 0 ? "rejected" : "accepted";
+    if (await stores.devices.recordCapabilities({ capabilities: envelope.payload.capabilities }) === void 0) {
+      return "rejected";
+    }
+    return completeInboundEnvelope(stores, deviceId, envelope.id, void 0);
   }
   if (!DAEMON_TO_SERVER_TYPES.includes(envelope.type)) return "rejected";
   if (envelope.type === "agent.message.publish") {
-    const alreadyDeduplicated = await stores.dedup.checkAndRecord(deviceId, envelope.id);
-    return (await handleAgentMessagePublish(
+    const message = await handleAgentMessagePublish(
       stores,
       deviceId,
       envelope.task_id,
       envelope.payload,
-      agentMessageConsume,
-      alreadyDeduplicated
-    )).outcome;
+      agentMessageConsume);
+    return message.outcome === "rejected" ? "rejected" : completeInboundEnvelope(stores, deviceId, envelope.id, envelope.payload.agentRef);
   }
   if (envelope.type === "agent.egress.reliable") {
     const device = await stores.devices.get(deviceId);
@@ -1262,25 +1434,28 @@ async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds
       payload: envelope.payload,
       receiptId: crypto.randomUUID()
     });
-    return outcome.created || sameReliableEgress(outcome.record.payload, envelope.payload) ? outcome.created ? "accepted" : "duplicate" : "rejected";
+    if (!outcome.created && !sameReliableEgress(outcome.record.payload, envelope.payload)) return "rejected";
+    return completeInboundEnvelope(stores, deviceId, envelope.id, envelope.payload.agentRef);
   }
   if (envelope.type === "agent.content.receipt") {
     const device = await stores.devices.get(deviceId);
     if (device === void 0 || device.revoked || envelope.payload.eventId !== envelope.payload.requestId || !hasCapabilities(device.capabilities, [contentReadCapability(envelope.payload.surface), AGENT_EGRESS_RELIABLE_ACK_CAPABILITY])) {
       return "rejected";
     }
-    const request = await readContentRequest(stores, deviceId, envelope.payload.requestId);
+    const request = await readContentRequest(stores, deviceId, envelope.payload.agentRef, envelope.payload.requestId);
     if (request === void 0 || !matchesContentReadReceipt(request, envelope.payload)) return "rejected";
-    const key = contentReceiptKey(deviceId, envelope.payload.requestId);
+    const key = contentReceiptKey(deviceId, envelope.payload.agentRef, envelope.payload.requestId);
     const body = JSON.stringify(envelope.payload);
     const receipt = await stores.receipts.record({ key, body });
-    return receipt.created ? "accepted" : receipt.receipt.body === body ? "duplicate" : "rejected";
+    if (!receipt.created && receipt.receipt.body !== body) return "rejected";
+    return completeInboundEnvelope(stores, deviceId, envelope.id, envelope.payload.agentRef);
   }
   const taskId = envelope.task_id;
   if (taskId === void 0) return "rejected";
   const attempt = await stores.tasks.get(taskId);
-  if (attempt?.agentRef !== void 0 && attempt.deviceId !== deviceId) return "rejected";
+  if (attempt === void 0 || attempt.deviceId !== deviceId) return "rejected";
   if (attempt?.ownerDeviceId !== void 0 && attempt.ownerDeviceId !== deviceId) return "rejected";
+  if (envelope.type === "task.claim" && envelope.payload.deviceId !== deviceId) return "rejected";
   if (attempt?.agentRef !== void 0 && agentRefEchoRequired(envelope) && !sameAgentRef(attempt.agentRef, inboundAgentRef(envelope))) {
     return "rejected";
   }
@@ -1312,14 +1487,22 @@ async function handleInboundEnvelope(stores, deviceId, envelope, activityBounds
       throw caught;
     }
   }
-  if (await stores.dedup.checkAndRecord(deviceId, envelope.id)) return "duplicate";
   await applyLifecycle(stores, deviceId, taskId, envelope, activityBounds, attempt?.agentRef);
-  return "accepted";
+  return completeInboundEnvelope(stores, deviceId, envelope.id, attempt?.agentRef);
+}
+async function completeInboundEnvelope(stores, deviceId, envelopeId, agentRef) {
+  const duplicate = agentRef === void 0 ? await stores.dedup.checkAndRecord(deviceId, envelopeId) : await stores.dedup.checkAndRecordAgent(deviceId, agentRef, envelopeId);
+  return duplicate ? "duplicate" : "accepted";
 }
 async function applyLifecycle(stores, deviceId, taskId, envelope, activityBounds, persistedAgentRef) {
   switch (envelope.type) {
     case "task.claim":
-      await stores.tasks.claim({ taskId, deviceId });
+      await stores.tasks.claim({
+        taskId,
+        deviceId,
+        ...envelope.payload.runtime === void 0 ? {} : { runtime: envelope.payload.runtime },
+        ...envelope.payload.capabilities === void 0 ? {} : { capabilities: envelope.payload.capabilities }
+      });
       return;
     case "task.started":
       await stores.tasks.recordStatus({
@@ -1329,11 +1512,7 @@ async function applyLifecycle(stores, deviceId, taskId, envelope, activityBounds
       });
       return;
     case "task.decline":
-      await stores.tasks.recordStatus({
-        taskId,
-        status: "failed",
-        ...persistedAgentRef === void 0 ? {} : { agentRef: persistedAgentRef }
-      });
+      await recordTerminal(stores, taskId, envelope);
       return;
     case "task.progress":
       if (envelope.payload.events.length > 0) {
@@ -1357,13 +1536,13 @@ async function applyLifecycle(stores, deviceId, taskId, envelope, activityBounds
       await stores.approvals.append(approvalTimelineAppendInput(taskId, envelope));
       return;
     case "task.complete":
-      await recordTerminal(stores, taskId, envelope, "complete");
+      await recordTerminal(stores, taskId, envelope);
       return;
     case "task.fail":
-      await recordTerminal(stores, taskId, envelope, "failed");
+      await recordTerminal(stores, taskId, envelope);
       return;
     case "task.cancelled":
-      await recordTerminal(stores, taskId, envelope, "cancelled");
+      await recordTerminal(stores, taskId, envelope);
       return;
     default:
       return;
@@ -1397,33 +1576,67 @@ function approvalTimelineAppendInput(taskId, envelope) {
       return void 0;
   }
 }
-async function recordTerminal(stores, taskId, envelope, status) {
-  const attempt = await stores.tasks.get(taskId);
-  const { created } = await stores.receipts.record({
+async function recordTerminal(stores, taskId, envelope) {
+  const receipt = await stores.receipts.record({
     key: terminalReceiptKey(taskId),
     body: encodeEnvelope(envelope)
   });
+  const winner = terminalReceiptBinding(taskId, receipt.receipt.body);
+  if (winner === void 0) {
+    throw new Error(`terminal receipt for ${taskId} is not a canonical terminal binding`);
+  }
+  const attempt = await stores.tasks.get(taskId);
   if (attempt?.cancellation !== void 0) {
-    if (status === "cancelled") {
+    await stores.tasks.recordStatus({
+      taskId,
+      status: "cancelled",
+      ...attempt.agentRef === void 0 ? {} : { agentRef: attempt.agentRef }
+    });
+    return;
+  }
+  const recordedAttempt = await stores.tasks.recordStatus({
+    taskId,
+    status: winner.status,
+    ...attempt?.agentRef === void 0 ? {} : { agentRef: attempt.agentRef },
+    ...winner.cause === void 0 ? {} : { terminalCause: winner.cause }
+  });
+  if (recordedAttempt?.cancellation !== void 0 || recordedAttempt?.status !== winner.status) {
+    if (recordedAttempt?.cancellation !== void 0) {
       await stores.tasks.recordStatus({
         taskId,
         status: "cancelled",
-        ...attempt.agentRef === void 0 ? {} : { agentRef: attempt.agentRef }
+        ...recordedAttempt.agentRef === void 0 ? {} : { agentRef: recordedAttempt.agentRef }
       });
     }
     return;
   }
-  if (!created) return;
-  const cause = envelope.type === "task.fail" || envelope.type === "task.cancelled" ? envelope.payload.reason : void 0;
-  const recordedAttempt = await stores.tasks.recordStatus({
-    taskId,
-    status,
-    ...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);
 }
+function terminalStatus(envelope) {
+  switch (envelope.type) {
+    case "task.complete":
+      return "complete";
+    case "task.fail":
+    case "task.decline":
+      return "failed";
+    case "task.cancelled":
+      return "cancelled";
+    default:
+      return void 0;
+  }
+}
+function terminalReceiptBinding(taskId, body) {
+  let envelope;
+  try {
+    envelope = decodeEnvelope(body);
+  } catch {
+    return void 0;
+  }
+  const status = terminalStatus(envelope);
+  if (status === void 0 || envelope.task_id !== taskId || encodeEnvelope(envelope) !== body) return void 0;
+  const cause = envelope.type === "task.fail" || envelope.type === "task.cancelled" || envelope.type === "task.decline" ? envelope.payload.reason : void 0;
+  return { status, ...cause === void 0 ? {} : { cause } };
+}
 
 // src/handlers/messages.ts
 var MESSAGES_JSON_BODY_MAX_BYTES = 2 * 1024 * 1024;
@@ -1444,7 +1657,8 @@ function messagesHandler(deps) {
         device.deviceId,
         envelope,
         deps.activityBounds,
-        envelope.type === "agent.message.publish" ? deps.agentMessage?.consume : void 0
+        envelope.type === "agent.message.publish" ? deps.agentMessage?.consume : void 0,
+        deps.observer
       );
       if (outcome === "rate_limited") return c.json({ error: "rate limit exceeded" }, 429);
       if (envelope.type === "agent.message.publish") {
@@ -1454,7 +1668,7 @@ function messagesHandler(deps) {
         }
       }
       if (envelope.type === "agent.egress.reliable" && (outcome === "accepted" || outcome === "duplicate")) {
-        const record = await stores.egress.get(device.deviceId, envelope.payload.eventId);
+        const record = await stores.egress.get(device.deviceId, envelope.payload.agentRef, envelope.payload.eventId);
         if (record === void 0) {
           throw new Error(`Accepted reliable egress ${envelope.payload.eventId} has no durable receipt record.`);
         }
@@ -2273,11 +2487,11 @@ var CloudRouteRegistry = class {
     return this.#app.fetch;
   }
 };
-function agentHomeProjectionRequestKey(deviceId, requestId) {
-  return `agent-home-projection:v1:${deviceId}:${requestId}:request`;
+function agentHomeProjectionRequestKey(deviceId, agentRef, requestId) {
+  return agentReliabilityKey("agent-home-projection-request", deviceId, agentRef, requestId);
 }
-function agentHomeProjectionCompletionKey(deviceId, requestId) {
-  return `agent-home-projection:v1:${deviceId}:${requestId}:completion`;
+function agentHomeProjectionCompletionKey(deviceId, agentRef, requestId) {
+  return agentReliabilityKey("agent-home-projection-completion", deviceId, agentRef, requestId);
 }
 function sameAgentHomeProjectionRequest(expected, actual) {
   return expected.requestId === actual.requestId && expected.agentRef.agentId === actual.agentRef.agentId && expected.agentRef.profileRevision === actual.agentRef.profileRevision && expected.projectionHash === actual.projectionHash && JSON.stringify(expected.projection) === JSON.stringify(actual.projection);
@@ -2311,7 +2525,7 @@ function parseCompletionBody(body) {
   }
 }
 async function readAgentHomeProjectionStatus(receipts, tenant, deviceId, input) {
-  const storedRequest = await receipts.get(agentHomeProjectionRequestKey(deviceId, input.requestId));
+  const storedRequest = await receipts.get(agentHomeProjectionRequestKey(deviceId, input.agentRef, input.requestId));
   if (storedRequest === void 0) return void 0;
   const request = parseRequestBody(storedRequest.body);
   if (!statusInputMatchesAgentHomeProjection(request, input)) {
@@ -2320,7 +2534,7 @@ async function readAgentHomeProjectionStatus(receipts, tenant, deviceId, input)
       `Agent-home projection request ${input.requestId} does not match its immutable desired fact.`
     );
   }
-  const storedCompletion = await receipts.get(agentHomeProjectionCompletionKey(deviceId, input.requestId));
+  const storedCompletion = await receipts.get(agentHomeProjectionCompletionKey(deviceId, request.agentRef, input.requestId));
   if (storedCompletion === void 0) {
     return {
       tenantId: tenant,
@@ -2350,7 +2564,7 @@ async function readAgentHomeProjectionStatus(receipts, tenant, deviceId, input)
 }
 async function recordAgentHomeProjectionCompletion(receipts, tenant, deviceId, receiptInput) {
   const receipt = AgentHomeProjectionCompletionRequestSchema.parse(receiptInput);
-  const storedRequest = await receipts.get(agentHomeProjectionRequestKey(deviceId, receipt.requestId));
+  const storedRequest = await receipts.get(agentHomeProjectionRequestKey(deviceId, receipt.agentRef, receipt.requestId));
   if (storedRequest === void 0) {
     throw new ByokCloudError(
       "agent_home_projection_request_not_found",
@@ -2366,7 +2580,7 @@ async function recordAgentHomeProjectionCompletion(receipts, tenant, deviceId, r
   }
   const body = JSON.stringify(receipt);
   const storedCompletion = await receipts.record({
-    key: agentHomeProjectionCompletionKey(deviceId, receipt.requestId),
+    key: agentHomeProjectionCompletionKey(deviceId, request.agentRef, receipt.requestId),
     body
   });
   if (!storedCompletion.created && storedCompletion.receipt.body !== body) {
@@ -2420,6 +2634,21 @@ function projectTerminalResult(taskId, receipt) {
         ...envelope.payload.usage !== void 0 ? { usage: envelope.payload.usage } : {},
         recordedAt: receipt.recordedAt
       };
+    // `task.decline` is the pre-claim terminal (§3.2, `Offered -> Failed`).
+    // It projects onto the same `failed` state as `task.fail` — there is no
+    // separate declined state — and carries the device's own `retryable`
+    // verbatim, exactly like `task.fail` does; this projection never decides
+    // that a decline is retryable on the device's behalf.
+    case "task.decline":
+      return {
+        taskId,
+        state: "failed",
+        ...envelope.payload.agentRef === void 0 ? {} : { agentRef: envelope.payload.agentRef },
+        reason: envelope.payload.reason,
+        terminalCause: envelope.payload.reason,
+        ...envelope.payload.retryable !== void 0 ? { retryable: envelope.payload.retryable } : {},
+        recordedAt: receipt.recordedAt
+      };
     case "task.cancelled":
       return {
         taskId,
@@ -2444,9 +2673,25 @@ var DEFAULT_LONG_POLL_HOLD_MS = 5e4;
 var DEFAULT_LONG_POLL_INTERVAL_MS = 250;
 var DEFAULT_EVENTS_PAGE_LIMIT = 50;
 var AGENT_HOME_CONTRACT_CAPABILITY = "agent-home-contract";
+function isTerminalAttemptStatus(status) {
+  return status === "complete" || status === "failed" || status === "cancelled";
+}
 function sameAgentRef2(expected, actual) {
   return actual?.agentId === expected.agentId && actual.profileRevision === expected.profileRevision;
 }
+function uuidFromSha256(value) {
+  const match = /^sha256:([0-9a-f]{64})$/.exec(value);
+  if (match === null) throw new Error("CloudCrypto.sha256 must return canonical sha256 hex");
+  const digest = match[1];
+  if (digest === void 0) throw new Error("CloudCrypto.sha256 must return canonical sha256 hex");
+  const hex = digest.slice(0, 32).split("");
+  hex[12] = "8";
+  hex[16] = ["8", "9", "a", "b"][Number.parseInt(hex[16], 16) & 3];
+  return `${hex.slice(0, 8).join("")}-${hex.slice(8, 12).join("")}-${hex.slice(12, 16).join("")}-${hex.slice(16, 20).join("")}-${hex.slice(20).join("")}`;
+}
+function sameOfferEnvelope(expected, actual) {
+  return expected.id === actual.id && expected.type === actual.type && expected.task_id === actual.task_id && JSON.stringify(expected.payload) === JSON.stringify(actual.payload);
+}
 function createByokCloud(options) {
   const declaration = parseDeclaration(options.capabilities);
   assertNoOverDeclaration(
@@ -2468,7 +2713,11 @@ function createByokCloud(options) {
   });
   const deviceRouteDeps = {
     root,
-    bearer: { tokenSigner: options.tokenSigner, devices: options.cloud.devices }
+    bearer: {
+      tokenSigner: options.tokenSigner,
+      devices: options.cloud.devices,
+      ...options.instanceProductId === void 0 ? {} : { instanceProductId: options.instanceProductId }
+    }
   };
   const registry = new CloudRouteRegistry();
   const activityBounds = {
@@ -2513,7 +2762,8 @@ function createByokCloud(options) {
         appendReliableEgressAck: enqueueReliableEgressAck,
         appendContentReceiptAck: enqueueContentReceiptAck,
         agentMessage: options.agentMessage,
-        appendAgentMessageDisposition: enqueueAgentMessageDisposition
+        appendAgentMessageDisposition: enqueueAgentMessageDisposition,
+        observer: options.observer
       })
     );
   }
@@ -2645,56 +2895,60 @@ function createByokCloud(options) {
   async function enqueueTaskEnvelope(tenant, deviceId, requestedTaskId, agentRef, buildEnvelope, beforeMailbox) {
     const stores = tenantStoresFor(controlPlane(tenant), root);
     const taskId = requestedTaskId ?? `task_${options.crypto.randomUuid()}`;
-    const messageId = options.crypto.randomUuid();
+    const messageId = uuidFromSha256(
+      await options.crypto.sha256(
+        new TextEncoder().encode(
+          JSON.stringify({ domain: "byok:task-offer", tenant, taskId, deviceId, agentRef })
+        )
+      )
+    );
     const reservation = agentRef === void 0 ? void 0 : await stores.tasks.reserveAgentOffer({ taskId, deviceId, agentRef });
-    const openedBeforeAppend = reservation?.attempt;
-    if (agentRef !== void 0 && (openedBeforeAppend === void 0 || openedBeforeAppend.deviceId !== deviceId || openedBeforeAppend.agentRef === void 0 || !sameAgentRef2(agentRef, openedBeforeAppend.agentRef))) {
+    const openedBeforeAppend = reservation?.attempt ?? (agentRef === void 0 ? await stores.tasks.open({ taskId, deviceId }) : void 0);
+    if (openedBeforeAppend === void 0 || openedBeforeAppend.deviceId !== deviceId || (agentRef === void 0 ? openedBeforeAppend.agentRef !== void 0 : openedBeforeAppend.agentRef === void 0 || !sameAgentRef2(agentRef, openedBeforeAppend.agentRef))) {
       throw new ByokCloudError(
-        "agent_ref_mismatch",
-        `Task ${taskId} already has a different durable Agent identity or target device.`
+        agentRef === void 0 ? "coordination_input_invalid" : "agent_ref_mismatch",
+        `Task ${taskId} already has a different durable target or Agent identity.`
       );
     }
-    if (reservation !== void 0 && !reservation.created) {
+    const offerReceiptKey = `task-offer:${messageId}`;
+    const deliveryReceiptKey = `task-offer-delivered:${messageId}`;
+    if (await stores.receipts.get(deliveryReceiptKey) !== void 0) {
       throw new ByokCloudError(
-        "agent_task_already_exists",
-        `Task ${taskId} already has a durable Agent attempt and cannot be enqueued again.`
+        agentRef === void 0 ? "coordination_input_invalid" : "agent_task_already_exists",
+        `Task ${taskId} already has a durable delivered attempt and cannot be enqueued again.`
       );
     }
-    let message;
-    try {
-      await beforeMailbox?.(stores, taskId);
-      message = await stores.mailbox.append({
-        deviceId,
-        messageId,
-        materialize: async (seq) => {
-          const envelope2 = buildEnvelope(taskId, seq, messageId);
-          const body = encodeEnvelope(envelope2);
-          const bytes = new TextEncoder().encode(body);
-          return {
-            body,
-            bodyHash: contentHash(await options.crypto.sha256(bytes)),
-            byteSize: BigInt(bytes.length)
-          };
-        }
-      });
-    } catch (error) {
-      if (openedBeforeAppend !== void 0) {
-        try {
-          await stores.tasks.recordStatus({
-            taskId,
-            status: "failed",
-            agentRef,
-            terminalCause: "mailbox append failed before Agent offer delivery"
-          });
-        } catch (cleanupError) {
-          throw new AggregateError(
-            [error, cleanupError],
-            `Agent task ${taskId} could not be delivered or durably closed`
-          );
-        }
-      }
-      throw error;
+    const proposed = buildEnvelope(taskId, 0, messageId);
+    const proposedBody = JSON.stringify({
+      deviceId,
+      type: proposed.type,
+      payload: proposed.payload
+    });
+    const recorded = await stores.receipts.record({
+      key: offerReceiptKey,
+      body: proposedBody
+    });
+    if (!recorded.created && recorded.receipt.body !== proposedBody) {
+      throw new ByokCloudError(
+        "coordination_input_invalid",
+        `Task ${taskId} already has a different executable offer body.`
+      );
     }
+    await beforeMailbox?.(stores, taskId);
+    const message = await stores.mailbox.append({
+      deviceId,
+      messageId,
+      materialize: async (seq) => {
+        const envelope2 = buildEnvelope(taskId, seq, messageId);
+        const body = encodeEnvelope(envelope2);
+        const bytes = new TextEncoder().encode(body);
+        return {
+          body,
+          bodyHash: contentHash(await options.crypto.sha256(bytes)),
+          byteSize: BigInt(bytes.length)
+        };
+      }
+    });
     const envelope = decodeEnvelope(message.body);
     if (envelope.seq !== message.seq) {
       throw new ByokCloudError(
@@ -2702,11 +2956,20 @@ function createByokCloud(options) {
         `Mailbox stored offer seq ${String(envelope.seq)} at row ${message.seq}; the daemon's redelivery cursor would be wrong.`
       );
     }
-    const attempt = openedBeforeAppend ?? await stores.tasks.open({
-      taskId,
-      deviceId
-    });
-    return { taskId, seq: message.seq, envelope, attempt };
+    if (!sameOfferEnvelope(buildEnvelope(taskId, message.seq, messageId), envelope)) {
+      throw new ByokCloudError(
+        "coordination_input_invalid",
+        `Task ${taskId} already has a different executable offer body.`
+      );
+    }
+    const delivered = await stores.receipts.record({ key: deliveryReceiptKey, body: messageId });
+    if (agentRef !== void 0 && reservation?.created === false && !delivered.created) {
+      throw new ByokCloudError(
+        "agent_task_already_exists",
+        `Task ${taskId} already has a durable Agent attempt and cannot be enqueued again.`
+      );
+    }
+    return { taskId, seq: message.seq, envelope, attempt: openedBeforeAppend };
   }
   async function assertAgentCapabilities(tenant, deviceId, required) {
     const device = await options.cloud.devices.get(tenant, deviceId);
@@ -2761,6 +3024,236 @@ function createByokCloud(options) {
     }
     return { seq: message.seq, envelope };
   }
+  async function agentControlEnvelopeId(domain, tenant, deviceId, agentRef, logicalRequestId) {
+    return uuidFromSha256(
+      await options.crypto.sha256(
+        new TextEncoder().encode(
+          JSON.stringify({ domain, tenant, deviceId, agentRef, logicalRequestId })
+        )
+      )
+    );
+  }
+  async function approvalDecisionSource(tenant, taskId, attempt, pending, decision) {
+    const agent = attempt.agentRef;
+    return uuidFromSha256(
+      await options.crypto.sha256(
+        new TextEncoder().encode(
+          JSON.stringify({
+            domain: "byok:approval-decision",
+            tenant,
+            taskId,
+            deviceId: attempt.deviceId,
+            ownerDeviceId: attempt.ownerDeviceId,
+            agentRef: agent,
+            requestSourceEnvelopeId: pending.sourceEnvelopeId,
+            requestRevision: pending.revision,
+            decision
+          })
+        )
+      )
+    );
+  }
+  function latestApprovalRequest(tail) {
+    if (tail === void 0) return void 0;
+    for (let index = tail.entries.length - 1; index >= 0; index -= 1) {
+      const entry = tail.entries[index];
+      if (entry.event.type !== "approval_requested") continue;
+      return {
+        sourceEnvelopeId: entry.sourceEnvelopeId,
+        revision: entry.revision,
+        ...entry.event.approvalId === void 0 ? {} : { approvalId: entry.event.approvalId }
+      };
+    }
+    return void 0;
+  }
+  async function recordedHostDecision(tenant, taskId, attempt, tail, request) {
+    for (const decision of ["approve", "reject"]) {
+      const sourceEnvelopeId = await approvalDecisionSource(tenant, taskId, attempt, request, decision);
+      const index = tail?.entries.findIndex((candidate) => candidate.sourceEnvelopeId === sourceEnvelopeId) ?? -1;
+      const entry = index < 0 ? void 0 : tail.entries[index];
+      if (entry?.event.type !== "approval_resolved" || entry.event.resolvedBy !== "host") continue;
+      const laterResolution = tail.entries.slice(index + 1).some(
+        (candidate) => candidate.event.type === "approval_resolved" && (request.approvalId === void 0 || candidate.event.approvalId === request.approvalId)
+      );
+      if (!laterResolution) {
+        if (entry.event.decision === "reject") {
+          return {
+            decision: "reject",
+            ...entry.event.approvalId === void 0 ? {} : { approvalId: entry.event.approvalId },
+            reason: entry.event.reason
+          };
+        }
+        return {
+          decision: "approve",
+          ...entry.event.approvalId === void 0 ? {} : { approvalId: entry.event.approvalId }
+        };
+      }
+    }
+    return void 0;
+  }
+  async function resolveApproval(tenant, taskId, decision, opts) {
+    const stores = tenantStoresFor(controlPlane(tenant), root);
+    const attempt = await stores.tasks.get(taskId);
+    if (attempt === void 0) {
+      throw new ByokCloudError("task_not_found", `Task ${taskId} was not found for this tenant.`);
+    }
+    if (isTerminalAttemptStatus(attempt.status)) {
+      throw new ByokCloudError(
+        "task_not_awaiting_approval",
+        `Task ${taskId} already reached ${attempt.status}; there is no approval left to ${decision}.`
+      );
+    }
+    const tail = await stores.approvals.read(taskId);
+    const pending = pendingApproval(tail);
+    const latestRequest = latestApprovalRequest(tail);
+    if (pending === void 0) {
+      if (latestRequest !== void 0) {
+        const recorded = await recordedHostDecision(tenant, taskId, attempt, tail, latestRequest);
+        if (recorded !== void 0) {
+          if (recorded.decision !== decision) {
+            throw new ByokCloudError(
+              "coordination_input_invalid",
+              `Task ${taskId} already has the opposite host approval decision.`
+            );
+          }
+          if (recorded.decision === "reject" && recorded.reason !== (opts?.reason ?? null)) {
+            throw new ByokCloudError(
+              "coordination_input_invalid",
+              `Task ${taskId} already has a host rejection with a different immutable reason.`
+            );
+          }
+          const ownerDeviceId2 = attempt.ownerDeviceId;
+          if (ownerDeviceId2 === void 0) {
+            throw new ByokCloudError(
+              "task_not_awaiting_approval",
+              `Task ${taskId} has no owning device to receive its recorded ${decision}.`
+            );
+          }
+          const messageId2 = await approvalDecisionSource(tenant, taskId, attempt, latestRequest, decision);
+          const targeting2 = recorded.approvalId === void 0 ? {} : { approvalId: recorded.approvalId };
+          const recordedReason = recorded.decision === "reject" ? recorded.reason : void 0;
+          return enqueueAgentControlEnvelope(
+            tenant,
+            ownerDeviceId2,
+            messageId2,
+            (seq) => decision === "approve" ? createEnvelope("task.approve", targeting2, { id: messageId2, taskId, seq }) : createEnvelope(
+              "task.reject",
+              { ...targeting2, ...recordedReason === null || recordedReason === void 0 ? {} : { reason: recordedReason } },
+              { id: messageId2, taskId, seq }
+            )
+          );
+        }
+      }
+      throw new ByokCloudError(
+        "task_not_awaiting_approval",
+        `Task ${taskId} has no pending approval to ${decision}.`
+      );
+    }
+    if (opts?.approvalId !== void 0 && pending.approvalId !== void 0 && opts.approvalId !== pending.approvalId) {
+      throw new StaleApprovalError(taskId, opts.approvalId, pending.approvalId);
+    }
+    const ownerDeviceId = attempt.ownerDeviceId;
+    if (ownerDeviceId === void 0) {
+      throw new ByokCloudError(
+        "task_not_awaiting_approval",
+        `Task ${taskId} has no owning device; no runtime is paused on an approval to ${decision}.`
+      );
+    }
+    const approvalId = pending.approvalId;
+    const messageId = await approvalDecisionSource(tenant, taskId, attempt, pending, decision);
+    const event = decision === "reject" ? {
+      type: "approval_resolved",
+      ...approvalId === void 0 ? {} : { approvalId },
+      decision: "reject",
+      resolvedBy: "host",
+      reason: opts?.reason ?? null,
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    } : {
+      type: "approval_resolved",
+      ...approvalId === void 0 ? {} : { approvalId },
+      decision: "approve",
+      resolvedBy: "host",
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const resolved = await root.cloud.approvals.resolvePending(tenant, {
+      taskId,
+      sourceEnvelopeId: messageId,
+      expectedSourceEnvelopeId: pending.sourceEnvelopeId,
+      expectedRevision: pending.revision,
+      event
+    });
+    let deliveredApprovalId = approvalId;
+    let deliveredReason = decision === "reject" ? opts?.reason ?? null : void 0;
+    if (resolved.status === "conflict" || resolved.status === "superseded" || resolved.status === "absent") {
+      const currentTail = resolved.tail ?? await stores.approvals.read(taskId);
+      const currentPending = pendingApproval(currentTail);
+      const recorded = await recordedHostDecision(tenant, taskId, attempt, currentTail, pending);
+      if (recorded?.decision === decision) {
+        deliveredApprovalId = recorded.approvalId;
+        if (recorded.decision === "reject") {
+          if (recorded.reason !== deliveredReason) {
+            throw new ByokCloudError(
+              "coordination_input_invalid",
+              `Task ${taskId} already has a host rejection with a different immutable reason.`
+            );
+          }
+          deliveredReason = recorded.reason;
+        }
+      } else if (recorded !== void 0) {
+        throw new ByokCloudError(
+          "coordination_input_invalid",
+          `Task ${taskId} already has the opposite host approval decision.`
+        );
+      } else if (currentPending !== void 0 && opts?.approvalId !== void 0 && currentPending.approvalId !== void 0 && currentPending.approvalId !== opts.approvalId) {
+        throw new StaleApprovalError(taskId, opts.approvalId, currentPending.approvalId);
+      } else {
+        throw new ByokCloudError(
+          "task_not_awaiting_approval",
+          `Task ${taskId} no longer has the pending approval to ${decision}.`
+        );
+      }
+    }
+    const targeting = deliveredApprovalId === void 0 ? {} : { approvalId: deliveredApprovalId };
+    return enqueueAgentControlEnvelope(
+      tenant,
+      ownerDeviceId,
+      messageId,
+      (seq) => decision === "approve" ? createEnvelope("task.approve", targeting, { id: messageId, taskId, seq }) : createEnvelope(
+        "task.reject",
+        { ...targeting, ...deliveredReason === null || deliveredReason === void 0 ? {} : { reason: deliveredReason } },
+        { id: messageId, taskId, seq }
+      )
+    );
+  }
+  async function steerTask(tenant, taskId, payload) {
+    const stores = tenantStoresFor(controlPlane(tenant), root);
+    const attempt = await stores.tasks.get(taskId);
+    if (attempt === void 0) {
+      throw new ByokCloudError("task_not_found", `Task ${taskId} was not found for this tenant.`);
+    }
+    if (isTerminalAttemptStatus(attempt.status)) {
+      throw new SteerRejectedError(taskId, "task_terminal", attempt.status, attempt.claimedRuntime);
+    }
+    const ownerDeviceId = attempt.ownerDeviceId;
+    if (attempt.status !== "running" || ownerDeviceId === void 0) {
+      throw new SteerRejectedError(taskId, "task_not_running", attempt.status, attempt.claimedRuntime);
+    }
+    if (attempt.claimedRuntimeCapabilities?.steer !== true) {
+      throw new SteerRejectedError(
+        taskId,
+        "steer_unsupported_runtime",
+        attempt.status,
+        attempt.claimedRuntime
+      );
+    }
+    const messageId = options.crypto.randomUuid();
+    return enqueueAgentControlEnvelope(
+      tenant,
+      ownerDeviceId,
+      messageId,
+      (seq) => createEnvelope("task.steer", { text: payload.text }, { id: messageId, taskId, seq })
+    );
+  }
   async function getAgentHomeProjectionStatus(tenant, deviceId, input) {
     return readAgentHomeProjectionStatus(
       tenantStoresFor(controlPlane(tenant), root).receipts,
@@ -3034,7 +3527,7 @@ function createByokCloud(options) {
       ]);
       const stores = tenantStoresFor(controlPlane(tenant), root);
       const persisted = await stores.receipts.record({
-        key: `agent-content-request:${deviceId}:${payload.requestId}`,
+        key: agentReliabilityKey("agent-content-request", deviceId, payload.agentRef, payload.requestId),
         body: JSON.stringify(payload)
       });
       if (!persisted.created && persisted.receipt.body !== JSON.stringify(payload)) {
@@ -3043,11 +3536,18 @@ function createByokCloud(options) {
           `Request ${payload.requestId} already exists with a different immutable content-read body.`
         );
       }
+      const messageId = await agentControlEnvelopeId(
+        "byok:agent-content-read",
+        tenant,
+        deviceId,
+        payload.agentRef,
+        payload.requestId
+      );
       const control = await enqueueAgentControlEnvelope(
         tenant,
         deviceId,
-        payload.requestId,
-        (seq) => createEnvelope("agent.content.read", payload, { id: payload.requestId, seq })
+        messageId,
+        (seq) => createEnvelope("agent.content.read", payload, { id: messageId, seq })
       );
       if (control.envelope.type !== "agent.content.read" || JSON.stringify(control.envelope.payload) !== JSON.stringify(payload)) {
         throw new ByokCloudError(
@@ -3066,7 +3566,7 @@ function createByokCloud(options) {
       const stores = tenantStoresFor(controlPlane(tenant), root);
       const requestBody = JSON.stringify(payload);
       const persisted = await stores.receipts.record({
-        key: agentHomeProjectionRequestKey(deviceId, payload.requestId),
+        key: agentHomeProjectionRequestKey(deviceId, payload.agentRef, payload.requestId),
         body: requestBody
       });
       const persistedPayload = AgentHomeProjectionPayloadSchema.parse(JSON.parse(persisted.receipt.body));
@@ -3076,11 +3576,18 @@ function createByokCloud(options) {
           `Agent-home projection request ${payload.requestId} already exists with a different immutable desired body.`
         );
       }
+      const messageId = await agentControlEnvelopeId(
+        "byok:agent-home-projection",
+        tenant,
+        deviceId,
+        payload.agentRef,
+        payload.requestId
+      );
       const control = await enqueueAgentControlEnvelope(
         tenant,
         deviceId,
-        payload.requestId,
-        (seq) => createEnvelope("agent.home.projection", payload, { id: payload.requestId, seq })
+        messageId,
+        (seq) => createEnvelope("agent.home.projection", payload, { id: messageId, seq })
       );
       if (control.envelope.type !== "agent.home.projection" || !sameAgentHomeProjectionRequest(payload, control.envelope.payload)) {
         throw new ByokCloudError(
@@ -3104,6 +3611,13 @@ function createByokCloud(options) {
     getAgentHomeProjectionStatus,
     completeAgentHomeProjection,
     eraseAgentMemoryProjection,
+    approveTask(tenant, taskId, opts) {
+      return resolveApproval(tenant, taskId, "approve", opts);
+    },
+    rejectTask(tenant, taskId, opts) {
+      return resolveApproval(tenant, taskId, "reject", opts);
+    },
+    steerTask,
     async cancelTask(tenant, taskId, reason) {
       const stores = tenantStoresFor(controlPlane(tenant), root);
       const proposedMessageId = options.crypto.randomUuid();
@@ -3143,11 +3657,14 @@ function createByokCloud(options) {
     readTaskAttempt(tenant, taskId) {
       return tenantStoresFor(controlPlane(tenant), root).tasks.get(taskId);
     },
+    listTaskAttempts(tenant, query) {
+      return tenantStoresFor(controlPlane(tenant), root).tasks.list(query);
+    },
     readTerminalReceipt(tenant, taskId) {
       return tenantStoresFor(controlPlane(tenant), root).receipts.get(terminalReceiptKey(taskId));
     },
-    readAgentEgress(tenant, deviceId, eventId) {
-      return tenantStoresFor(controlPlane(tenant), root).egress.get(deviceId, eventId);
+    readAgentEgress(tenant, deviceId, agentRef, eventId) {
+      return tenantStoresFor(controlPlane(tenant), root).egress.get(deviceId, agentRef, eventId);
     },
     async readTaskResult(tenant, taskId) {
       const stores = tenantStoresFor(controlPlane(tenant), root);
@@ -3534,7 +4051,15 @@ var InMemoryInboundDedupStore = class {
     this.#capacity = capacity;
   }
   async checkAndRecord(tenant, deviceId, envelopeId) {
-    const key = tenantKey(tenant, deviceId);
+    return this.#checkAndRecord(tenantKey(tenant, deviceId), envelopeId);
+  }
+  async checkAndRecordAgent(tenant, deviceId, agentRef, envelopeId) {
+    return this.#checkAndRecord(
+      tenantKey(tenant, agentReliabilityKey("inbound-dedup", deviceId, agentRef, "")),
+      envelopeId
+    );
+  }
+  #checkAndRecord(key, envelopeId) {
     let ring = this.#rings.get(key);
     if (ring === void 0) {
       ring = /* @__PURE__ */ new Set();
@@ -3777,22 +4302,23 @@ var InMemoryTaskAttemptStore = class {
   async reserveAgentMessage(tenant, input) {
     const key = tenantKey(tenant, input.taskId);
     return this.#state.mutate(key, () => {
-      const attempt = this.#state.attempts.get(key);
-      if (attempt === void 0 || attempt.deviceId !== input.deviceId || attempt.cancellation !== void 0 || !["offered", "claimed", "running"].includes(attempt.status)) return "rejected";
       const existing = this.#state.messageAdmissions.get(key);
-      if (existing === void 0) {
-        this.#state.messageAdmissions.set(key, {
-          messageId: input.messageId,
-          payloadBody: input.payloadBody
-        });
-        return "reserved";
+      if (existing !== void 0) {
+        return existing.deviceId === input.deviceId && existing.messageId === input.messageId && existing.payloadBody === input.payloadBody ? "pending" : "rejected";
       }
-      return existing.messageId === input.messageId && existing.payloadBody === input.payloadBody ? "pending" : "rejected";
+      const attempt = this.#state.attempts.get(key);
+      if (attempt === void 0 || attempt.deviceId !== input.deviceId || attempt.cancellation !== void 0 || !["offered", "claimed", "running"].includes(attempt.status)) return "rejected";
+      this.#state.messageAdmissions.set(key, {
+        deviceId: input.deviceId,
+        messageId: input.messageId,
+        payloadBody: input.payloadBody
+      });
+      return "reserved";
     });
   }
   async readAgentMessage(tenant, input) {
     const admission = this.#state.messageAdmissions.get(tenantKey(tenant, input.taskId));
-    return admission !== void 0 && admission.messageId === input.messageId && admission.payloadBody === input.payloadBody ? admission : void 0;
+    return admission !== void 0 && admission.deviceId === input.deviceId && admission.messageId === input.messageId && admission.payloadBody === input.payloadBody ? admission : void 0;
   }
   async finalizeAgentMessage(tenant, input) {
     const key = tenantKey(tenant, input.taskId);
@@ -3800,7 +4326,7 @@ var InMemoryTaskAttemptStore = class {
   }
   #terminalize(key, input) {
     const admission = this.#state.messageAdmissions.get(key);
-    if (admission === void 0 || admission.messageId !== input.messageId || admission.payloadBody !== input.payloadBody) {
+    if (admission === void 0 || admission.deviceId !== input.deviceId || admission.messageId !== input.messageId || admission.payloadBody !== input.payloadBody) {
       return void 0;
     }
     if (admission.terminalBody !== void 0) return admission;
@@ -3817,15 +4343,29 @@ var InMemoryTaskAttemptStore = class {
       return attempt === void 0 ? [] : [attempt];
     });
   }
+  async list(tenant, query) {
+    assertTaskAttemptListLimit(query.limit);
+    const cursor = query.cursor;
+    const matches = [...this.#state.attempts.values()].filter((attempt) => attempt.tenantId === tenant).filter((attempt) => cursor === void 0 || attempt.taskId > cursor).sort((left, right) => left.taskId < right.taskId ? -1 : left.taskId > right.taskId ? 1 : 0);
+    const attempts = matches.slice(0, query.limit);
+    const hasMore = matches.length > attempts.length;
+    const last = attempts.at(-1);
+    return {
+      attempts,
+      ...hasMore && last !== void 0 ? { nextCursor: last.taskId } : {}
+    };
+  }
   async claim(tenant, input) {
     const key = tenantKey(tenant, input.taskId);
     return this.#state.mutate(key, () => {
       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;
+      if (existing.deviceId !== input.deviceId || existing.ownerDeviceId !== void 0 || existing.cancellation !== void 0 || existing.status !== "offered") return existing;
       const claimed = {
         ...existing,
         ownerDeviceId: input.deviceId,
+        ...input.runtime === void 0 ? {} : { claimedRuntime: input.runtime },
+        ...input.capabilities === void 0 ? {} : { claimedRuntimeCapabilities: { ...input.capabilities } },
         status: "claimed",
         updatedAt: this.#now()
       };
@@ -3948,6 +4488,14 @@ var InMemoryActivityStore = class {
     const key = activityTailKey(tenant, input.taskId);
     const existing = this.#tails.get(key);
     const live = existing !== void 0 && receivedAt < existing.expiresAt ? existing : void 0;
+    const sourceState = activitySourceBatchState(live?.entries ?? [], input);
+    if (sourceState === "same") return live;
+    if (sourceState === "conflict") {
+      throw new ByokCloudError(
+        "coordination_input_invalid",
+        `Activity source envelope ${input.sourceEnvelopeId} already belongs to another canonical batch.`
+      );
+    }
     const incoming = projectTimelineEvents(input, receivedAt);
     for (const next of incoming) {
       const collision = live?.entries.find(
@@ -4039,6 +4587,46 @@ var InMemoryApprovalTimelineStore = class {
     this.#tails.set(key, tail);
     return tail;
   }
+  async resolvePending(tenant, input) {
+    const { capacity, ttlMs, event } = validateApprovalTimelineResolve(input);
+    const now = this.clock.now();
+    const receivedAt = now.toISOString();
+    const key = approvalTimelineKey(tenant, input.taskId);
+    const existing = this.#tails.get(key);
+    const live = existing !== void 0 && receivedAt < existing.expiresAt ? existing : void 0;
+    if (live === void 0) return { status: "absent" };
+    const duplicate = live.entries.find((entry) => entry.sourceEnvelopeId === input.sourceEnvelopeId);
+    if (duplicate !== void 0) {
+      if (JSON.stringify(duplicate.event) !== JSON.stringify(event)) return { status: "conflict", tail: live };
+      return { status: "replayed", tail: live };
+    }
+    const pending = pendingObservation(live.entries);
+    if (pending === void 0) return { status: "absent", tail: live };
+    if (pending.sourceEnvelopeId !== input.expectedSourceEnvelopeId || pending.revision !== input.expectedRevision) {
+      return { status: "superseded", tail: live };
+    }
+    const revision = (live.cursor ?? 0) + 1;
+    const observation = ApprovalObservationSchema.parse({
+      taskId: input.taskId,
+      sourceEnvelopeId: input.sourceEnvelopeId,
+      revision,
+      receivedAt,
+      event
+    });
+    const allEntries = [...live.entries, observation];
+    const evicted = Math.max(allEntries.length - capacity, 0);
+    const tail = {
+      tenantId: tenant,
+      taskId: input.taskId,
+      entries: allEntries.slice(evicted),
+      cursor: revision,
+      dropped: live.dropped + evicted,
+      capacity,
+      expiresAt: new Date(now.getTime() + ttlMs).toISOString()
+    };
+    this.#tails.set(key, tail);
+    return { status: "applied", tail };
+  }
   async read(tenant, taskId) {
     const key = approvalTimelineKey(tenant, taskId);
     const tail = this.#tails.get(key);
@@ -4050,6 +4638,19 @@ var InMemoryApprovalTimelineStore = class {
     return tail;
   }
 };
+function pendingObservation(entries) {
+  let pending;
+  for (const entry of entries) {
+    if (entry.event.type === "approval_requested") {
+      pending = entry;
+      continue;
+    }
+    if (pending !== void 0 && (pending.event.approvalId === void 0 || pending.event.approvalId === entry.event.approvalId)) {
+      pending = void 0;
+    }
+  }
+  return pending;
+}
 var InMemoryAgentEgressStore = class {
   #records = /* @__PURE__ */ new Map();
   #clock;
@@ -4057,7 +4658,10 @@ var InMemoryAgentEgressStore = class {
     this.#clock = clock;
   }
   async record(tenant, input) {
-    const key = tenantKey(tenant, `${input.deviceId}\0${input.payload.eventId}`);
+    const key = tenantKey(
+      tenant,
+      agentReliabilityKey("agent-egress", input.deviceId, input.payload.agentRef, input.payload.eventId)
+    );
     const existing = this.#records.get(key);
     if (existing !== void 0) return { record: existing, created: false };
     const record = {
@@ -4070,8 +4674,8 @@ var InMemoryAgentEgressStore = class {
     this.#records.set(key, record);
     return { record, created: true };
   }
-  async get(tenant, deviceId, eventId) {
-    return this.#records.get(tenantKey(tenant, `${deviceId}\0${eventId}`));
+  async get(tenant, deviceId, agentRef, eventId) {
+    return this.#records.get(tenantKey(tenant, agentReliabilityKey("agent-egress", deviceId, agentRef, eventId)));
   }
 };
 
@@ -4138,7 +4742,9 @@ function createInMemoryByokCloud(options = {}) {
     ...options.truthCommitter === void 0 ? {} : { truthCommitter: options.truthCommitter },
     ...options.truthObjectDownloads === void 0 ? {} : { truthObjectDownloads: options.truthObjectDownloads },
     ...options.operatorId !== void 0 ? { operatorId: options.operatorId } : {},
+    ...options.instanceProductId === void 0 ? {} : { instanceProductId: options.instanceProductId },
     ...options.agentMessage === void 0 ? {} : { agentMessage: options.agentMessage },
+    ...options.observer === void 0 ? {} : { observer: options.observer },
     ...options.agentMemoryProjectionAuthorizer === void 0 ? {} : { agentMemoryProjectionAuthorizer: options.agentMemoryProjectionAuthorizer },
     ...options.agentMemoryProjectionStore === void 0 ? {} : { agentMemoryProjectionStore: options.agentMemoryProjectionStore },
     ...options.maxBlobSizeBytes !== void 0 ? { maxBlobSizeBytes: options.maxBlobSizeBytes } : {},
@@ -4505,12 +5111,12 @@ function parseSseFrame(frame) {
 // src/stores/ports-contract.ts
 var CLOUD_PORT_METHODS = {
   activity: ["append", "read"],
-  approvals: ["append", "read"],
+  approvals: ["append", "read", "resolvePending"],
   devices: ["register", "get", "revoke", "list", "readiness", "recordCapabilities", "resolveByDeviceId"],
   pairingCodes: ["issue"],
   pairing: ["redeemAndRegister"],
   nonces: ["issue", "consumeIfValid"],
-  dedup: ["checkAndRecord"],
+  dedup: ["checkAndRecord", "checkAndRecordAgent"],
   tasks: [
     "open",
     "reserveAgentOffer",
@@ -4519,6 +5125,7 @@ var CLOUD_PORT_METHODS = {
     "finalizeAgentMessage",
     "get",
     "getMany",
+    "list",
     "claim",
     "recordStatus"
   ],
@@ -4549,6 +5156,6 @@ var CLOUD_PORT_INTERFACES = {
   rateLimiter: "InboundRateLimiter"
 };
 
-export { ACCESS_TOKEN_TTL_SECONDS, AGENT_HOME_CONTRACT_CAPABILITY, APPROVAL_SUMMARY_MAX_BYTES, ActivityAppendRequestSchema, AllowAllRateLimiter, ApprovalObservationSchema, ApprovalTimelineEventSchema, BLOB_READ_ERROR_CODES, BLOB_URL_TTL_MS, BoardFeedClient, BoardFeedRetryableError, BoardFeedStoppedError, ByokCloudError, CLOUD_CAPABILITIES, CLOUD_ERROR_CODES, CLOUD_PORT_INTERFACES, CLOUD_PORT_METHODS, CLOUD_STORE_NAMES, CapabilitiesResponseSchema, CloudRouteRegistry, DEDUP_RING_CAPACITY, DEFAULT_ACTIVITY_BOUNDS, DEFAULT_ACTIVITY_CAPACITY, DEFAULT_ACTIVITY_MAX_BYTES, DEFAULT_ACTIVITY_MAX_EVENTS, DEFAULT_ACTIVITY_TTL_MS, DEFAULT_APPROVAL_TIMELINE_CAPACITY, DEFAULT_APPROVAL_TIMELINE_TTL_MS, DEFAULT_BOARD_CHANNEL_MAX_BYTES, DEFAULT_BOARD_PAGE_LIMIT, DEFAULT_BOARD_STREAM_HEARTBEAT_INTERVAL_MS, DEFAULT_BOARD_STREAM_QUERY_INTERVAL_MS, DEFAULT_BOARD_STREAM_RECONCILIATION_INTERVAL_MS, DEFAULT_BOARD_TITLE_MAX_BYTES, DEFAULT_DEVICE_PROOF_CLOCK_SKEW_MS, DEFAULT_DEVICE_PROOF_MAX_LIFETIME_MS, DEFAULT_EVENTS_PAGE_LIMIT, DEFAULT_LONG_POLL_HOLD_MS, DEFAULT_LONG_POLL_INTERVAL_MS, DEFAULT_MAX_BLOB_SIZE_BYTES, DEFAULT_MAX_TRUTH_REQUEST_BYTES, DEFAULT_PRESENCE_DETAIL_MAX_BYTES, DEFAULT_PRESENCE_MINIMUM_INTERVAL_MS, DEFAULT_PRESENCE_TTL_MS, DEFAULT_SKILL_PACK_PAGE_LIMIT, DEVICE_IDENTITY_PROOF_KEY_EPOCH, DEVICE_IDENTITY_PROOF_KEY_ID, InMemoryActivityStore, InMemoryAgentEgressStore, InMemoryAgentMemoryProjectionAuthorizer, InMemoryAgentMemoryProjectionStore, InMemoryBlobContentProxy, InMemoryCloudBlobStore, InMemoryDeviceDirectory, InMemoryInboundDedupStore, InMemoryNonceStore, InMemoryPairingCodeStore, InMemoryProofRequestReceiptStore, InMemoryRequestReceiptStore, InMemoryTaskAttemptStore, InMemoryTaskCancellationStore, MAX_DEVICE_PROOF_CLOCK_SKEW_MS, MAX_DEVICE_PROOF_HEADER_BYTES, MAX_DEVICE_PROOF_MAX_LIFETIME_MS, NONCE_TTL_MS, PAIRING_CODE_TTL_MS, ROUTE_CLASSES, ROUTE_METHODS, TASK_ATTEMPT_STATUSES, TRUTH_BATCH_MAX_RECORDS, TRUTH_INLINE_CONTENT_TYPE, TRUTH_LABEL_MAX_LENGTH, TRUTH_MANIFEST_MAX_LIMIT, TRUTH_RECORD_CAPABILITY, TRUTH_RECORD_KEY_MAX_LENGTH, TRUTH_REQUEST_ID_MAX_LENGTH, TimelineEventSchema, TruthBodyInputSchema, TruthCommitError, TruthCommitResponseSchema, TruthRecordKeySchema, TruthRecordMetadataSchema, TruthWriteRequestSchema, activityCursor, agentHomeProjectionCompletionKey, agentHomeProjectionRequestKey, approvalTimelineCursor, authenticateBearer, authenticateDeviceProof, authenticateHostedDeviceAssertion, createAuthPlane, createByokCloud, createHmacTokenSigner, createInMemoryBlobs, createInMemoryByokCloud, createInMemoryCloudStores, createWebCrypto, declares, extractBearerToken, fullCapabilityDeclaration, handleInboundEnvelope, isCloudError, isTruthCommitError, parseApprovalObservations, parseTimelineEvents, projectTerminalResult, projectTimelineEvents, readAgentHomeProjectionStatus, recordAgentHomeProjectionCompletion, routeKey, tenantStoresFor, terminalReceiptKey, truthManifestMetadata, truthRecordMetadata, validateActivityAppend, validateApprovalTimelineAppend, verifyNonceSignature };
+export { ACCESS_TOKEN_TTL_SECONDS, AGENT_HOME_CONTRACT_CAPABILITY, APPROVAL_SUMMARY_MAX_BYTES, ActivityAppendRequestSchema, AllowAllRateLimiter, ApprovalObservationSchema, ApprovalTimelineEventSchema, BLOB_READ_ERROR_CODES, BLOB_URL_TTL_MS, BoardFeedClient, BoardFeedRetryableError, BoardFeedStoppedError, ByokCloudError, CLOUD_CAPABILITIES, CLOUD_ERROR_CODES, CLOUD_PORT_INTERFACES, CLOUD_PORT_METHODS, CLOUD_STORE_NAMES, CapabilitiesResponseSchema, CloudRouteRegistry, DEDUP_RING_CAPACITY, DEFAULT_ACTIVITY_BOUNDS, DEFAULT_ACTIVITY_CAPACITY, DEFAULT_ACTIVITY_MAX_BYTES, DEFAULT_ACTIVITY_MAX_EVENTS, DEFAULT_ACTIVITY_TTL_MS, DEFAULT_APPROVAL_TIMELINE_CAPACITY, DEFAULT_APPROVAL_TIMELINE_TTL_MS, DEFAULT_BOARD_CHANNEL_MAX_BYTES, DEFAULT_BOARD_PAGE_LIMIT, DEFAULT_BOARD_STREAM_HEARTBEAT_INTERVAL_MS, DEFAULT_BOARD_STREAM_QUERY_INTERVAL_MS, DEFAULT_BOARD_STREAM_RECONCILIATION_INTERVAL_MS, DEFAULT_BOARD_TITLE_MAX_BYTES, DEFAULT_DEVICE_PROOF_CLOCK_SKEW_MS, DEFAULT_DEVICE_PROOF_MAX_LIFETIME_MS, DEFAULT_EVENTS_PAGE_LIMIT, DEFAULT_LONG_POLL_HOLD_MS, DEFAULT_LONG_POLL_INTERVAL_MS, DEFAULT_MAX_BLOB_SIZE_BYTES, DEFAULT_MAX_TRUTH_REQUEST_BYTES, DEFAULT_PRESENCE_DETAIL_MAX_BYTES, DEFAULT_PRESENCE_MINIMUM_INTERVAL_MS, DEFAULT_PRESENCE_TTL_MS, DEFAULT_SKILL_PACK_PAGE_LIMIT, DEVICE_IDENTITY_PROOF_KEY_EPOCH, DEVICE_IDENTITY_PROOF_KEY_ID, InMemoryActivityStore, InMemoryAgentEgressStore, InMemoryAgentMemoryProjectionAuthorizer, InMemoryAgentMemoryProjectionStore, InMemoryBlobContentProxy, InMemoryCloudBlobStore, InMemoryDeviceDirectory, InMemoryInboundDedupStore, InMemoryNonceStore, InMemoryPairingCodeStore, InMemoryProofRequestReceiptStore, InMemoryRequestReceiptStore, InMemoryTaskAttemptStore, InMemoryTaskCancellationStore, MAX_DEVICE_PROOF_CLOCK_SKEW_MS, MAX_DEVICE_PROOF_HEADER_BYTES, MAX_DEVICE_PROOF_MAX_LIFETIME_MS, NONCE_TTL_MS, PAIRING_CODE_TTL_MS, ROUTE_CLASSES, ROUTE_METHODS, StaleApprovalError, SteerRejectedError, TASK_ATTEMPT_STATUSES, TRUTH_BATCH_MAX_RECORDS, TRUTH_INLINE_CONTENT_TYPE, TRUTH_LABEL_MAX_LENGTH, TRUTH_MANIFEST_MAX_LIMIT, TRUTH_RECORD_CAPABILITY, TRUTH_RECORD_KEY_MAX_LENGTH, TRUTH_REQUEST_ID_MAX_LENGTH, TimelineEventSchema, TruthBodyInputSchema, TruthCommitError, TruthCommitResponseSchema, TruthRecordKeySchema, TruthRecordMetadataSchema, TruthWriteRequestSchema, activityCursor, activitySourceBatchState, agentHomeProjectionCompletionKey, agentHomeProjectionRequestKey, approvalTimelineCursor, assertTaskAttemptListLimit, authenticateBearer, authenticateDeviceProof, authenticateHostedDeviceAssertion, createAuthPlane, createByokCloud, createHmacTokenSigner, createInMemoryBlobs, createInMemoryByokCloud, createInMemoryCloudStores, createWebCrypto, declares, extractBearerToken, fullCapabilityDeclaration, handleInboundEnvelope, isCloudError, isTruthCommitError, parseApprovalObservations, parseTimelineEvents, pendingApproval, projectTerminalResult, projectTimelineEvents, readAgentHomeProjectionStatus, recordAgentHomeProjectionCompletion, routeKey, tenantStoresFor, terminalReceiptKey, truthManifestMetadata, truthRecordMetadata, validateActivityAppend, validateApprovalTimelineAppend, validateApprovalTimelineResolve, verifyNonceSignature };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map