@canonmsg/agent-sdk 13.1.0 → 13.2.0

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

@@ -111,9 +111,9 @@ import {
 
 // 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 +154,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 +522,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 +535,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) {
@@ -597,10 +597,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");
@@ -621,7 +621,7 @@ var outboundPrefix = /* @__PURE__ */ __name((operation) => operationOrderingKey(
 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 +634,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 +913,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 +958,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 +1052,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 +1068,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);
         }
       };
     },
@@ -1224,7 +1224,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 +1263,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 +1278,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 +1312,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 +1340,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 +1356,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 +1563,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 +1608,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 +1620,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")
       }));
@@ -3184,6 +3184,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) {
@@ -3365,12 +3449,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 +3493,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 +3865,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 +4301,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 +4326,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 +4350,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 +4361,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 +4371,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 +4381,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 +4533,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 +5032,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 +5198,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 +5219,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 +5330,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 +5470,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 +5866,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 +5891,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 +5908,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 +6001,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 +6046,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 +6234,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 +6257,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 +6275,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 +6536,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 +6547,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 +6570,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 +7242,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 +7820,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 +7836,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;
@@ -7929,6 +8013,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 +8030,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 +8083,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 +8091,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 +8111,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 +8122,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 +8137,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 +8181,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 +8190,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 +8204,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 +8213,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 +8231,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 +8254,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 +8310,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 +8328,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 +8337,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 +8374,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 +8447,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 +8512,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 });
@@ -8500,7 +8611,7 @@ function createEndpoint(options) {
         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 +8647,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) => {
@@ -8714,7 +8825,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 +8846,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 +9017,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;
@@ -9098,12 +9207,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 +9252,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 +9271,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 +9504,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 +9747,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 +9800,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 +10059,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 +10472,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 +10553,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 +10579,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 +10733,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 +11238,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 +11281,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 +11349,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 +11365,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 +11515,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 +11611,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 +11640,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 +11822,6 @@ export {
   splitTextWithinBytes,
   readCliPackageVersion,
   runCli,
-  createCompletedOutputJournal,
   BoundedFileReadError,
   readBoundedRegularFileHandle,
   DEFAULT_MEDIA_CACHE_DIR,