@canonmsg/agent-sdk 13.1.0 → 13.2.1

package/dist/chunks/{chunk-ZPBOGOAD.js → chunk-HTLKCUQG.js}

@@ -5,7 +5,7 @@ import {
   createHttpEndpointTransport,
   createNodeEndpointStore,
   validateEndpointContentBoundary
-} from "./chunk-YJUPKU47.js";
+} from "./chunk-BPSFHEAA.js";
 import {
   CANON_ENDPOINT_PROTOCOL,
   CANON_VERB_WIRE_SCHEMA_VERSION,
@@ -40,8 +40,6 @@ import {
   isMlsDevTextProtocol,
   isMlsEnvironmentId,
   isMlsPrincipalAlias,
-  logicalMediaBlobId,
-  mergeDeliveryObservation,
   mlsAdmissionWait,
   mlsDevProtocolCarriesCards,
   normalizePublicRuntimeDescriptor,
@@ -102,18 +100,17 @@ import {
   parseMlsPrincipalOpening,
   parseMlsRoomIdentities,
   prepareJsonContent,
-  projectDeliveryStatus,
   projectVerbIntentToWire,
   readMembershipChangeMetadata,
   resolveAllowedUploadMimeType,
   sanitizeDownloadFileName
-} from "./chunk-5WPAB5MB.js";
+} from "./chunk-VIS5WXNH.js";
 
 // src/media.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { mkdir as mkdir2, open as open2, rename as rename2, stat as stat2, unlink as unlink2 } from "node:fs/promises";
-import { basename, dirname as dirname2, extname, join as join5 } from "node:path";
+import { basename, dirname as dirname2, extname, join as join4 } from "node:path";
 import { Readable, Transform as Transform2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 
@@ -154,11 +151,11 @@ function createNodeEndpointMediaBytes(options) {
   __name(digest, "digest");
   return {
     digest,
-    async retain(key, source) {
+    async retain(key2, source) {
       await initialized;
       const expected = expectedDigests.get(source);
       if (!expected) throw new Error("Canon media must be fingerprinted before retaining bytes");
-      const reference = `${createHash("sha256").update(key).digest("hex")}.bytes`;
+      const reference = `${createHash("sha256").update(key2).digest("hex")}.bytes`;
       const destination = referencePath(reference);
       const temporary = `${destination}.${randomUUID()}.tmp`;
       const sourceHandle = await open(source, "r");
@@ -522,8 +519,8 @@ async function readPreparationSnapshot(tx, scope5) {
 __name(readPreparationSnapshot, "readPreparationSnapshot");
 function assertPreparationAdmission(expected, current) {
   if (!expected || !current.admission) return;
-  for (const key of ["conversationId", "membershipRevision", "admissionId"]) {
-    if (expected[key] !== void 0 && current.admission[key] !== void 0 && expected[key] !== current.admission[key]) {
+  for (const key2 of ["conversationId", "membershipRevision", "admissionId"]) {
+    if (expected[key2] !== void 0 && current.admission[key2] !== void 0 && expected[key2] !== current.admission[key2]) {
       throw new EndpointError("The authored admission changed before content could commit", { code: "PREPARATION_ADMISSION_CHANGED", retryable: false });
     }
   }
@@ -535,12 +532,12 @@ function assertGeneration(current, expected) {
 __name(assertGeneration, "assertGeneration");
 async function reservePreparedIdentityInTransaction(tx, input) {
   assertGeneration(await tx.get(PREPARATION_GENERATION_KEY) ?? 0, input.installationGeneration);
-  const key = `preparation/${input.operationId}`;
-  const existing = await tx.get(key);
+  const key2 = `preparation/${input.operationId}`;
+  const existing = await tx.get(key2);
   if (existing && (existing.action !== input.action || existing.fingerprint !== input.fingerprint || existing.installationGeneration !== input.installationGeneration)) {
     throw new EndpointError("Operation ID was already reserved for different content", { status: 409, code: "OPERATION_ID_COLLISION", retryable: false, operationId: input.operationId });
   }
-  if (!existing) await tx.put(key, input);
+  if (!existing) await tx.put(key2, input);
 }
 __name(reservePreparedIdentityInTransaction, "reservePreparedIdentityInTransaction");
 async function reservePreparedIdentity(store, input) {
@@ -587,7 +584,6 @@ function endpointIntentOrdering(intent2) {
   const body = { ...intent2.body, ...intent2.envelope };
   if (intent2.action === "consume_runtime_signal") return "independent";
   if (intent2.action === "generate_image") return "provider";
-  if (["append_artifact_command", "retain_artifact_asset"].includes(intent2.action) && typeof body.artifactId === "string") return "artifact";
   if (intent2.action === "session_control" && !body.primitive && typeof body.agentId === "string") {
     const type = body.signal?.type;
     if (type === "interrupt" || type === "stop_and_drop") return "signal";
@@ -597,10 +593,10 @@ function endpointIntentOrdering(intent2) {
 }
 __name(endpointIntentOrdering, "endpointIntentOrdering");
 async function nextQueueSequence(tx, name) {
-  const key = `queue-sequence/${name}`;
-  const next = (await tx.get(key) ?? 0) + 1;
+  const key2 = `queue-sequence/${name}`;
+  const next = (await tx.get(key2) ?? 0) + 1;
   if (!Number.isSafeInteger(next)) throw new Error("Endpoint queue sequence exhausted");
-  await tx.put(key, next);
+  await tx.put(key2, next);
   return next;
 }
 __name(nextQueueSequence, "nextQueueSequence");
@@ -609,19 +605,17 @@ async function orderOperation(tx, operation) {
 }
 __name(orderOperation, "orderOperation");
 var outboxKey = /* @__PURE__ */ __name((operation) => operation.queueOrder === void 0 ? `outbox/${operation.operationId}` : `outbox/${ordinal(operation.queueOrder)}/${operation.operationId}`, "outboxKey");
-var artifactOrderingPrefix = /* @__PURE__ */ __name((conversationId, artifactId) => `outbound-artifact-order/${scope(conversationId)}/${scope(artifactId)}/`, "artifactOrderingPrefix");
 var controlOrderingKey = /* @__PURE__ */ __name((operation) => operation.action === "session_control" && operation.conversationId && operation.agentId ? `outbound-control-order/${scope(operation.conversationId)}/${scope(operation.agentId)}/` : void 0, "controlOrderingKey");
 var operationOrderingKey = /* @__PURE__ */ __name((operation) => {
   if (!operation.conversationId || operation.ordering === "independent" || operation.ordering === "provider") return void 0;
   if (operation.ordering === "signal") return controlOrderingKey(operation);
-  if (operation.ordering === "artifact") return artifactOrderingPrefix(operation.conversationId, operation.artifactId ?? "~");
   return operation.ordering === "message" ? `outbound-ack-order/${scope(operation.conversationId)}/${scope(operation.messageId)}/` : `outbound-order/${scope(operation.conversationId)}/`;
 }, "operationOrderingKey");
 var outboundPrefix = /* @__PURE__ */ __name((operation) => operationOrderingKey(operation), "outboundPrefix");
 var outboundKeys = /* @__PURE__ */ __name((operation) => [.../* @__PURE__ */ new Set([operationOrderingKey(operation), controlOrderingKey(operation)])].filter((prefix3) => Boolean(prefix3)).map((prefix3) => `${prefix3}${ordinal(operation.queueOrder)}/${operation.operationId}`), "outboundKeys");
 async function trackOperationOrder(tx, operation) {
   if (operation.queueOrder !== void 0 && !["succeeded", "rejected"].includes(operation.status)) {
-    for (const key of outboundKeys(operation)) await tx.put(key, { operationId: operation.operationId });
+    for (const key2 of outboundKeys(operation)) await tx.put(key2, { operationId: operation.operationId });
   }
 }
 __name(trackOperationOrder, "trackOperationOrder");
@@ -634,7 +628,7 @@ async function removeOperationOutbox(tx, operation) {
 }
 __name(removeOperationOutbox, "removeOperationOutbox");
 async function settleOperationOrder(tx, operation) {
-  if (operation.queueOrder !== void 0) for (const key of outboundKeys(operation)) await tx.delete(key);
+  if (operation.queueOrder !== void 0) for (const key2 of outboundKeys(operation)) await tx.delete(key2);
 }
 __name(settleOperationOrder, "settleOperationOrder");
 async function isFirstOrderedOperation(tx, operation) {
@@ -913,9 +907,9 @@ async function compactExpiredPayloads(store, clock) {
       const rows = await tx.scan("payload-expiry/", { limit: 100 });
       const expired = rows.filter((row) => row.value.expiresAt <= clock);
       for (const row of expired) {
-        const key = `operation/${row.value.operationId}`;
-        const value = await tx.get(key);
-        if (value && ["succeeded", "rejected", "uncertain"].includes(value.status)) await tx.put(key, compactOperation(value));
+        const key2 = `operation/${row.value.operationId}`;
+        const value = await tx.get(key2);
+        if (value && ["succeeded", "rejected", "uncertain"].includes(value.status)) await tx.put(key2, compactOperation(value));
         await tx.delete(row.key);
       }
       return expired.length;
@@ -958,7 +952,7 @@ async function eraseEndpointPlaintext(store) {
       after = rows[rows.length - 1].key;
     }
   }
-  for (const prefix3 of ["preparation/", "protocol-state/", "mls-principal", "mls-dev-device/", "mls-dev-key-package/", "mls-dev-group/", "deferred-opener/", "artifact-v2/", "artifact/", "artifact-intent/", "artifact-admission/", "artifact-key/", "conversation/", "inbound-ready/", "outbox/", "payload-expiry/", "media-flow/", "media-visible/", "media-pending/", "media-lease/", "media-prepared-upload/"]) {
+  for (const prefix3 of ["completion/", "preparation/", "protocol-state/", "mls-principal", "mls-dev-device/", "mls-dev-key-package/", "mls-dev-group/", "deferred-opener/", "artifact-v2/", "artifact/", "artifact-intent/", "artifact-admission/", "artifact-key/", "conversation/", "inbound-ready/", "outbox/", "payload-expiry/", "media-flow/", "media-visible/", "media-pending/", "media-lease/", "media-prepared-upload/"]) {
     for (; ; ) {
       const count = await store.transaction(async (tx) => {
         const rows = await tx.scan(prefix3, { limit: 100 });
@@ -1052,11 +1046,11 @@ function createEndpointQueryObserver(options) {
   return {
     observe(query, parameters, listener, onError) {
       if (closed) throw new Error("Endpoint query observer is closed");
-      const key = canonicalEndpointJson({ query, parameters });
-      let entry = entries2.get(key);
+      const key2 = canonicalEndpointJson({ query, parameters });
+      let entry = entries2.get(key2);
       if (!entry) {
         entry = { query, parameters, listeners: /* @__PURE__ */ new Set(), running: false, dirty: false, hasValue: false, hadError: false, retryAttempts: 0 };
-        entries2.set(key, entry);
+        entries2.set(key2, entry);
       }
       const observer = { value: listener, error: onError };
       entry.listeners.add(observer);
@@ -1068,7 +1062,7 @@ function createEndpointQueryObserver(options) {
         ownedEntry.listeners.delete(observer);
         if (ownedEntry.listeners.size === 0) {
           if (ownedEntry.timer) clearTimeout(ownedEntry.timer);
-          entries2.delete(key);
+          entries2.delete(key2);
         }
       };
     },
@@ -1106,42 +1100,18 @@ var ROOM_QUERIES = /* @__PURE__ */ new Set([
   "list_voice_sessions",
   "get_voice_session"
 ]);
-var ARTIFACT_QUERIES = /* @__PURE__ */ new Set(["list_artifacts", "get_artifact_log", "get_artifact_asset"]);
 var INBOX_QUERIES = /* @__PURE__ */ new Set(["list_conversations", "get_unread_summary"]);
 var CONTACT_QUERIES = /* @__PURE__ */ new Set(["list_contacts", "get_contact", "list_contact_requests"]);
 var ROOM_OPERATIONS = /* @__PURE__ */ new Set(["send_message", "mls_application", "mls_group_control", "react", "delete_message", "mark_read"]);
-var ARTIFACT_OPERATIONS = /* @__PURE__ */ new Set(["append_artifact_command", "retain_artifact_asset"]);
 function queryAffectedByOperation(operation, query, parameters) {
-  if (ARTIFACT_OPERATIONS.has(operation.action)) {
-    if (operation.status !== "succeeded" || !ARTIFACT_QUERIES.has(query)) return false;
-    return typeof parameters.conversationId !== "string" || !operation.conversationId || parameters.conversationId === operation.conversationId;
-  }
-  if (ARTIFACT_QUERIES.has(query)) return false;
   if (!ROOM_OPERATIONS.has(operation.action)) return true;
   if (operation.status !== "succeeded" && !(operation.action === "mls_application" && ["rejected", "uncertain"].includes(operation.status))) return false;
   return queryAffectedByEvent({ kind: "conversation.changed", data: { conversationId: operation.conversationId } }, query, parameters);
 }
 __name(queryAffectedByOperation, "queryAffectedByOperation");
-function artifactQueryAffected(event, query, parameters) {
-  const conversationId = parameters.conversationId;
-  const sameRoom = typeof conversationId !== "string" || typeof event.data.conversationId !== "string" || event.data.conversationId === conversationId;
-  if (event.kind === "artifact.changed") {
-    if (!sameRoom) return false;
-    return query === "list_artifacts" || typeof parameters.artifactId !== "string" || typeof event.data.artifactId !== "string" || parameters.artifactId === event.data.artifactId;
-  }
-  if (event.kind === "conversation.removed") return sameRoom;
-  if (event.kind === "conversations.changed") {
-    const removed = event.data.removedConversationIds;
-    return Array.isArray(removed) && (typeof conversationId !== "string" || removed.includes(conversationId));
-  }
-  return false;
-}
-__name(artifactQueryAffected, "artifactQueryAffected");
 function queryAffectedByEvent(event, query, parameters) {
-  if (!ROOM_QUERIES.has(query) && !ARTIFACT_QUERIES.has(query) && !INBOX_QUERIES.has(query) && !CONTACT_QUERIES.has(query)) return true;
+  if (!ROOM_QUERIES.has(query) && !INBOX_QUERIES.has(query) && !CONTACT_QUERIES.has(query)) return true;
   if (event.kind === "agent.context" || event.kind.startsWith("replay.")) return true;
-  if (ARTIFACT_QUERIES.has(query)) return artifactQueryAffected(event, query, parameters);
-  if (event.kind === "artifact.changed") return false;
   if (/^contacts?\./.test(event.kind)) return CONTACT_QUERIES.has(query);
   if (!/^(message\.|conversations?\.|voice\.session\.)/.test(event.kind)) return true;
   if (CONTACT_QUERIES.has(query)) return false;
@@ -1172,10 +1142,10 @@ async function prepareEndpointIntent(input) {
   const { intent: intent2 } = input;
   const nested = intent2.action === "verb_execute";
   const action = nested ? intent2.body.verb : intent2.action;
-  if (!["remove_member", "update_member_role", "leave_conversation", "append_artifact_command", "retain_artifact_asset"].includes(String(action))) return intent2;
+  if (!["remove_member", "update_member_role", "leave_conversation"].includes(String(action))) return intent2;
   const body = intentBody(intent2);
   const conversationId = body.conversationId ?? body.targetConversationId;
-  const ownAdmission = ["leave_conversation", "append_artifact_command", "retain_artifact_asset"].includes(String(action));
+  const ownAdmission = action === "leave_conversation";
   const targetUserId = body.targetUserId ?? body.userId ?? body.agentId;
   if (typeof conversationId !== "string" || !ownAdmission && typeof targetUserId !== "string") {
     throw new EndpointError("Membership control requires a conversation and target", { status: 400, code: "INVALID_MEMBERSHIP_CONTROL", retryable: false });
@@ -1224,7 +1194,7 @@ async function assertMlsDevPlaintextAllowed(tx, intent2, lane = "operation.reque
   const privateLeaf = /* @__PURE__ */ __name((value, path) => {
     if (value && typeof value === "object") {
       const entries2 = Object.entries(value);
-      if (entries2.length) return entries2.some(([key, child]) => privateLeaf(child, [...path, key]));
+      if (entries2.length) return entries2.some(([key2, child]) => privateLeaf(child, [...path, key2]));
     }
     return boundary.classify(path) !== "public-metadata";
   }, "privateLeaf");
@@ -1263,8 +1233,8 @@ function normalizeInboundDeletion(event) {
 __name(normalizeInboundDeletion, "normalizeInboundDeletion");
 async function recordInboundEvent(tx, incoming, timestamp) {
   const event = normalizeInboundDeletion(incoming);
-  const key = `inbound/${event.id}`;
-  const existing = await tx.get(key);
+  const key2 = `inbound/${event.id}`;
+  const existing = await tx.get(key2);
   if (event.conversationId && ["message.created", "message.snapshot", "message.updated"].includes(event.kind) && await isMlsDevRoomProtected(tx, event.conversationId)) {
     if (existing) return false;
     const raw = event.kind === "message.snapshot" ? event.data : event.data.message;
@@ -1278,7 +1248,7 @@ async function recordInboundEvent(tx, incoming, timestamp) {
       durable: true,
       data: notice ? { id: message.id, metadata, text: formatMembershipChangeNotice(metadata), contentType: "text" } : {}
     };
-    await tx.put(key, {
+    await tx.put(key2, {
       event: sanitized,
       state: "settled",
       reason: notice ? "membership_control" : "mls_plaintext_withheld",
@@ -1312,12 +1282,12 @@ async function recordInboundEvent(tx, incoming, timestamp) {
     };
     delete next.lease;
     if (existing) await removeInboundReady(tx, existing);
-    await tx.put(key, next);
+    await tx.put(key2, next);
     return true;
   }
   if (existing) return false;
   const record6 = await orderInbound(tx, { event: copyJson(event), state: "observed", createdAt: timestamp, updatedAt: timestamp });
-  await tx.put(key, record6);
+  await tx.put(key2, record6);
   await enqueueInbound(tx, record6);
   return true;
 }
@@ -1340,14 +1310,14 @@ function serializeInboundPreparation(store, scope5, prepare) {
 }
 __name(serializeInboundPreparation, "serializeInboundPreparation");
 async function recordMlsInteractionProjection(tx, event, timestamp) {
-  const key = `inbound/${event.id}`, existing = await tx.get(key);
+  const key2 = `inbound/${event.id}`, existing = await tx.get(key2);
   if (existing && existing.reason !== "mls_plaintext_withheld") return;
-  await tx.put(key, { event: copyJson(event), state: "settled", reason: "mls_interaction", createdAt: timestamp, updatedAt: timestamp });
+  await tx.put(key2, { event: copyJson(event), state: "settled", reason: "mls_interaction", createdAt: timestamp, updatedAt: timestamp });
 }
 __name(recordMlsInteractionProjection, "recordMlsInteractionProjection");
 async function recordVerifiedMlsInboundEvent(tx, event, feedOrdinal, timestamp, own = false) {
   if (!event.conversationId || !Number.isSafeInteger(feedOrdinal) || feedOrdinal < 1) throw new Error("Invalid verified MLS input");
-  const key = `inbound/${event.id}`, existing = await tx.get(key);
+  const key2 = `inbound/${event.id}`, existing = await tx.get(key2);
   if (existing && existing.reason !== "mls_plaintext_withheld") return false;
   const record6 = {
     event: copyJson(event),
@@ -1356,7 +1326,7 @@ async function recordVerifiedMlsInboundEvent(tx, event, feedOrdinal, timestamp,
     createdAt: timestamp,
     updatedAt: timestamp
   };
-  await tx.put(key, record6);
+  await tx.put(key2, record6);
   if (!own) await enqueueInbound(tx, record6);
   return true;
 }
@@ -1563,8 +1533,8 @@ function createConversationSynchronizer(input) {
       if (protocolPage) return protocolPage;
       const protectedMode = await input.prepareProtocol?.(conversationId) ?? false;
       assertOpen();
-      const key = `cursor/${conversationId}`;
-      const before = await input.store.transaction((tx) => tx.get(key));
+      const key2 = `cursor/${conversationId}`;
+      const before = await input.store.transaction((tx) => tx.get(key2));
       const resuming = before?.paused !== void 0 && options.resumeAdmissionChange === "checkpoint";
       if (before?.paused && !resuming) throw new EndpointError("Conversation admission changed; pickup is paused until an explicit new checkpoint is chosen", { code: "SYNC_ADMISSION_PAUSED", retryable: false });
       if (!before && !options.bootstrap) throw new EndpointError("Choose a reconciled history baseline before receiving conversation work", { code: "SYNC_BASELINE_REQUIRED", retryable: false });
@@ -1608,11 +1578,11 @@ function createConversationSynchronizer(input) {
         commit: /* @__PURE__ */ __name(async (tx, preparedChanges) => {
           assertOpen();
           if (await tx.get("migration/active")) throw new EndpointError("Migration started during synchronization", { code: "MIGRATION_IN_PROGRESS", retryable: false });
-          const current = await tx.get(key);
+          const current = await tx.get(key2);
           if (canonicalEndpointJson(current ?? null) !== canonicalEndpointJson(before ?? null)) return false;
           if (page.reset) {
-            if (options.pauseOnAdmissionChange) await tx.put(key, { ...before ?? { cursor: null, admissionId: null, mode, bootstrapping: false }, paused: { admissionId: page.admissionId } });
-            else await tx.delete(key);
+            if (options.pauseOnAdmissionChange) await tx.put(key2, { ...before ?? { cursor: null, admissionId: null, mode, bootstrapping: false }, paused: { admissionId: page.admissionId } });
+            else await tx.delete(key2);
             return true;
           }
           for (const event of preparedChanges) {
@@ -1620,7 +1590,7 @@ function createConversationSynchronizer(input) {
             if (mode === "checkpoint") continue;
             await recordInboundEvent(tx, event, new Date(input.clock()).toISOString());
           }
-          await tx.put(key, { cursor: page.cursor, admissionId: page.admissionId, bootstrapping: page.bootstrap && page.hasMore, mode });
+          await tx.put(key2, { cursor: page.cursor, admissionId: page.admissionId, bootstrapping: page.bootstrap && page.hasMore, mode });
           return true;
         }, "commit")
       }));
@@ -2035,7 +2005,7 @@ __name(createEndpointMigration, "createEndpointMigration");
 
 // ../endpoint/src/media.ts
 function createEndpointMediaPipeline(options) {
-  const { endpoint, store, bytes, background } = options;
+  const { endpoint, store, bytes } = options;
   const clock = options.clock ?? Date.now;
   const ids = options.ids ?? (() => crypto.randomUUID());
   const leaseMs = Math.max(1e3, options.leaseMs ?? 3e4);
@@ -2090,14 +2060,6 @@ function createEndpointMediaPipeline(options) {
   const listeners = /* @__PURE__ */ new Set();
   let closed = false;
   let foreground = true;
-  let restoredNativeObservations = false;
-  const reconciliation = /* @__PURE__ */ new Map();
-  const observations = /* @__PURE__ */ new Map();
-  let backgroundCapability;
-  let lastServerBackgroundCapability;
-  let serverPreparedContentVersion;
-  const preparationGeneration = background ? endpoint.ready().then(() => readPreparationGeneration(store)) : Promise.resolve(0);
-  void preparationGeneration.catch(() => void 0);
   let timer;
   const prefix3 = "media-flow/";
   const attachmentFor = /* @__PURE__ */ __name((file, value, resultUploadId) => {
@@ -2117,7 +2079,6 @@ function createEndpointMediaPipeline(options) {
       for (const file of previous?.files ?? []) if (file.uploadId && !currentIds.has(file.uploadId)) await tx.delete(`media-prepared-upload/${file.uploadId}`);
       for (const uploadId of currentIds) await tx.put(`media-prepared-upload/${uploadId}`, { id: flow.id });
     }
-    if (flow.status === "succeeded" || flow.status === "cancelled") delete flow.preparedContent;
     await tx.put(`${prefix3}${flow.id}`, flow);
     if (flow.status === "pending" || flow.status === "sending") await tx.put(`media-pending/${flow.id}`, { id: flow.id });
     else await tx.delete(`media-pending/${flow.id}`);
@@ -2158,10 +2119,6 @@ function createEndpointMediaPipeline(options) {
     timer.unref?.();
   }
   __name(schedule, "schedule");
-  const stopConnections = background ? endpoint.observeEvents?.(() => void 0, { families: ["messages"], onConnected: /* @__PURE__ */ __name(() => {
-    for (const state of reconciliation.values()) state.nextAt = Math.min(state.nextAt, clock() + 5e3);
-    schedule();
-  }, "onConnected") }) : void 0;
   const unsubscribe = endpoint.subscribe((operation) => {
     if (operation.status === "succeeded" && operation.action.endsWith("_upload")) schedule();
   });
@@ -2170,265 +2127,21 @@ function createEndpointMediaPipeline(options) {
     await Promise.allSettled(flow.files.filter((file) => file.reference).map((file) => bytes.release(file.reference)));
   }
   __name(release, "release");
-  function probeBackgroundCapability() {
-    if (!background) return Promise.resolve(false);
-    if (!backgroundCapability) {
-      const check = Promise.resolve().then(() => Promise.all([background.available(), endpoint.capabilities()])).then(([nativeAvailable, capabilities]) => {
-        if (capabilities) serverPreparedContentVersion = capabilities.preparedMediaContentVersion;
-        if (capabilities) lastServerBackgroundCapability = capabilities.actions.includes("stage_media_message") && (background.observationVersion !== 2 || capabilities.mediaDeliveryObservationVersion === 2);
-        return nativeAvailable && lastServerBackgroundCapability === true;
-      }).catch(() => false).then((enabled) => {
-        if (!enabled && backgroundCapability === check) backgroundCapability = void 0;
-        return enabled;
-      });
-      backgroundCapability = check;
-    }
-    return backgroundCapability;
-  }
-  __name(probeBackgroundCapability, "probeBackgroundCapability");
   const encryptedRoom = /* @__PURE__ */ __name(async (conversationId) => await endpoint.getConversationContentMode(conversationId) !== "plaintext", "encryptedRoom");
-  async function canSendInBackground(options2) {
-    if (!background) return false;
-    if (options2?.conversationId !== void 0 && await encryptedRoom(options2.conversationId).catch(() => true)) return false;
-    if (options2?.maxProbeWaitMs === void 0) return probeBackgroundCapability();
-    const nativeAvailable = await Promise.resolve().then(() => background.available()).catch(() => false);
-    if (!nativeAvailable) return false;
-    if (lastServerBackgroundCapability === false) {
-      void probeBackgroundCapability();
-      return false;
-    }
-    const check = probeBackgroundCapability();
-    const waitMs = Math.max(0, options2.maxProbeWaitMs);
-    if (waitMs === 0) return false;
-    return new Promise((resolve3) => {
-      const timer2 = setTimeout(() => resolve3(false), waitMs);
-      void check.then((enabled) => {
-        clearTimeout(timer2);
-        resolve3(enabled);
-      });
-    });
-  }
-  __name(canSendInBackground, "canSendInBackground");
-  async function applyBackgroundSnapshot(snapshot) {
-    if (closed || !background) return;
-    const flow = await read(snapshot.deliveryId);
-    if (!flow || flow.deliveryMode !== "background") return;
-    if (snapshot.schemaVersion === 2) {
-      const identity = await endpoint.ready();
-      if (!snapshot.identity || snapshot.identity.installationId !== identity.installationId || snapshot.identity.environmentId !== identity.environmentId || snapshot.identity.conversationId !== flow.conversationId || snapshot.identity.messageId !== flow.messageId) {
-        schedule();
-        return;
-      }
-    }
-    const owner = await acquire(flow.id).catch(() => null);
-    if (!owner) {
-      schedule();
-      return;
-    }
-    try {
-      const current = await read(flow.id);
-      if (!current || current.deliveryMode !== "background" || current.status === "succeeded" || current.status === "cancelled") return;
-      if (snapshot.schemaVersion === 2) {
-        const identity = await endpoint.ready();
-        if (snapshot.observation) current.observation = mergeDeliveryObservation(current.observation, snapshot.observation, {
-          deliveryId: flow.id,
-          conversationId: flow.conversationId,
-          messageId: flow.messageId,
-          installationId: identity.installationId,
-          environmentId: identity.environmentId
-        });
-        current.attention = snapshot.attention;
-        const phase = ["published", "cancelled", "expired", "rejected"].includes(snapshot.status) ? "idle" : snapshot.status;
-        current.status = projectDeliveryStatus(current.observation?.outcome ?? "unknown", phase);
-        current.background = { phase: snapshot.status, uploadedBytes: Math.max(0, snapshot.uploadedBytes), totalBytes: Math.max(0, snapshot.totalBytes) };
-        if (current.attention) current.error = { code: current.attention.code, message: snapshot.errorMessage ?? "Delivery needs attention. Its server outcome is being checked." };
-        else delete current.error;
-      } else {
-        current.background = {
-          phase: snapshot.status,
-          uploadedBytes: Math.max(0, snapshot.uploadedBytes),
-          totalBytes: Math.max(0, snapshot.totalBytes)
-        };
-        if (snapshot.status === "published") {
-          current.status = "succeeded";
-          delete current.error;
-        } else if (snapshot.status === "cancelled") {
-          current.status = "cancelled";
-          delete current.error;
-        } else if (snapshot.status === "expired" || snapshot.status === "rejected") {
-          current.status = "rejected";
-          current.error = { code: snapshot.errorCode ?? (snapshot.status === "expired" ? "MEDIA_BACKGROUND_EXPIRED" : "MEDIA_BACKGROUND_REJECTED"), message: snapshot.errorMessage ?? "Attachment delivery needs attention" };
-        } else {
-          current.status = snapshot.status === "sending" ? "sending" : "pending";
-          delete current.error;
-        }
-      }
-      await write(current, owner);
-      if (current.status === "succeeded" || current.status === "cancelled") {
-        delete current.attention;
-        delete current.error;
-        await Promise.allSettled(current.files.filter((file) => file.descriptor.cleanupAfterSend).map((file) => background.cleanupSource?.(file.reference)));
-        await write({ ...current, message: {}, files: [] }, owner);
-      }
-      if (current.status === "pending" || current.status === "sending") schedule();
-    } finally {
-      await unlock(flow.id, owner);
-    }
-  }
-  __name(applyBackgroundSnapshot, "applyBackgroundSnapshot");
-  async function authoritativeSnapshot(id2) {
-    if (!background?.reconcile || !foreground) return void 0;
-    const state = reconciliation.get(id2) ?? { nextAt: 0, failures: 0 };
-    if (state.pending) return state.pending;
-    if (clock() < state.nextAt) {
-      schedule();
-      return void 0;
-    }
-    state.nextAt = clock() + 5e3;
-    const pending = background.reconcile(id2).then((snapshot) => {
-      state.failures = 0;
-      state.nextAt = clock() + 5e3;
-      return snapshot;
-    }, (error) => {
-      state.failures += 1;
-      state.nextAt = clock() + Math.min(3e5, 5e3 * 2 ** Math.min(6, state.failures));
-      schedule();
-      throw error;
-    }).finally(() => {
-      delete state.pending;
-    });
-    state.pending = pending;
-    reconciliation.set(id2, state);
-    return pending;
-  }
-  __name(authoritativeSnapshot, "authoritativeSnapshot");
-  async function resumeBackground(flow, onProgress) {
-    if (!background) throw new EndpointError("This delivery needs a Canon version with background transfer support", { code: "MEDIA_BACKGROUND_MODULE_UNAVAILABLE", retryable: false });
+  async function retireBackground(flow) {
     if (flow.status === "succeeded") return flow.messageId;
-    if (flow.status === "cancelled") throw new EndpointError("Attachment was cancelled", { code: "MEDIA_FLOW_CANCELLED", retryable: false });
-    const snapshots = await background.inspect();
-    let snapshot = snapshots.find((item) => item.deliveryId === flow.id);
-    if (!snapshot && flow.background?.phase === "cancelling") {
-      throw new EndpointError("Cancellation is being reconciled", { code: "MEDIA_CANCELLING", retryable: true });
-    }
-    if (!snapshot) {
-      const identity = await endpoint.ready();
-      snapshot = await background.enqueue({
-        deliveryId: flow.id,
-        installationId: identity.installationId,
-        conversationId: flow.conversationId,
-        messageId: flow.messageId,
-        message: copyJson(flow.message),
-        ...flow.preparedContent ? { preparedContent: copyJson(flow.preparedContent) } : {},
-        files: flow.files.map((file) => ({ source: file.reference, descriptor: copyJson(file.descriptor) }))
-      });
-    }
-    await applyBackgroundSnapshot(snapshot);
-    if (background.reconcile) {
-      const authoritative = await authoritativeSnapshot(flow.id).catch(() => void 0);
-      if (authoritative) {
-        snapshot = authoritative;
-        await applyBackgroundSnapshot(snapshot);
-      }
-      schedule();
-    }
-    if (snapshot.schemaVersion !== 2 && (snapshot.status === "expired" || snapshot.status === "rejected")) {
-      throw new EndpointError(snapshot.errorMessage ?? "Attach this file again to send it", {
-        code: snapshot.errorCode ?? (snapshot.status === "expired" ? "MEDIA_BACKGROUND_EXPIRED" : "MEDIA_BACKGROUND_REJECTED"),
-        retryable: false
-      });
-    }
-    const phase = snapshot.status === "waiting_for_connection" ? "waiting_for_connection" : snapshot.status === "cancelling" ? "cancelling" : snapshot.status === "sending" || snapshot.status === "published" ? "sending" : snapshot.status === "uploading" ? "uploading" : "preparing";
-    onProgress?.({ phase, uploadedBytes: snapshot.uploadedBytes, totalBytes: snapshot.totalBytes });
-    return flow.messageId;
-  }
-  __name(resumeBackground, "resumeBackground");
-  async function stageBackground(input, sendOptions) {
-    if (!background) throw new Error("Background media adapter is missing");
-    const id2 = flowId(input.conversationId, input.messageId);
-    const existing = staging.get(id2);
-    if (existing) {
-      await existing;
-      return stageBackground(input, sendOptions);
-    }
-    const staged = (async () => {
-      if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-      const fingerprint = await hash(canonicalEndpointJson({ message: input.message, files: input.files.map((file) => ({ descriptor: file.descriptor, source: background.sourceIdentity(file.source) })) }));
-      if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-      const owner = await acquire(id2);
+    if (flow.status !== "cancelled") {
+      const owner = await acquire(flow.id);
       try {
-        if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-        const prior = await read(id2);
-        if (prior) {
-          if (prior.deliveryMode !== "background" || prior.fingerprint !== fingerprint) throw new EndpointError("Message identity already belongs to another attachment", { status: 409, code: "MEDIA_FLOW_CONFLICT", retryable: false });
-        } else {
-          const flow = {
-            id: id2,
-            conversationId: input.conversationId,
-            messageId: input.messageId,
-            message: copyJson(input.message),
-            fingerprint,
-            createdAt: new Date(clock()).toISOString(),
-            files: input.files.map((file) => ({ descriptor: copyJson(file.descriptor), reference: background.sourceIdentity(file.source) })),
-            deliveryMode: "background",
-            status: "pending",
-            background: { phase: "preparing", uploadedBytes: 0, totalBytes: input.files.reduce((sum, file) => sum + file.descriptor.sizeBytes, 0) }
-          };
-          if (background.preparedContentVersion === 1 && serverPreparedContentVersion === 1) {
-            const generation2 = await preparationGeneration;
-            const operationId = `media:${id2}`;
-            await reservePreparedIdentity(store, { operationId, action: "send_message", fingerprint, installationGeneration: generation2 });
-            const committed = await prepareAndCommitContent({
-              store,
-              scope: input.conversationId,
-              installationGeneration: generation2,
-              existing: /* @__PURE__ */ __name((tx) => tx.get(`${prefix3}${id2}`), "existing"),
-              prepare: /* @__PURE__ */ __name(async (snapshot) => ({ nextProtocolState: snapshot.protocolState, payload: prepareJsonContent({
-                context: { action: "send_message", conversationId: input.conversationId, messageId: input.messageId },
-                body: { ...input.message, conversationId: input.conversationId, messageId: input.messageId },
-                blobs: input.files.map((_, index) => ({ id: logicalMediaBlobId(input.conversationId, input.messageId, index), index })),
-                expected: { installationGeneration: generation2, protocolRevision: snapshot.protocolRevision, ...snapshot.admission ? { admission: snapshot.admission } : {} }
-              }) }), "prepare"),
-              commit: /* @__PURE__ */ __name(async (tx, preparedContent) => {
-                if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-                const sealed = { ...flow, preparedContent };
-                await writeInTransaction(tx, sealed, owner);
-                await tx.delete(`preparation/${operationId}`);
-                return sealed;
-              }, "commit")
-            });
-            notifyFlow(committed);
-          } else await write(flow, owner);
-        }
+        const { id: id2, conversationId, messageId, createdAt, deliveryMode } = flow;
+        await write({ id: id2, conversationId, messageId, createdAt, deliveryMode, message: {}, files: [], status: "cancelled" }, owner);
       } finally {
-        await unlock(id2, owner);
-      }
-      const onAbort = /* @__PURE__ */ __name(() => {
-        void pipeline3.cancel(id2).catch(() => void 0);
-      }, "onAbort");
-      sendOptions?.signal?.addEventListener("abort", onAbort, { once: true });
-      try {
-        if (sendOptions?.signal?.aborted) onAbort();
-        return await resumeBackground(await read(id2), sendOptions?.onProgress);
-      } finally {
-        sendOptions?.signal?.removeEventListener("abort", onAbort);
+        await unlock(flow.id, owner);
       }
-    })();
-    staging.set(id2, staged);
-    try {
-      return await staged;
-    } finally {
-      if (staging.get(id2) === staged) staging.delete(id2);
     }
+    throw new EndpointError("Attachment was cancelled", { code: "MEDIA_FLOW_CANCELLED", retryable: false });
   }
-  __name(stageBackground, "stageBackground");
-  const stopBackground = background?.subscribe((snapshot) => {
-    const next = (observations.get(snapshot.deliveryId) ?? Promise.resolve()).then(() => applyBackgroundSnapshot(snapshot)).catch(() => schedule());
-    observations.set(snapshot.deliveryId, next);
-    void next.finally(() => {
-      if (observations.get(snapshot.deliveryId) === next) observations.delete(snapshot.deliveryId);
-    });
-  });
+  __name(retireBackground, "retireBackground");
   async function stage(input, sendOptions, prepareOnly = false) {
     if (closed) throw new Error("Endpoint media pipeline is closed");
     const id2 = flowId(input.conversationId, input.messageId);
@@ -2470,7 +2183,7 @@ function createEndpointMediaPipeline(options) {
             files.push({ descriptor: copyJson(file.descriptor), reference: await bytes.retain(`${id2}:${fingerprint}:${index}`, file.source) });
           }
           checkOpen();
-          await write({ id: id2, ...prepareOnly ? { purpose: "prepare" } : {}, conversationId: input.conversationId, messageId: input.messageId, fingerprint, createdAt: new Date(clock()).toISOString(), ...sendOptions?.beforePublish ? { requiresPublicationApproval: true } : {}, message: copyJson(input.message), files, deliveryMode: "legacy", status: "pending" }, owner);
+          await write({ id: id2, ...prepareOnly ? { purpose: "prepare" } : {}, conversationId: input.conversationId, messageId: input.messageId, fingerprint, createdAt: new Date(clock()).toISOString(), ...sendOptions?.beforePublish ? { requiresPublicationApproval: true } : {}, message: copyJson(input.message), files, status: "pending" }, owner);
         }
       } catch (error) {
         await Promise.allSettled(files.map((file) => bytes.release(file.reference)));
@@ -2492,18 +2205,9 @@ function createEndpointMediaPipeline(options) {
   }
   __name(stage, "stage");
   const pipeline3 = {
-    canSendInBackground,
     async send(input, sendOptions) {
-      const id2 = flowId(input.conversationId, input.messageId);
-      const prior = await read(id2);
-      if (prior?.deliveryMode === "background") return stageBackground(input, sendOptions);
-      if (!prior && !sendOptions?.beforePublish && sendOptions?.handoffMode !== "legacy") {
-        const encrypted = await encryptedRoom(input.conversationId);
-        if (encrypted && sendOptions?.handoffMode === "background") {
-          throw new EndpointError("An encrypted room's attachments are prepared on this device", { code: "MEDIA_BACKGROUND_UNAVAILABLE", retryable: false });
-        }
-        if (!encrypted && (sendOptions?.handoffMode === "background" || await canSendInBackground())) return stageBackground(input, sendOptions);
-      }
+      const prior = await read(flowId(input.conversationId, input.messageId));
+      if (prior?.deliveryMode === "background") return retireBackground(prior);
       return stage(input, sendOptions);
     },
     async prepare(input, prepareOptions) {
@@ -2515,7 +2219,7 @@ function createEndpointMediaPipeline(options) {
     },
     async resume(id2, resumeOptions) {
       const persisted = await read(id2);
-      if (persisted?.deliveryMode === "background") return resumeBackground(persisted, resumeOptions?.onProgress);
+      if (persisted?.deliveryMode === "background") return retireBackground(persisted);
       installGuard(id2, resumeOptions?.beforePublish);
       const existing = running.get(id2);
       if (existing) return existing;
@@ -2771,15 +2475,6 @@ function createEndpointMediaPipeline(options) {
     },
     async resumePending() {
       if (closed) return;
-      if (background?.reconcile && !restoredNativeObservations) {
-        restoredNativeObservations = true;
-        try {
-          for (const snapshot of await background.inspect()) await applyBackgroundSnapshot(snapshot);
-        } catch {
-          restoredNativeObservations = false;
-          schedule();
-        }
-      }
       let after;
       do {
         const records = await store.transaction((tx) => tx.scan("media-pending/", { after, limit: 100 }));
@@ -2793,20 +2488,9 @@ function createEndpointMediaPipeline(options) {
       if (saved) await pipeline3.cancel(saved.id);
     },
     async cancel(id2) {
-      const backgroundFlow = await read(id2);
-      if (backgroundFlow?.deliveryMode === "background") {
-        if (!background || backgroundFlow.status === "succeeded" || backgroundFlow.status === "cancelled") return;
-        const owner2 = await acquire(id2);
-        try {
-          const current = await read(id2);
-          if (!current || current.status === "succeeded" || current.status === "cancelled") return;
-          current.background = { phase: "cancelling", uploadedBytes: current.background?.uploadedBytes ?? 0, totalBytes: current.background?.totalBytes ?? 0 };
-          await write(current, owner2);
-        } finally {
-          await unlock(id2, owner2);
-        }
-        await background.cancel(id2);
-        schedule();
+      const retired = await read(id2);
+      if (retired?.deliveryMode === "background") {
+        await retireBackground(retired).catch(() => void 0);
         return;
       }
       if (staging.has(id2)) cancelledStages.add(id2);
@@ -2829,15 +2513,12 @@ function createEndpointMediaPipeline(options) {
     async close(closeOptions) {
       closed = true;
       unsubscribe();
-      stopConnections?.();
-      stopBackground?.();
       listeners.clear();
       for (const guard of publicationGuards.values()) guard.unregister();
       publicationGuards.clear();
       if (timer) clearTimeout(timer);
       for (const controller of controllers.values()) controller.abort();
       await Promise.allSettled([...staging.values(), ...running.values()]);
-      if (closeOptions?.discard) await background?.cleanup();
       if (closeOptions?.discard) {
         let after;
         do {
@@ -3184,6 +2865,90 @@ function createInboundHandoffs(input) {
 }
 __name(createInboundHandoffs, "createInboundHandoffs");
 
+// ../endpoint/src/completions.ts
+var PREFIX = "completion/";
+var key = /* @__PURE__ */ __name((id2) => `${PREFIX}${encodeURIComponent(id2)}`, "key");
+function createCompletions(input) {
+  function validate(record6) {
+    if (record6?.version !== 1 || typeof record6.id !== "string" || !record6.id || record6.id.length > 600 || typeof record6.conversationId !== "string" || !record6.conversationId || typeof record6.createdAt !== "string" || !Array.isArray(record6.inputIds) || record6.inputIds.some((id2) => typeof id2 !== "string" || !id2) || record6.output === void 0) {
+      throw new EndpointError("Invalid completion", { code: "INVALID_COMPLETION", retryable: false });
+    }
+  }
+  __name(validate, "validate");
+  async function put(tx, record6) {
+    const existing = await tx.get(key(record6.id));
+    if (existing && canonicalEndpointJson(existing) !== canonicalEndpointJson(record6)) {
+      throw new EndpointError("A completion cannot be replaced", { code: "COMPLETION_CONFLICT", retryable: false });
+    }
+    if (!existing) await tx.put(key(record6.id), record6);
+  }
+  __name(put, "put");
+  async function all(tx) {
+    const found = [];
+    for (let after; ; ) {
+      const batch = await tx.scan(PREFIX, { ...after ? { after } : {}, limit: 100 });
+      found.push(...batch.map((entry) => entry.value));
+      if (batch.length < 100) return found;
+      after = batch.at(-1).key;
+    }
+  }
+  __name(all, "all");
+  const transaction = /* @__PURE__ */ __name(async (work) => {
+    input.assertOpen();
+    await input.ready();
+    return input.store.transaction(async (tx) => {
+      await input.assertCurrent(tx);
+      return work(tx);
+    });
+  }, "transaction");
+  return {
+    async save(record6) {
+      const frozen = copyJson(record6);
+      validate(frozen);
+      await transaction((tx) => put(tx, frozen));
+    },
+    async get(id2) {
+      input.assertOpen();
+      await input.ready();
+      return input.store.transaction((tx) => tx.get(key(id2)));
+    },
+    /** Oldest first. */
+    async list() {
+      input.assertOpen();
+      await input.ready();
+      const found = await input.store.transaction(all);
+      return found.sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+    },
+    /** One record for another, in one step: a Stop's cut keeps only what was already queued. */
+    async replace(previousId, next) {
+      const frozen = copyJson(next);
+      validate(frozen);
+      await transaction(async (tx) => {
+        await put(tx, frozen);
+        if (previousId !== frozen.id) await tx.delete(key(previousId));
+      });
+    },
+    /**
+     * The output is durable or withdrawn: its record goes, and in the same step `settle`'s inputs settle. An input already
+     * settled, or no longer in the inbox, is left as it is.
+     */
+    async finish(id2, settle) {
+      await transaction(async (tx) => {
+        for (const inputId of new Set(settle?.inputIds ?? [])) {
+          const current = await tx.get(`inbound/${inputId}`);
+          if (current && current.state !== "settled") await input.settleInbound(tx, inputId, settle.reason);
+        }
+        await tx.delete(key(id2));
+      });
+    },
+    /** The input ids every completion names, read inside the caller's transaction. */
+    async answered(tx) {
+      return new Set((await all(tx)).flatMap((record6) => record6.inputIds));
+    }
+  };
+}
+__name(createCompletions, "createCompletions");
+
 // ../endpoint/src/external-inbound.ts
 function createExternalInboundClaims(input) {
   function validate(id2, requestId) {
@@ -3328,13 +3093,6 @@ function createExternalInboundClaims(input) {
 }
 __name(createExternalInboundClaims, "createExternalInboundClaims");
 
-// ../endpoint/src/artifact-context.ts
-var contexts = /* @__PURE__ */ new WeakMap();
-function registerArtifactEndpoint(endpoint, context) {
-  contexts.set(endpoint, context);
-}
-__name(registerArtifactEndpoint, "registerArtifactEndpoint");
-
 // ../endpoint/src/receipts.ts
 function endpointReceiptResult(receipt) {
   if (receipt.resultError) throw new EndpointError(receipt.resultError.message, { status: receipt.resultError.status, code: receipt.resultError.code, retryable: receipt.resultError.retryable, operationId: receipt.operationId });
@@ -3365,12 +3123,12 @@ function record(value, required, optional = []) {
   if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail();
   const descriptors = Object.getOwnPropertyDescriptors(value);
   const keys = Reflect.ownKeys(descriptors);
-  if (keys.some((key) => typeof key !== "string" || ![...required, ...optional].includes(key)) || required.some((key) => !Object.hasOwn(descriptors, key))) fail();
+  if (keys.some((key2) => typeof key2 !== "string" || ![...required, ...optional].includes(key2)) || required.some((key2) => !Object.hasOwn(descriptors, key2))) fail();
   const result = {};
-  for (const key of keys) {
-    const descriptor = descriptors[key];
+  for (const key2 of keys) {
+    const descriptor = descriptors[key2];
     if (!Object.hasOwn(descriptor, "value") || !descriptor.enumerable) fail();
-    result[key] = descriptor.value;
+    result[key2] = descriptor.value;
   }
   return result;
 }
@@ -3409,8 +3167,8 @@ function createMlsDevDeviceCoordinator(input) {
     installationId: binding.installationId,
     ...binding.principal.type === "ai_agent" ? { ownershipVersion: binding.principal.ownershipVersion } : {}
   });
-  function boundDevice(device, key) {
-    if (device.environmentId !== binding.environmentId || !same(device.principal, binding.principal) || device.installationId !== binding.installationId || device.signaturePublicKey !== key) fail("MLS_DEV_DEVICE_BINDING_MISMATCH");
+  function boundDevice(device, key2) {
+    if (device.environmentId !== binding.environmentId || !same(device.principal, binding.principal) || device.installationId !== binding.installationId || device.signaturePublicKey !== key2) fail("MLS_DEV_DEVICE_BINDING_MISMATCH");
   }
   __name(boundDevice, "boundDevice");
   async function load(tx, snapshot) {
@@ -3781,7 +3539,7 @@ __name(same2, "same");
 function parseFlow(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) fail2();
   const raw = value;
-  if (Object.keys(raw).some((key) => !["version", "id", "goal", "phase", "begin", "challenge"].includes(key)) || raw.version !== 1 || typeof raw.id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(raw.id)) fail2();
+  if (Object.keys(raw).some((key2) => !["version", "id", "goal", "phase", "begin", "challenge"].includes(key2)) || raw.version !== 1 || typeof raw.id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(raw.id)) fail2();
   const head = { version: 1, id: raw.id };
   if (raw.goal === "enroll" && raw.phase === "enrollment") return {
     ...head,
@@ -4217,8 +3975,8 @@ __name(fail3, "fail");
 function record2(value, keys) {
   if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail3();
   const fields = Object.getOwnPropertyDescriptors(value);
-  if (Reflect.ownKeys(fields).length !== keys.length || keys.some((key) => !Object.hasOwn(fields, key) || !Object.hasOwn(fields[key], "value") || !fields[key].enumerable)) fail3();
-  return Object.fromEntries(keys.map((key) => [key, fields[key].value]));
+  if (Reflect.ownKeys(fields).length !== keys.length || keys.some((key2) => !Object.hasOwn(fields, key2) || !Object.hasOwn(fields[key2], "value") || !fields[key2].enumerable)) fail3();
+  return Object.fromEntries(keys.map((key2) => [key2, fields[key2].value]));
 }
 __name(record2, "record");
 function createMlsDevKeyPackageService(options, context, store, initialized, readPrepared) {
@@ -4242,9 +4000,9 @@ function createMlsDevKeyPackageService(options, context, store, initialized, rea
   async function exchange(id2, online, op) {
     const { binding, device } = await initialized();
     if (online) network();
-    const key = op.prefix + id2;
+    const key2 = op.prefix + id2;
     const captured = await store.transaction(async (tx) => {
-      const current = await device.captureKeyPackagePrerequisite(tx), raw = await tx.get(key);
+      const current = await device.captureKeyPackagePrerequisite(tx), raw = await tx.get(key2);
       if (!online && raw === void 0) return { current, raw, request: void 0, previous: void 0 };
       const request = await op.make(tx, binding, current);
       const previous = raw === void 0 ? void 0 : parseJournal(raw, binding, current, op);
@@ -4266,7 +4024,7 @@ function createMlsDevKeyPackageService(options, context, store, initialized, rea
       if (current.fingerprint !== captured.current.fingerprint) fail3("MLS_DEV_KEY_PACKAGE_DEVICE_CHANGED", true);
       const claims = parseMlsDevCredentialToken(current.credential.credential).unsigned.claims, now = context.clock();
       if (!Number.isSafeInteger(now) || now < claims.issuedAtMs || now >= claims.expiresAtMs) fail3("MLS_DEV_KEY_PACKAGE_EXPIRED");
-      if (!same3(await tx.get(key) ?? null, captured.raw ?? null)) fail3("MLS_DEV_KEY_PACKAGE_STATE_CHANGED", true);
+      if (!same3(await tx.get(key2) ?? null, captured.raw ?? null)) fail3("MLS_DEV_KEY_PACKAGE_STATE_CHANGED", true);
       if (captured.raw === void 0 && (await tx.scan(op.prefix, { limit: 33 })).length >= 32) fail3("MLS_DEV_KEY_PACKAGE_INVENTORY_FULL");
       const request = captured.request ?? fail3();
       await op.validate(tx, binding, current, request, null);
@@ -4277,7 +4035,7 @@ function createMlsDevKeyPackageService(options, context, store, initialized, rea
         request,
         receipt: captured.previous?.receipt ?? null
       };
-      await tx.put(key, value);
+      await tx.put(key2, value);
       return value;
     });
     let receipt;
@@ -4287,7 +4045,7 @@ function createMlsDevKeyPackageService(options, context, store, initialized, rea
       if (!(error instanceof EndpointError)) fail3("MLS_DEV_KEY_PACKAGE_REQUEST_FAILED", true);
       if (op.forgetsRefusal && attempt.receipt === null && !error.retryable && error.status >= 400 && error.status < 500 && error.code === "HTTP_" + error.status) {
         await store.transaction(async (tx) => {
-          if (same3(await tx.get(key) ?? null, attempt)) await tx.delete(key);
+          if (same3(await tx.get(key2) ?? null, attempt)) await tx.delete(key2);
         });
       }
       throw error;
@@ -4297,11 +4055,11 @@ function createMlsDevKeyPackageService(options, context, store, initialized, rea
     return store.transaction(async (tx) => {
       const current = await device.captureKeyPackagePrerequisite(tx);
       if (current.fingerprint !== captured.current.fingerprint) fail3("MLS_DEV_KEY_PACKAGE_DEVICE_CHANGED", true);
-      const stored = parseJournal(await tx.get(key), binding, current, op);
+      const stored = parseJournal(await tx.get(key2), binding, current, op);
       if (!same3(stored.request, attempt.request)) fail3("MLS_DEV_KEY_PACKAGE_STATE_CHANGED", true);
       await op.validate(tx, binding, current, attempt.request, receipt);
       if (stored.receipt !== null && !same3(stored.receipt, receipt)) fail3("MLS_DEV_KEY_PACKAGE_RECEIPT_CONFLICT");
-      await tx.put(key, { ...stored, receipt });
+      await tx.put(key2, { ...stored, receipt });
       return receipt;
     });
   }
@@ -4449,8 +4207,8 @@ var same4 = /* @__PURE__ */ __name((a, b) => canonicalEndpointJson(a) === canoni
 function record3(value, keys) {
   if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail4();
   const fields = Object.getOwnPropertyDescriptors(value);
-  if (Reflect.ownKeys(fields).length !== keys.length || keys.some((key) => !Object.hasOwn(fields, key) || !Object.hasOwn(fields[key], "value") || !fields[key].enumerable)) fail4();
-  return Object.fromEntries(keys.map((key) => [key, fields[key].value]));
+  if (Reflect.ownKeys(fields).length !== keys.length || keys.some((key2) => !Object.hasOwn(fields, key2) || !Object.hasOwn(fields[key2], "value") || !fields[key2].enumerable)) fail4();
+  return Object.fromEntries(keys.map((key2) => [key2, fields[key2].value]));
 }
 __name(record3, "record");
 function boundPayload(command, payload) {
@@ -4948,28 +4706,28 @@ var erased = /* @__PURE__ */ __name((value) => {
 async function deleteMlsDevTextMessage(tx, conversationId, messageId) {
   const tombstone = mlsDevTextDeletedKey(conversationId, messageId), known = await tx.get(tombstone) !== void 0;
   if (!known) await tx.put(tombstone, { version: 1 });
-  const key = mlsDevTextMessageKey(conversationId, messageId), value = await tx.get(key);
+  const key2 = mlsDevTextMessageKey(conversationId, messageId), value = await tx.get(key2);
   if (value?.message.kind !== "text" && value?.message.kind !== "item" || value.deleted || value.feedOrdinal === null) return !known;
-  await tx.put(key, erased(value));
+  await tx.put(key2, erased(value));
   return true;
 }
 __name(deleteMlsDevTextMessage, "deleteMlsDevTextMessage");
 async function setMlsDevTextReactions(tx, conversationId, messageId, reactions) {
-  const key = mlsDevTextReactionsKey(conversationId, messageId), next = reactions && Object.keys(reactions).length ? reactions : void 0;
-  const previous = await tx.get(key);
+  const key2 = mlsDevTextReactionsKey(conversationId, messageId), next = reactions && Object.keys(reactions).length ? reactions : void 0;
+  const previous = await tx.get(key2);
   if (JSON.stringify(previous ?? null) === JSON.stringify(next ?? null)) return false;
-  if (next) await tx.put(key, next);
-  else await tx.delete(key);
+  if (next) await tx.put(key2, next);
+  else await tx.delete(key2);
   return true;
 }
 __name(setMlsDevTextReactions, "setMlsDevTextReactions");
 async function putMlsDevTextMessage(tx, value) {
   if (await tx.get(mlsDevTextDeletedKey(value.message.conversationId, value.message.messageId)) !== void 0) value = erased(value);
   const { conversationId, messageId } = value.message;
-  const key = mlsDevTextMessageKey(conversationId, messageId);
-  const old = await tx.get(key);
+  const key2 = mlsDevTextMessageKey(conversationId, messageId);
+  const old = await tx.get(key2);
   if (old?.feedOrdinal !== null && old?.feedOrdinal !== void 0 && old.feedOrdinal !== value.feedOrdinal) fail5();
-  await tx.put(key, value);
+  await tx.put(key2, value);
   if (value.message.kind !== "text" && value.message.kind !== "item" && value.message.kind !== "interaction.request") return;
   if (value.feedOrdinal === null) await tx.put(`${pendingPrefix(conversationId)}${encoded2(messageId)}`, { messageId });
   else {
@@ -5114,10 +4872,10 @@ async function queryMlsDevTextHistory(tx, conversationId, name, parameters, audi
 __name(queryMlsDevTextHistory, "queryMlsDevTextHistory");
 async function settleMlsDevTextOperation(tx, operation) {
   if (operation.action !== "mls_application" || !operation.conversationId || !operation.messageId || !["rejected", "uncertain"].includes(operation.status)) return;
-  const key = mlsDevTextMessageKey(operation.conversationId, operation.messageId);
-  const value = await tx.get(key);
+  const key2 = mlsDevTextMessageKey(operation.conversationId, operation.messageId);
+  const value = await tx.get(key2);
   if (value && value.message.operationId === operation.operationId && value.feedOrdinal === null) {
-    await tx.put(key, { ...value, status: operation.status });
+    await tx.put(key2, { ...value, status: operation.status });
   }
 }
 __name(settleMlsDevTextOperation, "settleMlsDevTextOperation");
@@ -5135,13 +4893,13 @@ async function opensMlsAlias(environmentId, alias, opening, hash) {
     return false;
   }
   if (!isMlsPrincipalAlias(alias)) return false;
-  const key = checkKey(environmentId, alias, value);
-  let opens = checked.get(key);
+  const key2 = checkKey(environmentId, alias, value);
+  let opens = checked.get(key2);
   if (opens === void 0) {
     const digest = await hash(encodeMlsPrincipalAliasInput(environmentId, value));
     opens = /^[0-9a-f]{64}$/.test(digest) && MLS_PRINCIPAL_ALIAS_PREFIX + encodeCanonicalMlsBase64Url(hexBytes(digest)) === alias;
     if (checked.size >= 4096) checked.clear();
-    checked.set(key, opens);
+    checked.set(key2, opens);
   }
   return opens;
 }
@@ -5246,8 +5004,8 @@ __name(id, "id");
 function record4(value, required, optional = []) {
   if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail6();
   const descriptors = Object.getOwnPropertyDescriptors(value), fields = Reflect.ownKeys(descriptors);
-  if (required.some((key) => !Object.hasOwn(descriptors, key)) || fields.some((key) => typeof key !== "string" || ![...required, ...optional].includes(key) || !Object.hasOwn(descriptors[key], "value") || !descriptors[key].enumerable)) fail6();
-  return Object.fromEntries(fields.map((key) => [key, descriptors[key].value]));
+  if (required.some((key2) => !Object.hasOwn(descriptors, key2)) || fields.some((key2) => typeof key2 !== "string" || ![...required, ...optional].includes(key2) || !Object.hasOwn(descriptors[key2], "value") || !descriptors[key2].enumerable)) fail6();
+  return Object.fromEntries(fields.map((key2) => [key2, descriptors[key2].value]));
 }
 __name(record4, "record");
 function envelope(value, binding, conversationId) {
@@ -5386,7 +5144,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       "mlsRemoval",
       "mlsIdentities",
       "mlsInviteeId"
-    ].map((key) => [key, conversation[key] ?? null])) : null;
+    ].map((key2) => [key2, conversation[key2] ?? null])) : null;
     const cursor = await tx.get(`cursor/${conversationId}`);
     const protocol = await tx.get(mlsDevTextProtocolKey(conversationId));
     if (protocol !== void 0 && !isMlsDevTextProtocol(protocol) || current && current.protocol !== protocol) fail6("MLS_DEV_TEXT_PROTOCOL_UNSUPPORTED");
@@ -5782,13 +5540,13 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       const request = message.interaction, responder = request.responderIds[0];
       if (sender.principal.type !== "ai_agent") return "MLS_DEV_INTERACTION_REQUESTER_INVALID";
       if (responder === sender.principal.id || !current.envelope.roster.some((member) => member.device.principal.type === "human" && member.device.principal.id === responder)) return "MLS_DEV_INTERACTION_RESPONDER_UNAVAILABLE";
-      const key2 = mlsDevInteractionKey(cid, sender.principal.id, request.requestId), existing2 = await tx.get(key2);
+      const key3 = mlsDevInteractionKey(cid, sender.principal.id, request.requestId), existing2 = await tx.get(key3);
       if (existing2) {
         const earlier = await tx.get(acceptedKey(cid, existing2.head.sequence));
         const principals = /* @__PURE__ */ __name((roster) => JSON.stringify([...new Set(roster.map((member) => JSON.stringify([member.device.principal.type, member.device.principal.id, member.admissionId])))].sort()), "principals");
         if (existing2.status !== "pending" || existing2.requesterDeviceId !== sender.deviceId || !same6(existing2.request, request) || existing2.membershipRevision !== wire.preconditions.membershipRevision || same6(existing2.head, wire.expectedHead) || earlier === void 0 || principals(parseMlsDevGroupAcceptedControl(earlier).control.roster) !== principals(current.envelope.roster)) return "MLS_DEV_INTERACTION_ID_CONFLICT";
       }
-      await tx.put(key2, {
+      await tx.put(key3, {
         version: 1,
         conversationId: cid,
         agentId: sender.principal.id,
@@ -5807,13 +5565,13 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     if (message.kind === "interaction.response") {
       const response = message.interaction;
       if (sender.principal.type !== "human") return "MLS_DEV_INTERACTION_RESPONDER_INVALID";
-      const key2 = mlsDevInteractionKey(cid, response.agentId, response.requestId), existing2 = await tx.get(key2);
+      const key3 = mlsDevInteractionKey(cid, response.agentId, response.requestId), existing2 = await tx.get(key3);
       if (!existing2) return "MLS_DEV_INTERACTION_UNKNOWN";
       if (!existing2.request.responderIds.includes(sender.principal.id)) return "MLS_DEV_INTERACTION_RESPONDER_INVALID";
       if (existing2.status !== "pending") return "MLS_DEV_INTERACTION_CLOSED";
       if (existing2.requestOrdinal >= entry.ordinal || !same6(existing2.head, wire.expectedHead) || existing2.membershipRevision !== wire.preconditions.membershipRevision) return "MLS_DEV_INTERACTION_AUDIENCE_CHANGED";
       if (!isMlsDevInteractionAnswerAllowed(existing2.request, response.answer)) return "MLS_DEV_INTERACTION_ANSWER_INVALID";
-      await tx.put(key2, { ...existing2, status: "answered", response: {
+      await tx.put(key3, { ...existing2, status: "answered", response: {
         responderId: sender.principal.id,
         responderDeviceId: sender.deviceId,
         messageId: wire.messageId,
@@ -5824,11 +5582,11 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       return void 0;
     }
     if (sender.principal.type !== "ai_agent") return "MLS_DEV_INTERACTION_REQUESTER_INVALID";
-    const key = mlsDevInteractionKey(cid, sender.principal.id, message.interaction.requestId), existing = await tx.get(key);
+    const key2 = mlsDevInteractionKey(cid, sender.principal.id, message.interaction.requestId), existing = await tx.get(key2);
     if (!existing) return "MLS_DEV_INTERACTION_UNKNOWN";
     if (existing.requesterDeviceId !== sender.deviceId) return "MLS_DEV_INTERACTION_REQUESTER_INVALID";
     if (existing.status !== "pending") return "MLS_DEV_INTERACTION_CLOSED";
-    await tx.put(key, { ...existing, status: "withdrawn", withdrawal: {
+    await tx.put(key2, { ...existing, status: "withdrawn", withdrawal: {
       reason: message.interaction.reason,
       messageId: wire.messageId,
       ordinal: entry.ordinal
@@ -5917,7 +5675,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       url: data.url,
       mimeType: data.mimeType,
       sizeBytes: data.sizeBytes,
-      ...Object.fromEntries(["fileName", "width", "height", "durationMs", "thumbnailUrl"].filter((key) => data[key] !== void 0 && data[key] !== null).map((key) => [key, data[key]])),
+      ...Object.fromEntries(["fileName", "width", "height", "durationMs", "thumbnailUrl"].filter((key2) => data[key2] !== void 0 && data[key2] !== null).map((key2) => [key2, data[key2]])),
       ...typeof caption === "string" && caption.trim() ? { caption } : {}
     };
     return validItem(raw);
@@ -5962,7 +5720,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     const attachments = data.attachments ?? [];
     if (!Array.isArray(attachments) || attachments.length > 1) fail6(Array.isArray(attachments) ? "MLS_DEV_ONE_ITEM_PER_MESSAGE" : "MLS_DEV_TEXT_ONLY");
     const item = attachments.length ? itemInput(attachments[0], data.text) : void 0;
-    if (data.contentType !== void 0 && data.contentType !== (item ? item.type : "text") || !item && typeof data.text !== "string" || item && data.text !== void 0 && data.text !== null && typeof data.text !== "string" || data.mentions !== void 0 && (!Array.isArray(data.mentions) || data.mentions.some((mention) => typeof mention !== "string")) || data.replyTo !== void 0 && data.replyTo !== null && typeof data.replyTo !== "string" || ["replyToPosition", "metadata", "forwarded", "contactCardUserId"].some((key) => data[key] !== void 0 && data[key] !== null) || data.replyAuthority !== void 0 && (!!item || !data.replyAuthority || typeof data.replyAuthority !== "object" || Array.isArray(data.replyAuthority))) fail6("MLS_DEV_TEXT_ONLY");
+    if (data.contentType !== void 0 && data.contentType !== (item ? item.type : "text") || !item && typeof data.text !== "string" || item && data.text !== void 0 && data.text !== null && typeof data.text !== "string" || data.mentions !== void 0 && (!Array.isArray(data.mentions) || data.mentions.some((mention) => typeof mention !== "string")) || data.replyTo !== void 0 && data.replyTo !== null && typeof data.replyTo !== "string" || ["replyToPosition", "metadata", "forwarded", "contactCardUserId"].some((key2) => data[key2] !== void 0 && data[key2] !== null) || data.replyAuthority !== void 0 && (!!item || !data.replyAuthority || typeof data.replyAuthority !== "object" || Array.isArray(data.replyAuthority))) fail6("MLS_DEV_TEXT_ONLY");
     const mentions = [...new Set(data.mentions ?? [])].map(id);
     return {
       conversationId: id(data.conversationId),
@@ -6150,14 +5908,14 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       ...input.replyTo ? { replyTo: input.replyTo } : {},
       ...input.mentions ? { mentions: input.mentions } : {}
     };
-    const init = await initialized(), key = mlsDevHeldTextKey(cid, messageId);
+    const init = await initialized(), key2 = mlsDevHeldTextKey(cid, messageId);
     const kept = await store.transaction(async (tx) => {
-      const existing = await tx.get(key);
+      const existing = await tx.get(key2);
       if (!existing) return await tx.get(`operation/${operationId}`) !== void 0 ? "made" : (await readMlsDevHeldTexts(tx, cid)).some((held) => !held.failed) ? "behind" : "none";
       if (existing.operationId !== operationId || canonicalEndpointJson(existing.body) !== canonicalEndpointJson(body)) fail6("OPERATION_ID_COLLISION");
       if (existing.failed) {
         const { failed: _failed, ...again } = existing;
-        await tx.put(key, again);
+        await tx.put(key2, again);
       }
       return "kept";
     });
@@ -6173,7 +5931,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     await store.transaction(async (tx) => {
       const held = await readMlsDevHeldTexts(tx, cid);
       if (held.length >= MLS_DEV_HELD_TEXT_MAX) fail6("MLS_DEV_HELD_TEXT_LIMIT");
-      await tx.put(key, {
+      await tx.put(key2, {
         version: 1,
         body,
         operationId,
@@ -6191,20 +5949,20 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     const sent = [], failed = [];
     const kept = (await store.transaction((tx) => readMlsDevHeldTexts(tx, conversationId))).filter((held) => !held.failed);
     for (const held of kept) {
-      const key = mlsDevHeldTextKey(conversationId, held.body.messageId);
+      const key2 = mlsDevHeldTextKey(conversationId, held.body.messageId);
       try {
         sent.push(await sendText(textInput(held.body), held.operationId));
       } catch (error) {
         if (error instanceof EndpointError && ["ENDPOINT_CLOSED", "PREPARATION_INSTALLATION_FENCED"].includes(error.code)) throw error;
         if (!(error instanceof EndpointError) || error.retryable) return { sent, failed, waiting: true };
         await store.transaction(async (tx) => {
-          if (await tx.get(key) !== void 0) await tx.put(key, { ...held, failed: error.code });
+          if (await tx.get(key2) !== void 0) await tx.put(key2, { ...held, failed: error.code });
         });
         failed.push({ operationId: held.operationId, error });
         bridge.historyChanged?.(conversationId);
         continue;
       }
-      await store.transaction((tx) => tx.delete(key));
+      await store.transaction((tx) => tx.delete(key2));
     }
     return { sent, failed, waiting: false };
   }
@@ -6452,7 +6210,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
   }
   __name(readInteraction, "readInteraction");
   async function openSecretAnswer(conversationId, requestId) {
-    const init = await initialized(), key = mlsDevInteractionKey(conversationId, init.binding.principal.id, requestId);
+    const init = await initialized(), key2 = mlsDevInteractionKey(conversationId, init.binding.principal.id, requestId);
     if (principal.type !== "ai_agent") fail6("MLS_DEV_INTERACTION_REQUESTER_INVALID");
     let captured, known, text;
     await prepareAndCommitContent({
@@ -6463,7 +6221,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
         const current = await capture(tx, state, init, conversationId), group = current.envelope;
         if (!mlsDevProtocolCarriesCards(current.protocol) || !group?.head || group.removed) fail6("MLS_DEV_INTERACTION_PROTOCOL_REQUIRED");
         if (group.pending) fail6("MLS_DEV_GROUP_PENDING_CONTROL", true);
-        known = await tx.get(key) ?? fail6("MLS_DEV_INTERACTION_UNKNOWN");
+        known = await tx.get(key2) ?? fail6("MLS_DEV_INTERACTION_UNKNOWN");
         if (known.requesterDeviceId !== current.device.registration.device.deviceId || known.request.kind !== "secret") fail6("MLS_DEV_INTERACTION_REQUESTER_INVALID");
         if (known.opened) fail6("MLS_DEV_INTERACTION_OPENED");
         const view3 = viewMlsDevInteraction(known, context.clock(), void 0);
@@ -6486,8 +6244,8 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       }, "prepare"),
       commit: /* @__PURE__ */ __name(async (tx, prepared, state) => {
         const current = await capture(tx, state, init, conversationId);
-        if (current.fingerprint !== prepared.fingerprint || !same6(await tx.get(key), prepared.opened)) fail6("MLS_DEV_GROUP_DEPENDENCY_CHANGED", true);
-        await tx.put(key, { ...prepared.opened, opened: true });
+        if (current.fingerprint !== prepared.fingerprint || !same6(await tx.get(key2), prepared.opened)) fail6("MLS_DEV_GROUP_DEPENDENCY_CHANGED", true);
+        await tx.put(key2, { ...prepared.opened, opened: true });
         return true;
       }, "commit")
     });
@@ -7158,7 +6916,7 @@ function createEndpoint(options) {
   let retryDue = Number.POSITIVE_INFINITY;
   let negotiatedCapabilities = null;
   const now = /* @__PURE__ */ __name(() => new Date(clock()).toISOString(), "now");
-  const key = /* @__PURE__ */ __name((operationId) => `operation/${operationId}`, "key");
+  const key2 = /* @__PURE__ */ __name((operationId) => `operation/${operationId}`, "key");
   function assertOpen() {
     if (closed) throw new EndpointError("Endpoint is closed", { code: "ENDPOINT_CLOSED", retryable: false });
   }
@@ -7736,9 +7494,9 @@ function createEndpoint(options) {
   function rememberStubName(conversationId, stub) {
     const name = typeof stub.senderName === "string" ? stub.senderName.trim() : "";
     if (typeof stub.senderId !== "string" || !stub.senderId || !name || name === stub.senderId || name.length > 80) return;
-    const key2 = stubKey(conversationId, stub.id);
-    stubNames.delete(key2);
-    stubNames.set(key2, { senderId: stub.senderId, name });
+    const key3 = stubKey(conversationId, stub.id);
+    stubNames.delete(key3);
+    stubNames.set(key3, { senderId: stub.senderId, name });
     if (stubNames.size > 1e3) stubNames.delete(stubNames.keys().next().value);
   }
   __name(rememberStubName, "rememberStubName");
@@ -7752,13 +7510,13 @@ function createEndpoint(options) {
   }
   __name(withStubNames, "withStubNames");
   function forgetStubReads(conversationId) {
-    for (const key2 of stubReads.keys()) if (key2.startsWith(`${conversationId}\0`)) stubReads.delete(key2);
+    for (const key3 of stubReads.keys()) if (key3.startsWith(`${conversationId}\0`)) stubReads.delete(key3);
   }
   __name(forgetStubReads, "forgetStubReads");
   async function recoverMlsDevMessageActions(conversationId, messageIds) {
     const at = clock(), due = [...new Set(messageIds)].filter((id2) => at >= (stubReads.get(stubKey(conversationId, id2)) ?? -Infinity) + 3e4).slice(0, 100);
     if (!due.length) return false;
-    for (const [key2, readAt] of stubReads) if (at >= readAt + 3e4) stubReads.delete(key2);
+    for (const [key3, readAt] of stubReads) if (at >= readAt + 3e4) stubReads.delete(key3);
     for (const id2 of due) stubReads.set(stubKey(conversationId, id2), at);
     const beforeRead = liveActionCounter;
     let stubs;
@@ -7847,6 +7605,51 @@ function createEndpoint(options) {
     }
   }
   __name(refreshMlsRoomFromHint, "refreshMlsRoomFromHint");
+  const roomHints = /* @__PURE__ */ new Map();
+  let roomHintWorker;
+  function queueRoomHint(key3, run, last = false) {
+    if (closed) return Promise.resolve();
+    let hint = roomHints.get(key3);
+    if (hint && last) roomHints.delete(key3);
+    if (!hint) {
+      let settle;
+      const done = new Promise((resolve3, reject) => {
+        settle = /* @__PURE__ */ __name((error) => error === void 0 ? resolve3() : reject(error), "settle");
+      });
+      done.catch(() => void 0);
+      hint = { run, done, settle };
+    }
+    roomHints.set(key3, hint);
+    drainRoomHints();
+    return hint.done;
+  }
+  __name(queueRoomHint, "queueRoomHint");
+  function drainRoomHints() {
+    if (roomHintWorker) return;
+    roomHintWorker = (async () => {
+      for (const [key3, hint] of roomHints) {
+        roomHints.delete(key3);
+        if (closed) {
+          hint.settle();
+          continue;
+        }
+        try {
+          await hint.run();
+          hint.settle();
+        } catch (error) {
+          hint.settle(error);
+        }
+      }
+    })().finally(() => {
+      roomHintWorker = void 0;
+      if (roomHints.size) drainRoomHints();
+    });
+  }
+  __name(drainRoomHints, "drainRoomHints");
+  const hintRoom = /* @__PURE__ */ __name((conversationId) => queueRoomHint(`room/${conversationId}`, async () => {
+    await refreshMlsRoomFromHint(conversationId);
+    await sendDeferredOpeners(conversationId);
+  }), "hintRoom");
   const queryObserver = createEndpointQueryObserver({ query: /* @__PURE__ */ __name((name, parameters) => endpoint.query(name, parameters), "query"), getPollInterval: /* @__PURE__ */ __name(() => events.isConnected() ? Math.max(options.queryIntervalMs ?? 0, 6e4) : options.queryIntervalMs ?? 3e3, "getPollInterval") });
   const invalidateEvent = /* @__PURE__ */ __name((event) => queryObserver.invalidate(event ? (query, parameters) => queryAffectedByEvent(event, query, parameters) : void 0), "invalidateEvent");
   const syncConversation = createConversationSynchronizer({ store, query: /* @__PURE__ */ __name((name, parameters) => endpoint.query(name, parameters), "query"), ready: /* @__PURE__ */ __name(() => initialization, "ready"), clock, invalidate: /* @__PURE__ */ __name((conversationId) => invalidateEvent({ kind: "conversation.changed", data: { conversationId } }), "invalidate"), admitRecoveredMessages: options.admitRecoveredMessages, preparationGeneration: /* @__PURE__ */ __name(() => installationGeneration, "preparationGeneration"), prepareProtocol: /* @__PURE__ */ __name((id2) => refreshMlsRoom(id2, true), "prepareProtocol"), syncProtocol: /* @__PURE__ */ __name(async (id2, opts) => {
@@ -7855,19 +7658,20 @@ function createEndpoint(options) {
     return mlsDevGroups.syncText(id2, opts);
   }, "syncProtocol") });
   const events = createEndpointEventHub({ transport, invalidate: invalidateEvent, onDisconnected: /* @__PURE__ */ __name(() => queryObserver.reschedule(), "onDisconnected"), onEvent: /* @__PURE__ */ __name(async (event) => {
+    const hinted = [];
     if (mlsDevGroups && ["conversation.changed", "conversation.updated", "conversation.removed"].includes(event.kind)) {
       const id2 = event.data.conversationId ?? event.data.id;
       if (typeof id2 === "string" && ENDPOINT_ID_PATTERN.test(id2)) {
         if (event.kind === "conversation.changed" && event.data.projection === void 0) forgetStubReads(id2);
         const unseenRemoval = event.kind === "conversation.removed" && await store.transaction(async (tx) => await tx.get(`conversation/${id2}`) === void 0 && !await isMlsDevRoomProtected(tx, id2));
-        if (!unseenRemoval) await refreshMlsRoomFromHint(id2);
-        await sendDeferredOpeners(id2);
+        if (!unseenRemoval) hinted.push(hintRoom(id2));
+        else await sendDeferredOpeners(id2);
       }
     }
     if (mlsDevGroups && event.kind === "conversations.changed" && Array.isArray(event.data.conversationIds)) {
       for (const id2 of event.data.conversationIds) {
         if (typeof id2 === "string" && ENDPOINT_ID_PATTERN.test(id2) && await store.transaction((tx) => isMlsDevRoomProtected(tx, id2))) {
-          await refreshMlsRoomFromHint(id2);
+          hinted.push(hintRoom(id2));
         }
       }
     }
@@ -7879,13 +7683,16 @@ function createEndpoint(options) {
       if (event.kind === "connected") serverRoomMode = void 0;
       for (let after; ; ) {
         const page = await store.transaction((tx) => tx.scan("mls-dev-group/mode/", { after, limit: 100 }));
-        for (const item of page) await refreshMlsRoomFromHint(decodeURIComponent(item.key.slice("mls-dev-group/mode/".length)));
+        for (const item of page) hinted.push(hintRoom(decodeURIComponent(item.key.slice("mls-dev-group/mode/".length))));
         if (page.length < 100) break;
         after = page[page.length - 1].key;
       }
-      await sendDeferredOpeners();
-      await discoverInviteeRooms().catch(() => void 0);
+      hinted.push(queueRoomHint("after/reconnect", async () => {
+        await sendDeferredOpeners();
+        await discoverInviteeRooms().catch(() => void 0);
+      }, true));
     }
+    if (event.id) await Promise.all(hinted);
     if ((event.kind === "message.updated" || event.kind === "message.deleted") && typeof event.data.conversationId === "string" && typeof event.data.messageId === "string" && ENDPOINT_ID_PATTERN.test(event.data.conversationId)) {
       const room = event.data.conversationId, message = event.data.messageId;
       const applied = await store.transaction(async (tx) => {
@@ -7929,6 +7736,13 @@ function createEndpoint(options) {
     }, "assertReady")
   });
   const externalInbound = createExternalInboundClaims({ store, clock, hash, ownershipVersion: options.identity.ownershipVersion, ready: /* @__PURE__ */ __name(() => initialization, "ready"), assertOpen, assertCurrent: assertCurrentInstallation });
+  const completions = createCompletions({
+    store,
+    ready: /* @__PURE__ */ __name(() => initialization, "ready"),
+    assertOpen,
+    assertCurrent: assertCurrentInstallation,
+    settleInbound: /* @__PURE__ */ __name((tx, id2, reason) => writeInboundState(tx, id2, "settled", reason), "settleInbound")
+  });
   const messageGroups = createMessageGroupCoordinator({
     store,
     endpoint: /* @__PURE__ */ __name(() => endpoint, "endpoint"),
@@ -7939,6 +7753,26 @@ function createEndpoint(options) {
     preparationGeneration: /* @__PURE__ */ __name(() => installationGeneration, "preparationGeneration"),
     supportsPreparedContent: /* @__PURE__ */ __name(() => Promise.resolve(negotiatedCapabilities?.preparedContentVersion === 1), "supportsPreparedContent")
   });
+  async function writeInboundState(tx, id2, state, reason) {
+    const recordKey = `inbound/${id2}`;
+    const current = await tx.get(recordKey);
+    if (!current) throw new EndpointError("Inbound operation was not durably received", { code: "INBOUND_NOT_FOUND", retryable: false });
+    if (current.externalClaim) throw new EndpointError("Use the bound external claim to settle this input", { code: "EXTERNAL_INBOUND_CLAIM_REQUIRED", retryable: false });
+    if (current.handoffGeneration && state !== "settled" && state !== "uncertain") throw new EndpointError("Use the input handoff to release or defer managed work", { code: "INBOUND_HANDOFF_REQUIRED", retryable: false });
+    if (current.deleted && !["settled", "uncertain"].includes(state)) throw new EndpointError("Deleted input cannot be replayed", { code: "INBOUND_DELETED", retryable: false });
+    if (current.state === "settled" && state !== "settled") throw new EndpointError("Settled input cannot be replayed", { code: "INBOUND_ALREADY_SETTLED", retryable: false });
+    const next = { ...current, state, ...reason ? { reason } : {}, updatedAt: now() };
+    delete next.lease;
+    if (state === "settled") {
+      delete next.handoffGeneration;
+      delete next.handoffInstallationGeneration;
+    }
+    if (state === "settled") next.event = { ...next.event, data: {} };
+    await tx.put(recordKey, next);
+    if (state === "settled" || state === "uncertain" || current.deleted) await removeInboundReady(tx, current);
+    else await enqueueInbound(tx, next);
+  }
+  __name(writeInboundState, "writeInboundState");
   function deferredReceipt(operation, error) {
     return operation.receipt ?? {
       protocol: CANON_ENDPOINT_PROTOCOL,
@@ -7972,7 +7806,7 @@ function createEndpoint(options) {
       const index = group?.children.findIndex((child) => child.operationId === next.operationId) ?? -1;
       if (group && index >= 0 && !group.cancelled) {
         for (const reference of group.children.slice(index + 1)) {
-          const child = await tx.get(key(reference.operationId));
+          const child = await tx.get(key2(reference.operationId));
           if (!child || messageGroupChildSucceeded(child)) continue;
           if (messageGroupChildSucceeded(next)) {
             if (!terminal(child.status) && child.status !== "uncertain") await enqueueOperation(tx, child);
@@ -7980,7 +7814,7 @@ function createEndpoint(options) {
           }
           if (!child.attempted && !terminal(child.status)) {
             const { request: _plaintext, preparedContent: _sealedPlaintext, ...correlation } = child;
-            await tx.put(key(child.operationId), { ...correlation, status: "rejected", updatedAt: now(), receipt: {
+            await tx.put(key2(child.operationId), { ...correlation, status: "rejected", updatedAt: now(), receipt: {
               protocol: CANON_ENDPOINT_PROTOCOL,
               operationId: child.operationId,
               installationId: child.installationId,
@@ -8000,7 +7834,7 @@ function createEndpoint(options) {
   __name(advanceMessageGroup, "advanceMessageGroup");
   async function commitOperationRecord(tx, created) {
     const ordered = await orderOperation(tx, created);
-    await tx.put(key(created.operationId), ordered);
+    await tx.put(key2(created.operationId), ordered);
     await trackOperationOrder(tx, ordered);
     await enqueueOperation(tx, ordered);
     if (!created.sensitive) await tx.delete(`preparation/${created.operationId}`);
@@ -8011,7 +7845,7 @@ function createEndpoint(options) {
     if (receipt.operationId !== operation.operationId || receipt.installationId !== operation.installationId || receipt.action !== operation.action) {
       throw new EndpointError("Operation receipt identity mismatch", { status: 502, code: "INVALID_RECEIPT" });
     }
-    const current = await tx.get(key(operation.operationId));
+    const current = await tx.get(key2(operation.operationId));
     if (!current) throw new EndpointError("Pending operation was discarded", { code: "OPERATION_DISCARDED", retryable: false });
     const recoveredGroupSuccess = acceptedEcho && ["mls_group_control", "mls_application"].includes(current.action) && receipt.status === "succeeded" && current.status === "rejected";
     if (terminal(current.status) && !recoveredGroupSuccess) return current;
@@ -8026,7 +7860,7 @@ function createEndpoint(options) {
     }
     if (terminal(next.status)) delete next.nextAttemptAt;
     else next.nextAttemptAt = clock() + (typeof receipt.error?.retryAfterMs === "number" && Number.isFinite(receipt.error.retryAfterMs) ? Math.max(1e3, Math.min(3e5, receipt.error.retryAfterMs)) : 1e3);
-    await tx.put(key(operation.operationId), next);
+    await tx.put(key2(operation.operationId), next);
     await settleMlsDevTextOperation(tx, next);
     if (next.action === "delete_message" && next.status === "succeeded" && next.conversationId && next.messageId && await isMlsDevRoomProtected(tx, next.conversationId)) await applyMlsDevDeletion(tx, next.conversationId, next.messageId);
     if (terminal(next.status) || next.status === "uncertain") {
@@ -8070,7 +7904,7 @@ function createEndpoint(options) {
     assertOpen();
     await initialization;
     const { operation, acquired } = await store.transaction(async (tx) => {
-      const current = await tx.get(key(operationId));
+      const current = await tx.get(key2(operationId));
       if (!current) throw new EndpointError("Unknown endpoint operation", { status: 404, code: "OPERATION_NOT_FOUND", retryable: false });
       if (terminal(current.status)) return { operation: current, acquired: false };
       await assertCurrentInstallation(tx);
@@ -8079,7 +7913,7 @@ function createEndpoint(options) {
       if (!reconcileOnly && current.messageGroupId && current.status !== "uncertain") {
         const group = await tx.get(`message-group/${current.messageGroupId}`);
         const index = group?.children.findIndex((child) => child.operationId === operationId) ?? -1;
-        const previous = group && index > 0 ? await tx.get(key(group.children[index - 1].operationId)) : void 0;
+        const previous = group && index > 0 ? await tx.get(key2(group.children[index - 1].operationId)) : void 0;
         if (previous?.status === "rejected" || previous?.status === "succeeded" && !messageGroupChildSucceeded(previous)) {
           const rejected = { ...current, status: "rejected", updatedAt: now(), receipt: {
             protocol: CANON_ENDPOINT_PROTOCOL,
@@ -8093,7 +7927,7 @@ function createEndpoint(options) {
           } };
           delete rejected.request;
           delete rejected.preparedContent;
-          await tx.put(key(operationId), rejected);
+          await tx.put(key2(operationId), rejected);
           await removeOperationOutbox(tx, rejected);
           await settleOperationOrder(tx, rejected);
           return { operation: rejected, acquired: false };
@@ -8102,7 +7936,7 @@ function createEndpoint(options) {
       }
       if (current.lease && current.lease.owner !== owner && current.lease.expiresAt > clock()) return { operation: current, acquired: false };
       const next = { ...current, status: reconcileOnly ? current.status : current.status === "uncertain" ? "uncertain" : "sending", lease: { owner, expiresAt: clock() + leaseMs }, attempts: current.attempts + 1, updatedAt: now() };
-      await tx.put(key(operationId), next);
+      await tx.put(key2(operationId), next);
       return { operation: next, acquired: true };
     });
     if (terminal(operation.status) && operation.receipt) {
@@ -8120,8 +7954,8 @@ function createEndpoint(options) {
     notify(operation);
     const heartbeat = setInterval(() => {
       void store.transaction(async (tx) => {
-        const current = await tx.get(key(operationId));
-        if (current?.lease?.owner === owner) await tx.put(key(operationId), { ...current, lease: { owner, expiresAt: clock() + leaseMs } });
+        const current = await tx.get(key2(operationId));
+        if (current?.lease?.owner === owner) await tx.put(key2(operationId), { ...current, lease: { owner, expiresAt: clock() + leaseMs } });
       }).catch(() => void 0);
     }, Math.floor(leaseMs / 3));
     heartbeat.unref?.();
@@ -8143,11 +7977,11 @@ function createEndpoint(options) {
         const receipt2 = found?.status === "succeeded" || found?.status === "rejected" ? found : { ...deferredReceipt(operation), status: operation.status === "uncertain" ? "uncertain" : "pending" };
         if (reconcileOnly && !terminal(receipt2.status)) {
           await store.transaction(async (tx) => {
-            const current = await tx.get(key(operationId));
+            const current = await tx.get(key2(operationId));
             if (current?.lease?.owner === owner) {
               const next = { ...current };
               delete next.lease;
-              await tx.put(key(operationId), next);
+              await tx.put(key2(operationId), next);
             }
           });
           return receipt2;
@@ -8199,7 +8033,7 @@ function createEndpoint(options) {
       });
       checkingContentMode = false;
       await store.transaction(async (tx) => {
-        const current = await tx.get(key(operationId));
+        const current = await tx.get(key2(operationId));
         if (!current || current.lease?.owner !== owner || terminal(current.status)) throw new EndpointError("Delivery ownership changed", { code: "DELIVERY_FENCED" });
         await assertCurrentInstallation(tx);
         if (current.preparedContent && (await tx.get(PREPARATION_GENERATION_KEY) ?? 0) !== current.preparedContent.expected.installationGeneration) throw new EndpointError("This endpoint installation can no longer dispatch its prepared content", { code: "PREPARATION_INSTALLATION_FENCED", retryable: false });
@@ -8217,7 +8051,7 @@ function createEndpoint(options) {
           const group = await tx.get(`message-group/${current.messageGroupId}`);
           if (group?.cancelled || !messageGroups.allowed(current.messageGroupId)) throw new EndpointError("Message group was cancelled", { code: "OPERATION_DISCARDED", retryable: false });
         }
-        await tx.put(key(operationId), { ...current, attempted: true });
+        await tx.put(key2(operationId), { ...current, attempted: true });
       });
       const receipt = await transport.execute(request, controller.signal);
       await persistReceipt(operation, receipt);
@@ -8226,17 +8060,17 @@ function createEndpoint(options) {
       const failure = safeError(error);
       if (reconcileOnly && failure.retryable) {
         await store.transaction(async (tx) => {
-          const current = await tx.get(key(operationId));
+          const current = await tx.get(key2(operationId));
           if (current?.lease?.owner === owner) {
             const next = { ...current };
             delete next.lease;
-            await tx.put(key(operationId), next);
+            await tx.put(key2(operationId), next);
           }
         });
         return deferredReceipt(operation, failure);
       }
       const updated = await store.transaction(async (tx) => {
-        const current = await tx.get(key(operationId));
+        const current = await tx.get(key2(operationId));
         if (!current) throw failure;
         if (current.lease?.owner !== owner || terminal(current.status)) return current;
         const lookupUncertain = resolvingReceipt && !failure.retryable;
@@ -8263,7 +8097,7 @@ function createEndpoint(options) {
           next.receipt = { protocol: CANON_ENDPOINT_PROTOCOL, operationId: current.operationId, installationId: current.installationId, action: current.action, status: "rejected", error: { code: failure.code, message: current.sensitive ? "Sensitive operation could not complete" : failure.message, status: failure.status, retryable: false }, createdAt: current.createdAt, updatedAt: now() };
           delete next.nextAttemptAt;
         }
-        await tx.put(key(operationId), next);
+        await tx.put(key2(operationId), next);
         await settleMlsDevTextOperation(tx, next);
         if (terminal(next.status) || next.status === "uncertain") {
           await removeOperationOutbox(tx, next);
@@ -8336,7 +8170,7 @@ function createEndpoint(options) {
       const inputFingerprint = sensitive ? void 0 : await hash(canonicalEndpointJson({ ...authored, ...identity.ownershipVersion !== void 0 ? { ownershipVersion: identity.ownershipVersion } : {} }));
       const previous = await store.transaction(async (tx) => {
         await assertCurrentInstallation(tx);
-        return tx.get(key(operationId));
+        return tx.get(key2(operationId));
       });
       if (previous?.inputFingerprint !== void 0 && !sensitive) {
         if (previous.inputFingerprint !== inputFingerprint || previous.guardId !== executeOptions.guardId) {
@@ -8401,7 +8235,7 @@ function createEndpoint(options) {
         ...normalized.preconditions ? { preconditions: normalized.preconditions } : {}
       };
       const existingOperation = /* @__PURE__ */ __name(async (tx) => {
-        const existing = await tx.get(key(operationId));
+        const existing = await tx.get(key2(operationId));
         if (!existing) return void 0;
         if (existing.fingerprint !== fingerprint || existing.sensitive !== sensitive || existing.guardId !== executeOptions.guardId) {
           throw new EndpointError("Operation ID was already used for different content", { status: 409, code: "OPERATION_ID_COLLISION", retryable: false, operationId });
@@ -8429,7 +8263,6 @@ function createEndpoint(options) {
           ...endpointIntentConversationId(normalized) ? { conversationId: endpointIntentConversationId(normalized) } : {},
           ...typeof routedBody.messageId === "string" ? { messageId: routedBody.messageId } : {},
           ...normalized.action === "session_control" && typeof routedBody.agentId === "string" ? { agentId: routedBody.agentId } : {},
-          ...endpointIntentOrdering(normalized) === "artifact" && typeof routedBody.artifactId === "string" ? { artifactId: routedBody.artifactId } : {},
           sensitive,
           status: "queued",
           attempts: 0,
@@ -8495,12 +8328,12 @@ function createEndpoint(options) {
       let dispatched = 0;
       let hasDeferred = false;
       const blockedKeys = /* @__PURE__ */ new Set();
-      for (const ordering of ["independent", "signal", "message", "provider", "artifact", "conversation"]) {
+      for (const ordering of ["independent", "signal", "message", "provider", "conversation"]) {
         let after;
         do {
           const batch = await store.transaction(async (tx) => {
             const entries2 = await tx.scan("outbox/", { after, limit: 100 });
-            return Promise.all(entries2.map(async (entry) => ({ key: entry.key, value: await tx.get(key(entry.value.operationId)) })));
+            return Promise.all(entries2.map(async (entry) => ({ key: entry.key, value: await tx.get(key2(entry.value.operationId)) })));
           });
           for (const entry of batch) {
             after = entry.key;
@@ -8536,7 +8369,7 @@ function createEndpoint(options) {
     },
     async getOperation(operationId) {
       await initialization;
-      return store.transaction((tx) => tx.get(key(operationId)));
+      return store.transaction((tx) => tx.get(key2(operationId)));
     },
     waitForOperation(operationId, waitOptions = {}) {
       return new Promise((resolve3, reject) => {
@@ -8671,9 +8504,9 @@ function createEndpoint(options) {
     },
     refreshQueries: /* @__PURE__ */ __name(() => queryObserver.invalidate(), "refreshQueries"),
     observeEvents: events.observe,
-    createMediaPipeline(bytes, mediaOptions) {
+    createMediaPipeline(bytes) {
       assertOpen();
-      const pipeline3 = createEndpointMediaPipeline({ endpoint, store, bytes, hash, ids, clock, background: mediaOptions?.background });
+      const pipeline3 = createEndpointMediaPipeline({ endpoint, store, bytes, hash, ids, clock });
       mediaPipelines2.add(pipeline3);
       return pipeline3;
     },
@@ -8714,7 +8547,7 @@ function createEndpoint(options) {
       const recordKey = `${openerPrefix()}/${encodeURIComponent(input.messageId)}`;
       await store.transaction(async (tx) => {
         await assertCurrentInstallation(tx);
-        const operation = await tx.get(key(operationId));
+        const operation = await tx.get(key2(operationId));
         if (operation) {
           if (operation.openerFingerprint !== openerFingerprint)
             throw new EndpointError("Opening line ID was already used for different content", { status: 409, code: "OPERATION_ID_COLLISION", retryable: false, operationId });
@@ -8735,7 +8568,7 @@ function createEndpoint(options) {
       });
       try {
         const result = await endpoint.executeResult({ action: "start_conversation", body: { ...body } }, { operationId });
-        if (result.status === "unavailable" && result.reason === "opening-text-required") {
+        if (result.status === "unavailable" && (result.reason === "opening-text-required" || result.reason === "encrypted-room-required")) {
           await store.transaction(async (tx) => {
             await assertCurrentInstallation(tx);
             await tx.delete(recordKey);
@@ -8906,29 +8739,27 @@ function createEndpoint(options) {
         }
       }
       await initialization;
-      await store.transaction(async (tx) => {
-        const recordKey = `inbound/${id2}`;
-        const current = await tx.get(recordKey);
-        if (!current) throw new EndpointError("Inbound operation was not durably received", { code: "INBOUND_NOT_FOUND", retryable: false });
-        if (current.externalClaim) throw new EndpointError("Use the bound external claim to settle this input", { code: "EXTERNAL_INBOUND_CLAIM_REQUIRED", retryable: false });
-        if (current.handoffGeneration && state !== "settled" && state !== "uncertain") throw new EndpointError("Use the input handoff to release or defer managed work", { code: "INBOUND_HANDOFF_REQUIRED", retryable: false });
-        if (current.deleted && !["settled", "uncertain"].includes(state)) throw new EndpointError("Deleted input cannot be replayed", { code: "INBOUND_DELETED", retryable: false });
-        if (current.state === "settled" && state !== "settled") throw new EndpointError("Settled input cannot be replayed", { code: "INBOUND_ALREADY_SETTLED", retryable: false });
-        const next = { ...current, state, ...reason ? { reason } : {}, updatedAt: now() };
-        delete next.lease;
-        if (state === "settled") {
-          delete next.handoffGeneration;
-          delete next.handoffInstallationGeneration;
-        }
-        if (state === "settled") next.event = { ...next.event, data: {} };
-        await tx.put(recordKey, next);
-        if (state === "settled" || state === "uncertain" || current.deleted) await removeInboundReady(tx, current);
-        else await enqueueInbound(tx, next);
-      });
+      await store.transaction((tx) => writeInboundState(tx, id2, state, reason));
     },
     async listInbound(listOptions = {}) {
       await initialization;
-      return store.transaction((tx) => matchingRecords(tx, "inbound/", listOptions, (entry) => !listOptions.states || listOptions.states.includes(entry.state)));
+      return store.transaction(async (tx) => {
+        const answered = listOptions.unanswered ? await completions.answered(tx) : void 0;
+        return matchingRecords(tx, "inbound/", listOptions, (entry) => (!listOptions.states || listOptions.states.includes(entry.state)) && !answered?.has(entry.event.id));
+      });
+    },
+    saveCompletion: completions.save,
+    getCompletion: completions.get,
+    listCompletions: completions.list,
+    replaceCompletion: completions.replace,
+    async finishCompletion(id2, settle) {
+      for (const inputId of new Set(settle?.inputIds ?? [])) {
+        const managed = handoffs.settle(inputId, settle.reason);
+        if (managed && !await managed && (await endpoint.getInbound(inputId))?.state !== "settled") {
+          throw new EndpointError("Input ownership changed before reconciliation", { code: "INBOUND_HANDOFF_LOST", retryable: false });
+        }
+      }
+      await completions.finish(id2, settle);
     },
     async discardPending() {
       await initialization;
@@ -8979,7 +8810,7 @@ function createEndpoint(options) {
       listeners.clear();
       closing = (async () => {
         await Promise.allSettled([handoffs.close(), recovery.close(), syncConversation.close(), events.close(), ...[...consumers].map((consumer) => consumer.close()), ...[...mediaPipelines2].map((pipeline3) => pipeline3.close({ discard: true }))]);
-        await Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization]);
+        await Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization, roomHintWorker]);
         await endpoint.discardPending();
         await eraseEndpointPlaintext(store);
         await store.close();
@@ -9002,11 +8833,10 @@ function createEndpoint(options) {
       sensitiveRequests.clear();
       sensitiveFingerprints.clear();
       listeners.clear();
-      closing = Promise.allSettled([handoffs.close(), recovery.close(), syncConversation.close(), events.close(), ...[...consumers].map((consumer) => consumer.close()), ...[...mediaPipelines2].map((pipeline3) => pipeline3.close())]).then(() => Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization])).then(() => store.close());
+      closing = Promise.allSettled([handoffs.close(), recovery.close(), syncConversation.close(), events.close(), ...[...consumers].map((consumer) => consumer.close()), ...[...mediaPipelines2].map((pipeline3) => pipeline3.close())]).then(() => Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization, roomHintWorker])).then(() => store.close());
       return closing;
     }
   };
-  registerArtifactEndpoint(endpoint, { store, closed: /* @__PURE__ */ __name(() => closed, "closed"), assertCurrent: assertCurrentInstallation });
   void initialization.then(() => scheduleRetry(0)).catch(() => void 0);
   void initialization.then(() => sendDeferredOpeners()).catch(() => void 0);
   if (mlsDevGroups) void initialization.then(() => resumeHeldTexts()).catch(() => void 0);
@@ -9064,7 +8894,7 @@ async function acquireAgentEndpoint(input) {
   }
   const requestedMls = input.options.mlsDev;
   const mls = requestedMls ? await (async () => {
-    const crypto2 = await import("./mls-crypto-NZVMSUFU.js");
+    const crypto2 = await import("./mls-crypto-ZBEC26B5.js");
     const configuration = crypto2.parseMlsDevClientConfiguration(requestedMls.configuration);
     if (configuration.environmentId !== environmentId || baseUrl !== CANON_RUNTIME_ENDPOINT_DEFAULTS[configuration.environmentId]?.apiBaseUrl || configuration.principalIds && !configuration.principalIds.includes(input.principalId) || !Number.isSafeInteger(input.ownershipVersion) || input.ownershipVersion < 0) throw new Error("MLS_DEV_AGENT_CONFIGURATION_BINDING_MISMATCH");
     const custody = requestedMls.custody;
@@ -9098,12 +8928,12 @@ async function acquireAgentEndpoint(input) {
 ${baseUrl}
 ${input.principalId}
 ${input.ownershipVersion}`).digest("hex");
-  const key = `${directory}
+  const key2 = `${directory}
 ${namespace}
 ${input.options.autoDrain === false ? "operator" : "live"}`;
-  let entry = endpoints.get(key);
+  let entry = endpoints.get(key2);
   if (entry && entry.installationId !== input.options.installationId) throw new Error("Canon endpoint is already open under another installation.");
-  if (entry && (!!entry.mlsDev !== !!mls || mls && (entry.mlsDev?.fingerprint !== mls.fingerprint || entry.mlsDev.custody !== mls.custody || Object.keys(mls.callbacks).some((key2) => entry.mlsDev.callbacks[key2] !== mls.callbacks[key2])))) {
+  if (entry && (!!entry.mlsDev !== !!mls || mls && (entry.mlsDev?.fingerprint !== mls.fingerprint || entry.mlsDev.custody !== mls.custody || Object.keys(mls.callbacks).some((key3) => entry.mlsDev.callbacks[key3] !== mls.callbacks[key3])))) {
     throw new Error("MLS_DEV_AGENT_SHARED_CONFIGURATION_MISMATCH");
   }
   if (!entry) {
@@ -9143,9 +8973,9 @@ ${input.options.autoDrain === false ? "operator" : "live"}`;
       autoDrain: input.options.autoDrain
     }));
     entry = shared;
-    endpoints.set(key, entry);
+    endpoints.set(key2, entry);
     void entry.endpoint.catch(() => {
-      if (endpoints.get(key) === entry) endpoints.delete(key);
+      if (endpoints.get(key2) === entry) endpoints.delete(key2);
     });
   }
   entry.token = input.apiKey;
@@ -9162,8 +8992,8 @@ ${input.options.autoDrain === false ? "operator" : "live"}`;
     if (released) return;
     released = true;
     entry.references--;
-    if (entry.references === 0 && endpoints.get(key) === entry) {
-      endpoints.delete(key);
+    if (entry.references === 0 && endpoints.get(key2) === entry) {
+      endpoints.delete(key2);
       await endpoint.close();
     }
   } };
@@ -9395,42 +9225,6 @@ var CanonClient = class {
       delivery?.operationId ?? (options?.messageId ? stableOperationId("send_message", conversationId, options.messageId) : void 0)
     );
   }
-  /** Inspect a trusted reply's durable delivery without rebuilding its body. */
-  async getMessageOperation(conversationId, messageId, delivery) {
-    const endpoint = await this.getEndpoint();
-    const group = await endpoint.getMessageGroup(delivery?.operationId ?? stableOperationId("send_group", conversationId, messageId));
-    if (group) return group;
-    const operation = await endpoint.getOperation(delivery?.operationId ?? stableOperationId("send_message", conversationId, messageId));
-    if (operation) return operation;
-    const firstPart = `${messageId.slice(0, 153)}-part-1`;
-    if (await endpoint.getOperation(delivery?.operationId ? `${delivery.operationId.slice(0, 153)}-part-1` : stableOperationId("send_message", conversationId, firstPart))) {
-      throw new CanonApiError(409, JSON.stringify({ code: "OPERATION_UNCERTAIN", message: "Existing message parts require aggregate delivery reconciliation" }));
-    }
-    return void 0;
-  }
-  /** Core's chunker records all ordered message intents before publishing any part. */
-  async prepareMessageGroup(conversationId, messageId, parts, delivery) {
-    const id2 = delivery?.operationId ?? stableOperationId("send_group", conversationId, messageId);
-    try {
-      const endpoint = await this.getEndpoint();
-      const group = await endpoint.registerMessageGroup({ id: id2, ...delivery?.replacesOperationId ? { replacesOperationId: delivery.replacesOperationId } : {}, children: parts.map((part, index) => ({
-        operationId: delivery?.operationId ? `${delivery.operationId.slice(0, 160 - `-part-${index + 1}`.length)}-part-${index + 1}` : stableOperationId("send_message", conversationId, part.options.messageId),
-        intent: { action: "send_message", body: { conversationId, text: part.text, ...part.options } }
-      })) }, { signal: delivery?.signal });
-      return { id: id2, sendPart: /* @__PURE__ */ __name(async (index, options) => {
-        const operationId = group.childOperationIds?.[index];
-        if (!operationId) throw new Error("Unknown message group part");
-        if (options?.signal?.aborted) throw new CanonApiError(409, JSON.stringify({ code: "OPERATION_PENDING", message: "Reply delivery was interrupted" }));
-        await endpoint.retry(operationId);
-        return this.waitForOperation(operationId, options);
-      }, "sendPart") };
-    } catch (error) {
-      throw asCanonApiError(error);
-    }
-  }
-  async cancelMessageGroup(id2) {
-    await (await this.getEndpoint()).cancelMessageGroup(id2);
-  }
   /**
    * Execute a canonical verb over the wire contract (canon.verb-wire.v1).
    * Bindings build the request with projectVerbIntentToWire; the endpoint
@@ -9674,27 +9468,18 @@ var CanonClient = class {
   async deleteMessage(conversationId, messageId) {
     await this.endpointAction("delete_message", { conversationId, messageId });
   }
-  async updateMessageDisposition(conversationId, messageId, inboundDisposition) {
-    await this.endpointAction("update_message_disposition", { conversationId, messageId, inboundDisposition });
-  }
   async markAsRead(conversationId) {
     await this.endpointAction("mark_read", { conversationId });
   }
   async react(conversationId, messageId, emoji) {
     await this.endpointAction("react", { conversationId, messageId, emoji });
   }
-  async setStreaming(options) {
-    await this.endpointPublish("publish_streaming", { ...options });
-  }
   async clearStreaming(conversationId) {
     await this.endpointPublish("publish_streaming", { conversationId, streaming: false });
   }
   async setRuntimeTurn(options) {
     await this.endpointPublish("publish_turn", { ...options });
   }
-  async setTyping(conversationId, typing, status) {
-    await this.endpointPublish("publish_typing", { conversationId, typing, ...status ? { status } : {} });
-  }
   async peekRuntimeSignal(conversationId) {
     return this.endpointQuery("peek_runtime_signal", { conversationId });
   }
@@ -9736,38 +9521,6 @@ var CanonClient = class {
   async patchRuntimeStreaming(conversationId, patch) {
     await this.endpointPublish("publish_streaming", { ...patch, conversationId });
   }
-  async createRuntimeInputRequest(options) {
-    return this.endpointAction("create_interaction", { ...options, interactionKind: "input" });
-  }
-  async consumeRuntimeInputResponse(options) {
-    return this.endpointAction("consume_interaction", { ...options, interactionKind: "input" });
-  }
-  async createRuntimeApprovalRequest(options) {
-    return this.endpointAction("create_interaction", { ...options, interactionKind: "approval" });
-  }
-  async consumeRuntimeApprovalResponse(options) {
-    return this.endpointAction("consume_interaction", { ...options, interactionKind: "approval" });
-  }
-  async createRuntimeCardRequest(options) {
-    return this.endpointAction("create_interaction", { ...options, interactionKind: "card" });
-  }
-  async consumeRuntimeCardResponse(options) {
-    return this.endpointAction("consume_interaction", { ...options, interactionKind: "card" });
-  }
-  /**
-   * Create a server-owned plan-approval interaction.
-   *
-   * Seeds the pending node + attention + runtime-card state and authors the
-   * `plan_approval` card message, mirroring the other `createRuntime*Request`
-   * spine methods. Hosts resolve it through `consumeRuntimePlanResponse()` so
-   * the canonical pending state, rather than a timeline receipt, is authoritative.
-   */
-  async createRuntimePlanRequest(options) {
-    return this.endpointAction("create_interaction", { ...options, interactionKind: "plan" });
-  }
-  async consumeRuntimePlanResponse(options) {
-    return this.endpointAction("consume_interaction", { ...options, interactionKind: "plan" });
-  }
   async updateRuntimeStatus(options) {
     await this.endpointPublish("publish_runtime_status", { ...options });
   }
@@ -10027,7 +9780,7 @@ async function resumeRegistration(options) {
   };
   let session = await store.load();
   if (session) {
-    if (Object.entries(binding).some(([key, value]) => session[key] !== value)) {
+    if (Object.entries(binding).some(([key2, value]) => session[key2] !== value)) {
       throw new Error("Pending registration belongs to another Canon environment or endpoint set");
     }
     if (session.ownerPhone && session.ownerPhone !== input.ownerPhone || input.requestedAgentId && input.requestedAgentId !== session.requestedAgentId || input.localRegistrationId && input.localRegistrationId !== session.localRegistrationId) {
@@ -10440,7 +10193,7 @@ function normalizePendingRegistration(name, value) {
     "createdAt",
     "updatedAt"
   ];
-  if (requiredStrings.some((field) => typeof pending[field] !== "string" || !pending[field]) || pending.profile !== name || pending.requestId !== void 0 && typeof pending.requestId !== "string" || pending.pollToken !== void 0 && typeof pending.pollToken !== "string" || pending.clientType !== void 0 && typeof pending.clientType !== "string" || ["ownerPhone", "requestedAgentId", "credentialAgentId"].some((key) => pending[key] !== void 0 && typeof pending[key] !== "string")) {
+  if (requiredStrings.some((field) => typeof pending[field] !== "string" || !pending[field]) || pending.profile !== name || pending.requestId !== void 0 && typeof pending.requestId !== "string" || pending.pollToken !== void 0 && typeof pending.pollToken !== "string" || pending.clientType !== void 0 && typeof pending.clientType !== "string" || ["ownerPhone", "requestedAgentId", "credentialAgentId"].some((key2) => pending[key2] !== void 0 && typeof pending[key2] !== "string")) {
     throw new Error(
       `${PENDING_REGISTRATIONS_PATH} entry "${name}" must include a complete environment binding`
     );
@@ -10521,7 +10274,7 @@ async function ensureAgentProfile(options) {
   const existing = loadProfiles()[profile];
   const pending = loadPendingRegistrations()[profile];
   if (!pending && existing && !options.reconnect) {
-    if (Object.entries(binding).some(([key, value]) => existing[key] !== value) || input.requestedAgentId && input.requestedAgentId !== existing.agentId) {
+    if (Object.entries(binding).some(([key2, value]) => existing[key2] !== value) || input.requestedAgentId && input.requestedAgentId !== existing.agentId) {
       throw new Error("Saved Canon profile belongs to another environment or agent identity");
     }
     await verifyCanonRuntimeConnection(connection);
@@ -10547,7 +10300,7 @@ async function ensureAgentProfile(options) {
       }, "save"),
       loadCredentials: /* @__PURE__ */ __name(() => {
         const saved = loadProfiles()[profile];
-        if (saved && Object.entries(binding).some(([key, value]) => saved[key] !== value)) {
+        if (saved && Object.entries(binding).some(([key2, value]) => saved[key2] !== value)) {
           throw new Error("Saved registration credential belongs to another Canon environment or endpoint set");
         }
         return saved;
@@ -10701,7 +10454,7 @@ function createRTDBClientHandle(client) {
     if (target.family === "streaming") {
       if (clear) return client.clearStreaming(target.conversationId);
       const { updatedAt: _updatedAt, startedAt: _startedAt, ...patch2 } = record5(data);
-      if (Object.keys(patch2).some((key) => !["text", "status", "messageId", "turnId", "blocks"].includes(key))) throw new Error("Unsupported streaming projection field");
+      if (Object.keys(patch2).some((key2) => !["text", "status", "messageId", "turnId", "blocks"].includes(key2))) throw new Error("Unsupported streaming projection field");
       return client.patchRuntimeStreaming(target.conversationId, patch2);
     }
     if (target.family === "turn-state") {
@@ -11206,125 +10959,6 @@ function runCli(moduleUrl, main, onError, metadata) {
 }
 __name(runCli, "runCli");
 
-// ../core/src/completed-output-journal.ts
-import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
-import {
-  closeSync as closeSync3,
-  existsSync as existsSync2,
-  fsyncSync,
-  mkdirSync as mkdirSync2,
-  openSync as openSync3,
-  readFileSync as readFileSync4,
-  readdirSync,
-  renameSync as renameSync2,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync3
-} from "node:fs";
-import { join as join4 } from "node:path";
-function createCompletedOutputJournal(directory, scope5, options) {
-  const label = options.label;
-  const folder = join4(directory, createHash4("sha256").update(JSON.stringify(scope5)).digest("hex"));
-  const filename = /* @__PURE__ */ __name((turnId) => join4(folder, `${createHash4("sha256").update(turnId).digest("hex")}.json`), "filename");
-  function syncDirectory() {
-    if (process.platform === "win32") return;
-    const fd = openSync3(folder, "r");
-    try {
-      fsyncSync(fd);
-    } finally {
-      closeSync3(fd);
-    }
-  }
-  __name(syncDirectory, "syncDirectory");
-  function validate(record6) {
-    if (record6?.version !== 1 || typeof record6.turnId !== "string" || !record6.turnId || typeof record6.conversationId !== "string" || !record6.conversationId || typeof record6.createdAt !== "string" || options.validate && !options.validate(record6)) {
-      throw new Error(`Invalid completed ${label} output record; operator reconciliation is required`);
-    }
-  }
-  __name(validate, "validate");
-  function recoverTemporaryFiles() {
-    for (const name of readdirSync(folder)) {
-      const match = /^([a-f0-9]{64})\.(\d+)\.[a-f0-9-]+\.tmp$/.exec(name);
-      if (!match) continue;
-      try {
-        process.kill(Number(match[2]), 0);
-        continue;
-      } catch (error) {
-        if (error.code !== "ESRCH") continue;
-      }
-      const path = join4(folder, name);
-      let record6;
-      try {
-        record6 = JSON.parse(readFileSync4(path, "utf8"));
-        validate(record6);
-      } catch {
-        unlinkSync3(path);
-        throw new Error(`Incomplete ${label} output write removed; reconcile its native transcript`);
-      }
-      const destination = filename(record6.turnId);
-      if (destination !== join4(folder, `${match[1]}.json`)) {
-        throw new Error(`Completed ${label} output temporary file identity mismatch`);
-      }
-      if (existsSync2(destination)) {
-        if (readFileSync4(destination, "utf8") !== JSON.stringify(record6)) {
-          throw new Error(`Conflicting completed ${label} outputs require reconciliation`);
-        }
-        unlinkSync3(path);
-      } else renameSync2(path, destination);
-      syncDirectory();
-    }
-  }
-  __name(recoverTemporaryFiles, "recoverTemporaryFiles");
-  return {
-    save(record6) {
-      validate(record6);
-      mkdirSync2(folder, { recursive: true, mode: 448 });
-      const path = filename(record6.turnId);
-      const serialized = JSON.stringify(record6);
-      if (existsSync2(path)) {
-        if (readFileSync4(path, "utf8") !== serialized) throw new Error(`Completed ${label} output cannot be replaced`);
-        return;
-      }
-      const temporary = `${path.slice(0, -5)}.${process.pid}.${randomUUID6()}.tmp`;
-      try {
-        const fd = openSync3(temporary, "wx", 384);
-        try {
-          writeFileSync3(fd, serialized);
-          fsyncSync(fd);
-        } finally {
-          closeSync3(fd);
-        }
-        renameSync2(temporary, path);
-        syncDirectory();
-      } catch (error) {
-        try {
-          unlinkSync3(temporary);
-        } catch {
-        }
-        throw error;
-      }
-    },
-    list() {
-      if (!existsSync2(folder)) return [];
-      recoverTemporaryFiles();
-      return readdirSync(folder).filter((name) => name.endsWith(".json")).map((name) => {
-        const record6 = JSON.parse(readFileSync4(join4(folder, name), "utf8"));
-        validate(record6);
-        if (filename(record6.turnId) !== join4(folder, name)) throw new Error(`Completed ${label} output identity mismatch`);
-        return record6;
-      }).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-    },
-    remove(turnId) {
-      try {
-        unlinkSync3(filename(turnId));
-        syncDirectory();
-      } catch (error) {
-        if (error.code !== "ENOENT") throw error;
-      }
-    }
-  };
-}
-__name(createCompletedOutputJournal, "createCompletedOutputJournal");
-
 // src/bounded-file-read.ts
 var BoundedFileReadError = class extends Error {
   constructor(failure) {
@@ -11368,7 +11002,7 @@ var ANTHROPIC_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
   "image/gif",
   "image/webp"
 ]);
-var DEFAULT_MEDIA_CACHE_DIR = join5(CANON_DIR, "media-cache");
+var DEFAULT_MEDIA_CACHE_DIR = join4(CANON_DIR, "media-cache");
 var DEFAULT_MEDIA_MATERIALIZATION_BYTES = 10 * 1024 * 1024;
 var MAX_CANON_MEDIA_BYTES = 100 * 1024 * 1024;
 var MAX_ANTHROPIC_IMAGE_RAW_BYTES = 7 * 1024 * 1024;
@@ -11436,7 +11070,7 @@ function inferExtension(input) {
 }
 __name(inferExtension, "inferExtension");
 function conversationMediaCacheDir(input) {
-  return join5(
+  return join4(
     input.rootDir ?? DEFAULT_MEDIA_CACHE_DIR,
     sanitizeSegment(input.agentId, "agent"),
     sanitizeSegment(input.conversationId, "conversation")
@@ -11452,7 +11086,7 @@ function buildCachePath(input) {
   const fallbackName = `${input.attachment.kind}-${input.index}${extension}`;
   const preferredName = input.attachment.fileName ? sanitizeDownloadFileName(input.attachment.fileName, fallbackName) : fallbackName;
   const fileName = extname(preferredName) ? preferredName : `${preferredName}${extension}`;
-  return join5(
+  return join4(
     conversationMediaCacheDir({ agentId: input.agentId, conversationId: input.conversationId, rootDir }),
     sanitizeSegment(input.messageId, "message"),
     `${String(input.index).padStart(2, "0")}-${fileName}`
@@ -11602,7 +11236,7 @@ async function materializeAttachment(attachment, options) {
     if (!response.body) {
       throw new Error("Canon media response had no body");
     }
-    const tempPath = `${path}.${process.pid}.${randomUUID7()}.part`;
+    const tempPath = `${path}.${process.pid}.${randomUUID6()}.part`;
     const limiter = byteLimitTransform(maxBytes);
     try {
       await pipeline2(
@@ -11698,7 +11332,7 @@ async function uploadMediaFile(client, conversationId, filePath, options) {
   const media = await client.getFileMediaPipeline(options?.fetchImpl);
   const [attachment] = await media.prepare({
     conversationId,
-    attachmentId: options?.attachmentId ?? randomUUID7(),
+    attachmentId: options?.attachmentId ?? randomUUID6(),
     files: [{ source: filePath, descriptor: {
       mimeType,
       sizeBytes: fileStat.size,
@@ -11727,7 +11361,7 @@ async function sendMediaFileMessage(client, conversationId, filePath, text = "",
     const current = await client.getConversation(conversationId);
     return !!current && originalMembers.size > 0 && current.memberIds.every((id2) => originalMembers.has(id2)) && canPublish();
   } : void 0;
-  const messageId = sendOptions.messageId ?? randomUUID7();
+  const messageId = sendOptions.messageId ?? randomUUID6();
   const pipeline3 = await client.getFileMediaPipeline(fetchImpl);
   const delivered = await pipeline3.send({
     conversationId,
@@ -11909,7 +11543,6 @@ export {
   splitTextWithinBytes,
   readCliPackageVersion,
   runCli,
-  createCompletedOutputJournal,
   BoundedFileReadError,
   readBoundedRegularFileHandle,
   DEFAULT_MEDIA_CACHE_DIR,