@canonmsg/agent-sdk 12.6.1 → 13.0.3

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

@@ -5,7 +5,7 @@ import {
   createHttpEndpointTransport,
   createNodeEndpointStore,
   validateEndpointContentBoundary
-} from "./chunk-FVYKLH6I.js";
+} from "./chunk-YJUPKU47.js";
 import {
   CANON_ENDPOINT_PROTOCOL,
   CANON_VERB_WIRE_SCHEMA_VERSION,
@@ -42,6 +42,7 @@ import {
   isMlsPrincipalAlias,
   logicalMediaBlobId,
   mergeDeliveryObservation,
+  mlsAdmissionWait,
   mlsDevProtocolCarriesCards,
   normalizePublicRuntimeDescriptor,
   normalizePublicRuntimeFacts,
@@ -106,11 +107,11 @@ import {
   readMembershipChangeMetadata,
   resolveAllowedUploadMimeType,
   sanitizeDownloadFileName
-} from "./chunk-S7BV74DN.js";
+} from "./chunk-5WPAB5MB.js";
 
 // src/media.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID7 } 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 { Readable, Transform as Transform2 } from "node:stream";
@@ -4904,6 +4905,38 @@ async function isMlsDevOwnAnswerSending(tx, conversationId, agentId, requestId)
   return !!authored && authored.feedOrdinal === null && (authored.status === "queued" || authored.status === "uncertain");
 }
 __name(isMlsDevOwnAnswerSending, "isMlsDevOwnAnswerSending");
+var mlsDevHeldTextPrefix = /* @__PURE__ */ __name((conversationId) => `mls-dev-group/held-text/${conversationId === void 0 ? "" : `${encoded2(conversationId)}/`}`, "mlsDevHeldTextPrefix");
+var mlsDevHeldTextKey = /* @__PURE__ */ __name((conversationId, messageId) => `${mlsDevHeldTextPrefix(conversationId)}${encoded2(messageId)}`, "mlsDevHeldTextKey");
+async function readMlsDevHeldTexts(tx, conversationId) {
+  const rows = await tx.scan(mlsDevHeldTextPrefix(conversationId), { limit: MLS_DEV_HELD_TEXT_MAX });
+  return rows.map((row) => row.value).sort((a, b) => a.sequence - b.sequence);
+}
+__name(readMlsDevHeldTexts, "readMlsDevHeldTexts");
+var MLS_DEV_HELD_TEXT_MAX = 100;
+async function projectMlsDevHeldText(tx, value, account) {
+  const { body } = value;
+  const quote = body.replyTo ? mlsDevReplyQuote(
+    await tx.get(mlsDevTextMessageKey(body.conversationId, body.replyTo)),
+    MLS_DEV_REPLY_QUOTE_MAX_CHARACTERS
+  ) : void 0;
+  return {
+    id: body.messageId,
+    conversationId: body.conversationId,
+    senderId: account({ type: value.senderType, id: value.senderId }),
+    senderType: value.senderType,
+    contentType: "text",
+    text: body.text,
+    mentions: body.mentions ?? [],
+    attachments: [],
+    replyTo: body.replyTo ?? null,
+    ...quote ? { replyQuote: quote } : {},
+    status: value.failed ? "failed" : "sending",
+    deleted: false,
+    createdAt: new Date(value.createdAtMs).toISOString(),
+    mlsFeedOrdinal: null
+  };
+}
+__name(projectMlsDevHeldText, "projectMlsDevHeldText");
 var mlsDevTextDeletedKey = /* @__PURE__ */ __name((conversationId, messageId) => `mls-dev-group/message-deleted/${encoded2(conversationId)}/${encoded2(messageId)}`, "mlsDevTextDeletedKey");
 var mlsDevTextReactionsKey = /* @__PURE__ */ __name((conversationId, messageId) => `mls-dev-group/message-reactions/${encoded2(conversationId)}/${encoded2(messageId)}`, "mlsDevTextReactionsKey");
 var erased = /* @__PURE__ */ __name((value) => {
@@ -5036,7 +5069,8 @@ async function queryMlsDevTextHistory(tx, conversationId, name, parameters, audi
     const messages2 = [], missingMessageIds = [];
     for (const id2 of parameters.messageIds) {
       const value = await tx.get(mlsDevTextMessageKey(conversationId, id2));
-      const projected = value && await projectLocal(tx, value, audience);
+      const held = value ? void 0 : await tx.get(mlsDevHeldTextKey(conversationId, id2));
+      const projected = value ? await projectLocal(tx, value, audience) : held && await projectMlsDevHeldText(tx, held, audience.account);
       if (projected) messages2.push(projected);
       else missingMessageIds.push(id2);
     }
@@ -5060,10 +5094,15 @@ async function queryMlsDevTextHistory(tx, conversationId, name, parameters, audi
     return { ...row.value, ordinal: position };
   });
   const messages = [];
-  if (parameters.before === void 0) for (const row of await tx.scan(pendingPrefix(conversationId), { limit: 100 })) {
-    const value = await tx.get(mlsDevTextMessageKey(conversationId, row.value.messageId));
-    const projected = value && await projectLocal(tx, value, audience);
-    if (projected) messages.push(projected);
+  if (parameters.before === void 0) {
+    for (const held of (await readMlsDevHeldTexts(tx, conversationId)).reverse()) {
+      if (await tx.get(mlsDevTextMessageKey(conversationId, held.body.messageId)) === void 0) messages.push(await projectMlsDevHeldText(tx, held, audience.account));
+    }
+    for (const row of await tx.scan(pendingPrefix(conversationId), { limit: 100 })) {
+      const value = await tx.get(mlsDevTextMessageKey(conversationId, row.value.messageId));
+      const projected = value && await projectLocal(tx, value, audience);
+      if (projected) messages.push(projected);
+    }
   }
   for (const item of selected) {
     const value = await tx.get(mlsDevTextMessageKey(conversationId, item.messageId));
@@ -5166,6 +5205,7 @@ var recoveryFailureKey = /* @__PURE__ */ __name((id2) => `mls-dev-group/recovery
 var authorityKey = /* @__PURE__ */ __name((id2) => `mls-dev-group/authority/${encodeURIComponent(id2)}`, "authorityKey");
 var acceptedKey = /* @__PURE__ */ __name((id2, sequence) => `mls-dev-group/accepted/${encodeURIComponent(id2)}/${sequence}`, "acceptedKey");
 var feedKey = /* @__PURE__ */ __name((id2) => `mls-dev-group/feed/${encodeURIComponent(id2)}`, "feedKey");
+var missedEarlierKey = /* @__PURE__ */ __name((id2) => `mls-dev-group/missed-earlier/${encodeURIComponent(id2)}`, "missedEarlierKey");
 var feedEntryKey = /* @__PURE__ */ __name((id2, ordinal3) => `mls-dev-group/feed-entry/${encodeURIComponent(id2)}/${ordinal3}`, "feedEntryKey");
 var appIntentKey = /* @__PURE__ */ __name((operationId) => `mls-dev-group/application/${encodeURIComponent(operationId)}`, "appIntentKey");
 var appOperationKey = /* @__PURE__ */ __name((deviceId, operationId) => `mls-dev-group/application-operation/${encodeURIComponent(deviceId)}/${encodeURIComponent(operationId)}`, "appOperationKey");
@@ -5433,6 +5473,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
           return { changed: false, operation: void 0 };
         }
         if (feed) await checkFeedEntry(tx, current, conversationId, feed);
+        if (!current.envelope?.head && current.envelope?.pending?.control.kind === "create" && current.envelope.pending.operationId !== accepted.operationId) fail6("MLS_DEV_GROUP_PENDING_CONTROL", true);
         const rejoining = !!current.envelope && accepted.control.kind === "add" && accepted.control.keyPackageClaim?.recipientDeviceId === current.device.registration.device.deviceId && accepted.head.sequence > (current.envelope.head?.sequence ?? 0);
         if (current.envelope?.removed && !rejoining) fail6("MLS_DEV_GROUP_REMOVED");
         if (current.envelope?.head && !rejoining && (!same6(accepted.control.expectedHead, current.envelope.head) || accepted.head.sequence !== current.envelope.head.sequence + 1)) fail6("MLS_DEV_GROUP_CONTROL_GAP", true);
@@ -5840,6 +5881,8 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
           observedSequence: current.envelope?.head?.sequence ?? 0
         });
         await rememberMlsDevRoomMode(tx, cid, response.marker);
+        if (initialWelcome && captured.feedOrdinal === 0 && first.kind === "control" && first.ordinal > first.accepted.head.sequence)
+          await tx.put(missedEarlierKey(cid), true);
       });
       for (const entry of response.entries) {
         if (entry.kind === "control") {
@@ -5897,17 +5940,35 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     }
   }
   __name(validItem, "validItem");
+  function validText(text) {
+    try {
+      parseMlsDevTextPayload({
+        version: 1,
+        kind: "text",
+        conversationId: "validation",
+        groupId: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+        messageId: "validation",
+        operationId: "validation",
+        senderDeviceId: "00000000-0000-4000-8000-000000000000",
+        text
+      });
+    } catch {
+      fail6("MLS_DEV_TEXT_INVALID");
+    }
+  }
+  __name(validText, "validText");
   function textInput(value) {
-    const data = record4(value, ["conversationId"], ["text", "messageId", "contentType", "mentions", "attachments", "replyTo", "replyToPosition", "metadata", "forwarded", "contactCardUserId"]);
+    const data = record4(value, ["conversationId"], ["text", "messageId", "contentType", "mentions", "attachments", "replyTo", "replyToPosition", "metadata", "forwarded", "contactCardUserId", "replyAuthority"]);
     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)) 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((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");
     const mentions = [...new Set(data.mentions ?? [])].map(id);
     return {
       conversationId: id(data.conversationId),
       ...item ? { item } : { text: data.text },
       ...data.messageId === void 0 ? {} : { messageId: id(data.messageId) },
+      ...data.replyAuthority === void 0 ? {} : { replyAuthority: data.replyAuthority },
       ...typeof data.replyTo === "string" ? { replyTo: id(data.replyTo) } : {},
       ...mentions.length ? { mentions } : {}
     };
@@ -5919,18 +5980,23 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     return store.transaction(async (tx) => {
       const room = await tx.get(`conversation/${conversationId}`);
       const group = envelope((await readPreparationSnapshot(tx, scope4(conversationId))).protocolState, init.binding, conversationId);
+      const missed = await tx.get(missedEarlierKey(conversationId)) === true ? { missedEarlier: true } : {};
       if (room?.mlsAdmissionHold !== true) {
         const joining = !!room && !!room.mls && (!group || group.removed);
-        return Object.freeze({ held: joining, waitingPrincipalIds: Object.freeze(joining ? [init.identity.principalId] : []) });
+        return Object.freeze({ held: joining, waitingPrincipalIds: Object.freeze(joining ? [init.identity.principalId] : []), ...missed });
       }
       const accounts = mlsRoomAccounts(room, init.binding.environmentId);
       const admitted = new Set((group && !group.removed ? group.roster : []).map((entry) => mlsAccountOf(accounts, entry.device.principal)));
-      const waiting = [.../* @__PURE__ */ new Set([
-        ...Array.isArray(room.memberIds) ? room.memberIds : [],
-        ...typeof room.mlsInviteeId === "string" ? [room.mlsInviteeId] : [],
-        ...Array.isArray(room.mlsPendingFounderIds) ? room.mlsPendingFounderIds : []
-      ])].filter((memberId) => typeof memberId === "string" && !admitted.has(memberId));
-      return Object.freeze({ held: waiting.length > 0, waitingPrincipalIds: Object.freeze(waiting) });
+      const ids = /* @__PURE__ */ __name((value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [], "ids");
+      const waiting = mlsAdmissionWait({
+        senderId: init.identity.principalId,
+        memberIds: ids(room.memberIds),
+        admitted,
+        unacceptedIds: [...ids([room.mlsInviteeId]), ...ids(room.mlsPendingFounderIds)],
+        joinedAtMs: Number(room.mlsMemberJoinedAtMs),
+        nowMs: context.clock()
+      });
+      return Object.freeze({ held: waiting.length > 0, waitingPrincipalIds: Object.freeze(waiting), ...missed });
     });
   }
   __name(admissionHold, "admissionHold");
@@ -5965,6 +6031,10 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
         const current = await capture(tx, state, init, cid), group = current.envelope;
         if (!isMlsDevTextProtocol(current.protocol)) fail6("MLS_DEV_TEXT_PROTOCOL_UNSUPPORTED");
         if ((input.replyTo || input.mentions || input.item) && current.protocol !== MLS_DEV_TEXT_PROTOCOL_V3) fail6("MLS_DEV_TEXT_ONLY");
+        if (input.mentions) {
+          const members = (await tx.get(`conversation/${cid}`))?.memberIds;
+          if (!Array.isArray(members) || input.mentions.some((mention) => !members.includes(mention))) fail6("MLS_DEV_MENTION_NOT_MEMBER");
+        }
         if (input.item && !canonItemReference(input.item, cid, init.binding.environmentId)) fail6("MLS_DEV_ITEM_INVALID");
         if (input.replyTo) {
           const quote = mlsDevReplyQuote(await tx.get(mlsDevTextMessageKey(cid, input.replyTo)), MLS_DEV_REPLY_QUOTE_MAX_CHARACTERS);
@@ -6038,6 +6108,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
           feedOrdinal: null
         });
         const media = prepared.text.kind === "item" ? { mediaUploadIds: [prepared.text.item.uploadId] } : {};
+        const reply = input.replyAuthority ? { replyAuthority: input.replyAuthority } : {};
         return bridge.queue(tx, {
           operationId,
           installationId: init.identity.installationId,
@@ -6058,7 +6129,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
             operationId,
             installationId: init.identity.installationId,
             action: "mls_application",
-            body: { encoding: "json", value: { ...prepared.wire, ...media } },
+            body: { encoding: "json", value: { ...prepared.wire, ...media, ...reply } },
             ...init.identity.ownershipVersion === void 0 ? {} : { ownershipVersion: init.identity.ownershipVersion }
           }
         });
@@ -6068,6 +6139,76 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     return operation;
   }
   __name(sendText, "sendText");
+  async function holdText(input, operationId) {
+    const cid = input.conversationId;
+    if (input.item || input.replyAuthority || typeof input.text !== "string") return sendText(input, operationId);
+    const messageId = input.messageId ?? await bridge.hash(canonicalEndpointJson(["canon.held-text-message.v1", operationId]));
+    const body = {
+      conversationId: cid,
+      messageId,
+      text: input.text,
+      ...input.replyTo ? { replyTo: input.replyTo } : {},
+      ...input.mentions ? { mentions: input.mentions } : {}
+    };
+    const init = await initialized(), key = mlsDevHeldTextKey(cid, messageId);
+    const kept = await store.transaction(async (tx) => {
+      const existing = await tx.get(key);
+      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);
+      }
+      return "kept";
+    });
+    if (kept === "kept") return void 0;
+    if (kept !== "behind") {
+      try {
+        return await sendText({ ...input, messageId }, operationId);
+      } catch (error) {
+        if (kept === "made" || !(error instanceof EndpointError) || error.code !== "MLS_DEV_GROUP_ADMISSION_PENDING") throw error;
+      }
+    }
+    validText(body.text);
+    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, {
+        version: 1,
+        body,
+        operationId,
+        senderId: init.binding.principal.id,
+        senderType: principal.type,
+        createdAtMs: context.clock(),
+        sequence: (held.at(-1)?.sequence ?? 0) + 1
+      });
+    });
+    bridge.historyChanged?.(cid);
+    return void 0;
+  }
+  __name(holdText, "holdText");
+  async function sendHeldTexts(conversationId) {
+    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);
+      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 });
+        });
+        failed.push({ operationId: held.operationId, error });
+        bridge.historyChanged?.(conversationId);
+        continue;
+      }
+      await store.transaction((tx) => tx.delete(key));
+    }
+    return { sent, failed, waiting: false };
+  }
+  __name(sendHeldTexts, "sendHeldTexts");
   async function roomAccounts(tx, conversationId, init) {
     return mlsRoomAccounts(await tx.get(`conversation/${conversationId}`), init.binding.environmentId);
   }
@@ -6844,6 +6985,15 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       const input = textInput(value), selectedId = id(operationId), selectedGuard = guardId === void 0 ? void 0 : id(guardId);
       return run(() => serializeInboundPreparation(store, input.conversationId, () => sendText(input, selectedId, selectedGuard)));
     },
+    /** `sendText` for a person's composer: in a held room the text is kept, not refused (undefined), until `sendHeldTexts`. */
+    holdText(value, operationId) {
+      const input = textInput(value), selectedId = id(operationId);
+      return run(() => serializeInboundPreparation(store, input.conversationId, () => holdText(input, selectedId)));
+    },
+    sendHeldTexts(conversationId) {
+      const cid = id(conversationId);
+      return run(() => serializeInboundPreparation(store, cid, () => sendHeldTexts(cid)));
+    },
     /** A room this device holds caught up is read as it holds it: what fetches the room's new entries says so
      * (bridge.historyChanged). Otherwise a read fetches the feed first, which the polling fallback and the connected
      * stream's minute-long safety poll rely on. */
@@ -7127,6 +7277,7 @@ function createEndpoint(options) {
       clearTimeout(admissionTimers.get(conversationId));
       admissionTimers.delete(conversationId);
       scheduleAdmission(conversationId, 0);
+      void releaseHeldTexts(conversationId);
     }, "controlSettled"),
     // Whatever fetched them (a hint, the reconnect sweep, a send, recovery), the room's local reads show them now.
     historyChanged: /* @__PURE__ */ __name((conversationId) => queryObserver.invalidate((query, parameters) => options.localInboxPreviews && query === "list_conversations" || parameters.conversationId === conversationId && ["list_messages", "get_messages", "get_runtime_card_state"].includes(query)), "historyChanged"),
@@ -7497,6 +7648,86 @@ function createEndpoint(options) {
     }
   }
   __name(sendDeferredOpeners, "sendDeferredOpeners");
+  const heldWaiters = /* @__PURE__ */ new Map();
+  const heldRooms = /* @__PURE__ */ new Set(), heldTimers = /* @__PURE__ */ new Map(), heldDelays = /* @__PURE__ */ new Map();
+  const releasingHeld = /* @__PURE__ */ new Set(), releaseAgain = /* @__PURE__ */ new Set();
+  function settleHeldWaiters(operationId, settle) {
+    const waiters = heldWaiters.get(operationId) ?? [];
+    heldWaiters.delete(operationId);
+    for (const waiter of waiters) settle(waiter);
+  }
+  __name(settleHeldWaiters, "settleHeldWaiters");
+  function scheduleHeldTexts(conversationId) {
+    if (closed || heldTimers.has(conversationId)) return;
+    const delay = heldDelays.get(conversationId) ?? 3e3;
+    heldDelays.set(conversationId, Math.min(delay * 2, 3e4));
+    const timer = setTimeout(() => {
+      heldTimers.delete(conversationId);
+      void releaseHeldTexts(conversationId);
+    }, delay);
+    timer.unref?.();
+    heldTimers.set(conversationId, timer);
+  }
+  __name(scheduleHeldTexts, "scheduleHeldTexts");
+  async function releaseHeldTexts(conversationId) {
+    if (!mlsDevGroups || closed || !heldRooms.has(conversationId)) return;
+    if (releasingHeld.has(conversationId)) {
+      releaseAgain.add(conversationId);
+      return;
+    }
+    releasingHeld.add(conversationId);
+    try {
+      let waiting;
+      do {
+        releaseAgain.delete(conversationId);
+        const result = await mlsDevGroups.sendHeldTexts(conversationId);
+        for (const operation of result.sent) settleHeldWaiters(operation.operationId, (waiter) => waiter.resolve(operation));
+        for (const { operationId, error } of result.failed) settleHeldWaiters(operationId, (waiter) => waiter.reject(error));
+        waiting = result.waiting;
+      } while (releaseAgain.has(conversationId));
+      if (waiting) scheduleHeldTexts(conversationId);
+      else {
+        heldRooms.delete(conversationId);
+        heldDelays.delete(conversationId);
+        clearTimeout(heldTimers.get(conversationId));
+        heldTimers.delete(conversationId);
+      }
+    } catch (error) {
+      if (!(error instanceof EndpointError) || !["ENDPOINT_CLOSED", "PREPARATION_INSTALLATION_FENCED"].includes(error.code)) scheduleHeldTexts(conversationId);
+    } finally {
+      releasingHeld.delete(conversationId);
+    }
+  }
+  __name(releaseHeldTexts, "releaseHeldTexts");
+  function closeHeldTexts() {
+    for (const timer of heldTimers.values()) clearTimeout(timer);
+    heldTimers.clear();
+    const closedError = new EndpointError("Endpoint is closed", { code: "ENDPOINT_CLOSED", retryable: false });
+    for (const operationId of [...heldWaiters.keys()]) settleHeldWaiters(operationId, (waiter) => waiter.reject(closedError));
+  }
+  __name(closeHeldTexts, "closeHeldTexts");
+  async function sendTextWhenReady(body, operationId) {
+    const queued = await mlsDevGroups.holdText(body, operationId);
+    if (queued) return queued;
+    const conversationId = body.conversationId;
+    const sent = new Promise((resolve3, reject) => {
+      heldWaiters.set(operationId, [...heldWaiters.get(operationId) ?? [], { resolve: resolve3, reject }]);
+    });
+    heldRooms.add(conversationId);
+    void releaseHeldTexts(conversationId);
+    return sent;
+  }
+  __name(sendTextWhenReady, "sendTextWhenReady");
+  async function resumeHeldTexts() {
+    for (let after; ; ) {
+      const page = await store.transaction((tx) => tx.scan(mlsDevHeldTextPrefix(), { limit: 100, ...after ? { after } : {} }));
+      for (const row of page) if (!row.value.failed) heldRooms.add(row.value.body.conversationId);
+      if (page.length < 100) break;
+      after = page[page.length - 1].key;
+    }
+    for (const conversationId of heldRooms) void releaseHeldTexts(conversationId);
+  }
+  __name(resumeHeldTexts, "resumeHeldTexts");
   const stubReads = /* @__PURE__ */ new Map();
   const stubNames = /* @__PURE__ */ new Map();
   let liveActionCounter = 0;
@@ -7601,6 +7832,7 @@ function createEndpoint(options) {
       await mlsDevGroups.commitHeldRemoval(conversationId).catch((error) => {
         if (!(error instanceof EndpointError) || ["ENDPOINT_CLOSED", "PREPARATION_INSTALLATION_FENCED"].includes(error.code)) throw error;
       });
+      void releaseHeldTexts(conversationId);
     }
     return true;
   }
@@ -8117,6 +8349,7 @@ function createEndpoint(options) {
         if (mode.required) {
           if (!isMlsDevTextProtocol(mode.protocol) || !mlsDevGroups) throw new EndpointError("Encrypted text is unavailable for this room", { code: "MLS_DEV_ENCRYPTED_CONTENT_REQUIRED", retryable: false });
           if (executeOptions.sensitive || authored.envelope || authored.preconditions) throw new EndpointError("Unsupported encrypted text fields", { code: "INVALID_MLS_DEV_TEXT_INPUT", retryable: false });
+          if (executeOptions.waitWhileHeld && !executeOptions.guardId) return sendTextWhenReady(authored.body, operationId);
           return mlsDevGroups.sendText(authored.body, operationId, executeOptions.guardId);
         }
       }
@@ -8741,6 +8974,7 @@ function createEndpoint(options) {
       admissionTimers.clear();
       for (const timer of openerTimers.values()) clearTimeout(timer);
       openerTimers.clear();
+      closeHeldTexts();
       queryObserver.close();
       listeners.clear();
       closing = (async () => {
@@ -8763,6 +8997,7 @@ function createEndpoint(options) {
       admissionTimers.clear();
       for (const timer of openerTimers.values()) clearTimeout(timer);
       openerTimers.clear();
+      closeHeldTexts();
       queryObserver.close();
       sensitiveRequests.clear();
       sensitiveFingerprints.clear();
@@ -8774,6 +9009,7 @@ function createEndpoint(options) {
   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);
   return endpoint;
 }
 __name(createEndpoint, "createEndpoint");
@@ -8828,7 +9064,7 @@ async function acquireAgentEndpoint(input) {
   }
   const requestedMls = input.options.mlsDev;
   const mls = requestedMls ? await (async () => {
-    const crypto2 = await import("./mls-crypto-4DZT2UFH.js");
+    const crypto2 = await import("./mls-crypto-NZVMSUFU.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;
@@ -9433,7 +9669,7 @@ var CanonClient = class {
     return result.status === "unavailable" && result.reason === "opening-text-required" ? void 0 : result;
   }
   async blockUser(userId) {
-    await this.endpointAction("set_block", { userId, blocked: true });
+    await this.endpointAction("set_block", { targetUserId: userId, blocked: true });
   }
   async deleteMessage(conversationId, messageId) {
     await this.endpointAction("delete_message", { conversationId, messageId });
@@ -10330,1028 +10566,14 @@ async function ensureAgentProfile(options) {
 }
 __name(ensureAgentProfile, "ensureAgentProfile");
 
-// ../core/src/runtime-cards.ts
-var FIELD_TYPE_SET = new Set(RUNTIME_CARD_FIELD_TYPES);
-var LINE_ITEM_COLUMN_TYPE_SET = new Set(RUNTIME_CARD_LINE_ITEM_COLUMN_TYPES);
-function buildRuntimeInputOutcome(inputId, status, details) {
-  return {
-    text: status === "timeout" ? "Input request expired" : status === "cancelled" ? "Input request cancelled" : "Input request resolved",
-    metadata: {
-      type: "runtime_input_outcome",
-      inputId,
-      ...details?.kind ? { kind: details.kind } : {},
-      status,
-      ...details?.reason ? { reason: details.reason } : {}
-    }
-  };
-}
-__name(buildRuntimeInputOutcome, "buildRuntimeInputOutcome");
-function buildRuntimeCardOutcome(cardId, status, details) {
-  return {
-    text: status === "timeout" ? "Card request expired" : status === "cancelled" ? "Card request cancelled" : "Card request resolved",
-    metadata: {
-      type: "runtime_card_outcome",
-      cardId,
-      status,
-      ...details?.reason ? { reason: details.reason } : {},
-      turnSemantics: "control",
-      replyBehavior: "suppress_auto_reply"
-    }
-  };
-}
-__name(buildRuntimeCardOutcome, "buildRuntimeCardOutcome");
-
-// ../core/src/runtime-request-manager.ts
-var RuntimeRequestCancelledError = class extends Error {
-  static {
-    __name(this, "RuntimeRequestCancelledError");
-  }
-  constructor(message = "Runtime request cancelled") {
-    super(message);
-    this.name = "RuntimeRequestCancelledError";
-  }
-};
-var DEFAULT_TIMEOUT_MS = 3e5;
-var DEFAULT_POLL_MS = 1e3;
-function pendingKey(kind, conversationId, requestId) {
-  return `${kind}::${conversationId}::${requestId}`;
-}
-__name(pendingKey, "pendingKey");
-var RuntimeRequestManager = class {
-  static {
-    __name(this, "RuntimeRequestManager");
-  }
-  client;
-  ctx;
-  descriptors = /* @__PURE__ */ new Map();
-  pending = /* @__PURE__ */ new Map();
-  rules = [];
-  constructor(client, ctx) {
-    this.client = client;
-    this.ctx = ctx;
-    this.registerBuiltins();
-  }
-  /** Register (or override) the descriptor for a kind. */
-  register(kind, descriptor) {
-    this.descriptors.set(kind, descriptor);
-  }
-  /** Built-in input, card, and plan descriptors. Subclasses add approval policy. */
-  registerBuiltins() {
-    this.register("input", runtimeInputDescriptor);
-    this.register("card", runtimeCardDescriptor);
-    this.register("plan", runtimePlanDescriptor);
-  }
-  get pendingCount() {
-    return this.pending.size;
-  }
-  /**
-   * Run one interactive runtime request end to end:
-   * preflight → create → onCreated → register pending → poll (racing push wakeup
-   * and abort) → post-deadline consume → finalize → onOutcome → resolve.
-   */
-  async request(kind, conversationId, payload, options = {}) {
-    const descriptor = this.descriptors.get(kind);
-    if (!descriptor) {
-      throw new Error(`No runtime-request descriptor registered for kind '${kind}'`);
-    }
-    if (options.signal?.aborted) {
-      throw new RuntimeRequestCancelledError();
-    }
-    const pre = descriptor.preflight?.({
-      client: this.client,
-      ctx: this.ctx,
-      conversationId,
-      payload,
-      options
-    });
-    if (pre != null) return pre;
-    const requestId = options.requestId ?? descriptor.generateId(payload);
-    const expiresAt = descriptor.resolveExpiry?.({ payload, options }) ?? options.expiresAt ?? Date.now() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    const pollMs = descriptor.pollMs?.(payload) ?? options.pollMs ?? DEFAULT_POLL_MS;
-    const created = await descriptor.create({
-      client: this.client,
-      ctx: this.ctx,
-      conversationId,
-      requestId,
-      payload,
-      expiresAt,
-      state: void 0,
-      options
-    });
-    const effectiveId = created.requestId || requestId;
-    const effectiveExpiry = created.expiresAt ?? expiresAt;
-    const state = created.state;
-    const base = {
-      client: this.client,
-      ctx: this.ctx,
-      conversationId,
-      requestId: effectiveId,
-      payload,
-      expiresAt: effectiveExpiry,
-      state
-    };
-    if (options.signal?.aborted) {
-      await descriptor.cancel?.(base).catch(() => {
-      });
-      throw signalReason(options.signal) ?? new RuntimeRequestCancelledError();
-    }
-    if (options.onCreated) {
-      await options.onCreated({
-        requestId: effectiveId,
-        expiresAt: effectiveExpiry,
-        ...created.messageId !== void 0 ? { messageId: created.messageId } : {},
-        ...created.interactive !== void 0 ? { interactive: created.interactive } : {}
-      });
-    }
-    if (options.signal?.aborted) {
-      await descriptor.cancel?.(base).catch(() => {
-      });
-      throw signalReason(options.signal) ?? new RuntimeRequestCancelledError();
-    }
-    const key = pendingKey(kind, conversationId, effectiveId);
-    const signal = options.signal;
-    return await new Promise((resolve3, reject) => {
-      let settled = false;
-      const finishCommon = /* @__PURE__ */ __name(() => {
-        settled = true;
-        entry.wake();
-        clearTimeout(entry.timer);
-        this.pending.delete(key);
-        if (signal) signal.removeEventListener("abort", onAbort);
-      }, "finishCommon");
-      const settle = /* @__PURE__ */ __name((result, reason) => {
-        if (settled) return;
-        finishCommon();
-        void (async () => {
-          let finalResult = result;
-          try {
-            const override = descriptor.finalize?.({ ...base, result, reason });
-            if (override !== void 0) finalResult = override;
-          } catch {
-          }
-          if (options.onOutcome && descriptor.buildOutcome) {
-            try {
-              const env = descriptor.buildOutcome({ ...base, result: finalResult, reason });
-              if (env) await options.onOutcome(env);
-            } catch {
-            }
-          }
-          resolve3(finalResult);
-        })();
-      }, "settle");
-      const abort = /* @__PURE__ */ __name((error) => {
-        if (settled) return;
-        finishCommon();
-        void descriptor.cancel?.(base).catch(() => {
-        });
-        reject(error);
-      }, "abort");
-      const onAbort = /* @__PURE__ */ __name(() => abort(signalReason(signal) ?? new RuntimeRequestCancelledError()), "onAbort");
-      const entry = {
-        kind,
-        conversationId,
-        requestId: effectiveId,
-        timer: setTimeout(
-          () => settle(descriptor.timeoutResult(base), "timeout"),
-          Math.max(0, effectiveExpiry - Date.now())
-        ),
-        wake: /* @__PURE__ */ __name(() => {
-        }, "wake"),
-        wakeRequested: false,
-        settle: /* @__PURE__ */ __name((result, reason) => settle(result, reason), "settle"),
-        abort
-      };
-      this.pending.set(key, entry);
-      if (signal) signal.addEventListener("abort", onAbort, { once: true });
-      const pollOnce = /* @__PURE__ */ __name(async () => {
-        try {
-          const outcome = await descriptor.consume(base);
-          if (settled) return true;
-          if (outcome.state === "resolved") {
-            settle(outcome.result, "replied");
-            return true;
-          }
-          if (outcome.state === "timeout") {
-            settle(descriptor.timeoutResult(base), "timeout");
-            return true;
-          }
-        } catch {
-        }
-        return false;
-      }, "pollOnce");
-      const poll = /* @__PURE__ */ __name(async () => {
-        while (!settled && Date.now() < effectiveExpiry) {
-          if (await pollOnce()) return;
-          if (settled) return;
-          await this.sleep(key, Math.min(pollMs, Math.max(1, effectiveExpiry - Date.now())));
-        }
-        if (settled) return;
-        if (await pollOnce()) return;
-        if (!settled) settle(descriptor.timeoutResult(base), "timeout");
-      }, "poll");
-      void poll();
-    });
-  }
-  /** Push short-circuit: wake the pending request's poll to consume immediately. */
-  notify(kind, conversationId, requestId) {
-    const entry = this.pending.get(pendingKey(kind, conversationId, requestId));
-    if (!entry) return;
-    entry.wakeRequested = true;
-    entry.wake();
-  }
-  /**
-   * Feed an inbound message to the manager. Returns true when a matching pending
-   * request was woken to consume canonical state. Receipt metadata never settles
-   * the request directly. Fails closed on unknown / mismatched ids.
-   */
-  handleMessage(conversationId, message) {
-    if (this.pending.size === 0) return false;
-    for (const descriptor of this.descriptors.values()) {
-      const match = descriptor.matchPush?.({ conversationId, message, ctx: this.ctx });
-      if (!match) continue;
-      const entry = this.pending.get(pendingKey(descriptor.kind, conversationId, match.requestId));
-      if (!entry) return false;
-      entry.wakeRequested = true;
-      entry.wake();
-      return true;
-    }
-    return false;
-  }
-  /** Cancel a specific pending request (rejects its promise, best-effort server cancel). */
-  async cancel(kind, conversationId, requestId) {
-    this.pending.get(pendingKey(kind, conversationId, requestId))?.abort(new RuntimeRequestCancelledError());
-  }
-  // ── Session rules (approval descriptor uses these) ─────────────────
-  checkSessionRules(toolName, conversationId) {
-    this.pruneExpiredRules();
-    for (const stored of this.rules) {
-      if (conversationId && stored.conversationId !== conversationId) continue;
-      const { rule } = stored;
-      if (rule.type === "approve-all") return rule;
-      if ((rule.type === "approve-tool" || rule.type === "deny-tool") && rule.toolPattern) {
-        try {
-          const re = new RegExp(`^${rule.toolPattern}$`, "i");
-          if (re.test(toolName)) return rule;
-        } catch {
-          continue;
-        }
-      }
-    }
-    return null;
-  }
-  addSessionRule(conversationId, rule) {
-    this.rules.push({ conversationId, rule });
-  }
-  getSessionRules() {
-    this.pruneExpiredRules();
-    return this.rules.map((stored) => stored.rule);
-  }
-  clearSessionRules() {
-    this.rules = [];
-  }
-  dispose() {
-    for (const entry of this.pending.values()) {
-      clearTimeout(entry.timer);
-    }
-    this.pending.clear();
-    this.rules = [];
-  }
-  pruneExpiredRules() {
-    const now = Date.now();
-    this.rules = this.rules.filter(({ rule }) => {
-      if (!rule.expiresAt) return true;
-      return new Date(rule.expiresAt).getTime() > now;
-    });
-  }
-  /** Sleep that resolves on timeout, on `notify()` wakeup, or when the request settles. */
-  sleep(key, ms) {
-    const pending = this.pending.get(key);
-    if (pending?.wakeRequested) {
-      pending.wakeRequested = false;
-      return Promise.resolve();
-    }
-    return new Promise((resolve3) => {
-      let done = false;
-      const finish = /* @__PURE__ */ __name(() => {
-        if (done) return;
-        done = true;
-        clearTimeout(timer);
-        const current = this.pending.get(key);
-        if (current) {
-          current.wakeRequested = false;
-          current.wake = () => {
-          };
-        }
-        resolve3();
-      }, "finish");
-      const timer = setTimeout(finish, ms);
-      const entry = this.pending.get(key);
-      if (entry) entry.wake = finish;
-    });
-  }
-};
-function signalReason(signal) {
-  const reason = signal?.reason;
-  return reason instanceof Error ? reason : void 0;
-}
-__name(signalReason, "signalReason");
-function resolveResponder(explicit, ownerId, policy) {
-  if (explicit) return explicit;
-  return policy === "owner" ? ownerId || void 0 : void 0;
-}
-__name(resolveResponder, "resolveResponder");
-var inputSeq = 0;
-var cardSeq = 0;
-var planSeq = 0;
-var runtimeInputDescriptor = {
-  kind: "input",
-  generateId(payload) {
-    return `${payload.kind}_${Date.now().toString(36)}${(++inputSeq).toString(36)}`;
-  },
-  async create({ client, ctx, conversationId, requestId, payload, expiresAt, options }) {
-    const responder = resolveResponder(payload.responseUserId, ctx.ownerId, options.responderPolicy ?? "owner");
-    const created = await client.createRuntimeInputRequest({
-      conversationId,
-      inputId: requestId,
-      kind: payload.kind,
-      expiresAt,
-      ...responder !== void 0 ? { responseUserId: responder } : {},
-      ...payload.title !== void 0 ? { title: payload.title } : {},
-      ...payload.prompt !== void 0 ? { prompt: payload.prompt } : {},
-      ...payload.choices ? { choices: payload.choices } : {},
-      ...payload.questions ? { questions: payload.questions } : {},
-      ...payload.secretName ? { secretName: payload.secretName } : {},
-      ...payload.native ? { native: payload.native } : {},
-      ...payload.sensitive !== void 0 ? { sensitive: payload.sensitive } : {},
-      ...payload.turnId ? { turnId: payload.turnId } : {}
-    });
-    return { requestId, ...created.messageId !== void 0 ? { messageId: created.messageId } : {} };
-  },
-  async consume({ client, conversationId, requestId }) {
-    const response = await client.consumeRuntimeInputResponse({ conversationId, inputId: requestId });
-    if (response.status === "submitted") {
-      return {
-        state: "resolved",
-        result: {
-          status: "submitted",
-          inputId: requestId,
-          value: response.value,
-          ...response.answers ? { answers: response.answers } : {}
-        }
-      };
-    }
-    if (response.status === "cancelled") {
-      return { state: "resolved", result: { status: "cancelled", inputId: requestId } };
-    }
-    if (response.status === "timeout") return { state: "timeout" };
-    return { state: "pending" };
-  },
-  async cancel({ client, conversationId, requestId }) {
-    await client.consumeRuntimeInputResponse({ conversationId, inputId: requestId, cancel: true });
-  },
-  timeoutResult({ requestId }) {
-    return { status: "timeout", inputId: requestId };
-  },
-  buildOutcome({ payload, result }) {
-    const outcome = buildRuntimeInputOutcome(result.inputId, result.status, {
-      kind: payload.kind,
-      reason: result.status
-    });
-    return { text: outcome.text, metadata: outcome.metadata };
-  }
-};
-var runtimeCardDescriptor = {
-  kind: "card",
-  generateId(payload) {
-    return payload.card.cardId ?? `card_${Date.now().toString(36)}${(++cardSeq).toString(36)}`;
-  },
-  async create({ client, ctx, conversationId, requestId, payload, expiresAt, options }) {
-    const responder = resolveResponder(payload.responseUserId, ctx.ownerId, options.responderPolicy ?? "infer");
-    const created = await client.createRuntimeCardRequest({
-      conversationId,
-      // Embed cardId into the card body (as hosts do) so the wire shape is
-      // byte-identical whether a host folds onto this built-in or not.
-      card: { ...payload.card, cardId: requestId },
-      cardId: requestId,
-      expiresAt,
-      ...responder !== void 0 ? { responseUserId: responder } : {},
-      ...payload.runtimeId ? { runtimeId: payload.runtimeId } : {},
-      ...payload.turnId ? { turnId: payload.turnId } : {},
-      ...payload.native ? { native: payload.native } : {}
-    });
-    return {
-      requestId: created.cardId ?? requestId,
-      interactive: created.interactive,
-      ...created.expiresAt ? { expiresAt: created.expiresAt } : {},
-      ...created.messageId !== void 0 ? { messageId: created.messageId } : {}
-    };
-  },
-  async consume({ client, conversationId, requestId }) {
-    const response = await client.consumeRuntimeCardResponse({ conversationId, cardId: requestId });
-    if (response.status === "submitted") {
-      return {
-        state: "resolved",
-        result: {
-          status: "submitted",
-          cardId: requestId,
-          ...response.actionId ? { actionId: response.actionId } : {},
-          ...response.values ? { values: response.values } : {},
-          ...response.respondedBy ? { respondedBy: response.respondedBy } : {}
-        }
-      };
-    }
-    if (response.status === "cancelled") {
-      return {
-        state: "resolved",
-        result: {
-          status: "cancelled",
-          cardId: requestId,
-          ...response.respondedBy ? { respondedBy: response.respondedBy } : {}
-        }
-      };
-    }
-    if (response.status === "timeout") return { state: "timeout" };
-    return { state: "pending" };
-  },
-  async cancel({ client, conversationId, requestId }) {
-    await client.consumeRuntimeCardResponse({ conversationId, cardId: requestId, cancel: true });
-  },
-  timeoutResult({ requestId }) {
-    return { status: "timeout", cardId: requestId };
-  },
-  buildOutcome({ result }) {
-    const status = result.status;
-    const outcome = buildRuntimeCardOutcome(result.cardId, status, { reason: status });
-    return { text: outcome.text, metadata: outcome.metadata };
-  }
-};
-var runtimePlanDescriptor = {
-  kind: "plan",
-  generateId() {
-    return `plan_${Date.now().toString(36)}${(++planSeq).toString(36)}`;
-  },
-  async create({ client, ctx, conversationId, requestId, payload, expiresAt, options }) {
-    const responder = resolveResponder(payload.responseUserId, ctx.ownerId, options.responderPolicy ?? "infer");
-    const created = await client.createRuntimePlanRequest({
-      conversationId,
-      planId: requestId,
-      expiresAt,
-      ...responder !== void 0 ? { responseUserId: responder } : {},
-      ...payload.title !== void 0 ? { title: payload.title } : {},
-      ...payload.summary !== void 0 ? { summary: payload.summary } : {},
-      ...payload.body !== void 0 ? { body: payload.body } : {},
-      ...payload.allowedPrompts ? { allowedPrompts: payload.allowedPrompts } : {},
-      ...payload.turnId ? { turnId: payload.turnId } : {}
-    });
-    return {
-      requestId: created.planId ?? requestId,
-      expiresAt: created.expiresAt,
-      ...created.messageId !== void 0 ? { messageId: created.messageId } : {}
-    };
-  },
-  async consume({ client, conversationId, requestId }) {
-    const response = await client.consumeRuntimePlanResponse({ conversationId, planId: requestId });
-    if (response.status === "approve" || response.status === "revise" || response.status === "reject") {
-      return {
-        state: "resolved",
-        result: {
-          status: response.status,
-          planId: requestId,
-          ...response.feedback ? { feedback: response.feedback } : {},
-          ...response.grantedPrompts ? { grantedPrompts: response.grantedPrompts } : {},
-          ...response.receiptId ? { receiptId: response.receiptId } : {}
-        }
-      };
-    }
-    if (response.status === "cancelled") {
-      return { state: "resolved", result: { status: "cancelled", planId: requestId } };
-    }
-    if (response.status === "timeout") return { state: "timeout" };
-    return { state: "pending" };
-  },
-  async cancel({ client, conversationId, requestId }) {
-    await client.consumeRuntimePlanResponse({ conversationId, planId: requestId, cancel: true });
-  },
-  timeoutResult({ requestId }) {
-    return { status: "timeout", planId: requestId };
-  },
-  matchPush({ message }) {
-    if (message.metadata?.type !== "plan_approval_reply") return null;
-    const requestId = message.metadata.planId;
-    return typeof requestId === "string" ? { requestId } : null;
-  }
-};
-
-// ../core/src/approval-types.ts
-var DEFAULT_APPROVAL_CONFIG = {
-  enabled: true,
-  timeoutSeconds: 300,
-  defaultOnTimeout: "deny",
-  // Applied to every host's approval previews via ApprovalManager. Covers both
-  // key=value assignments and common bare-credential shapes (bearer headers,
-  // provider keys, cloud keys, PEM blocks, credentialed URLs) so a redacted
-  // command preview does not leak secrets that the narrow key=value rule misses.
-  // Order matters: redactSecrets applies patterns sequentially, so specific
-  // credential shapes run BEFORE the broad key=value rule — otherwise the kv
-  // rule would consume "Authorization: Bearer" and leave the opaque token.
-  // Bare-credential shapes carry a left boundary so ordinary tokens whose tail
-  // happens to embed a prefix (risk-assessment…, disk-cleanup…) are not mangled
-  // in the command preview the owner must read before approving.
-  redactPatterns: [
-    "(?<![A-Za-z0-9])bearer\\s+[A-Za-z0-9._~+/=-]{12,}",
-    "(?<![A-Za-z0-9])sk-[A-Za-z0-9_-]{16,}",
-    "(?<![A-Za-z0-9])AKIA[0-9A-Z]{16}",
-    "(?<![A-Za-z0-9])gh[posru]_[A-Za-z0-9]{20,}",
-    "(?<![A-Za-z0-9])xox[baprs]-[A-Za-z0-9-]{10,}",
-    "(?<![A-Za-z0-9])eyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}",
-    "-----BEGIN [A-Z ]*PRIVATE KEY-----[\\s\\S]*?-----END [A-Z ]*PRIVATE KEY-----",
-    "://[^\\s:@/]+:[^\\s:@/]+@",
-    "(?:api[_-]?key|access[_-]?token|client[_-]?secret|secret|token|password|passwd|pwd|authorization|auth[_-]?token|private[_-]?key)\\s*[:=]\\s*\\S+"
-  ]
-};
-function isRecord2(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-__name(isRecord2, "isRecord");
-function normalizeString(value, maxLength) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  if (!trimmed || trimmed.length > maxLength) return null;
-  return trimmed;
-}
-__name(normalizeString, "normalizeString");
-function parseSessionRule(value) {
-  if (!isRecord2(value)) return null;
-  const type = value.type;
-  if (type !== "approve-all" && type !== "approve-tool" && type !== "deny-tool") {
-    return null;
-  }
-  let expiresAt;
-  if (value.expiresAt !== void 0) {
-    if (value.expiresAt === null) {
-      expiresAt = null;
-    } else {
-      const normalizedExpiresAt = normalizeString(value.expiresAt, 128);
-      if (!normalizedExpiresAt) return null;
-      const expiresMs = Date.parse(normalizedExpiresAt);
-      if (!Number.isFinite(expiresMs) || expiresMs <= Date.now()) return null;
-      expiresAt = new Date(expiresMs).toISOString();
-    }
-  }
-  if (type === "approve-all") {
-    return {
-      type,
-      ...expiresAt !== void 0 ? { expiresAt } : {}
-    };
-  }
-  const toolPattern = normalizeString(value.toolPattern, 128);
-  if (!toolPattern || !/^[\w.*:-]+$/.test(toolPattern)) {
-    return null;
-  }
-  return {
-    type,
-    toolPattern,
-    ...expiresAt !== void 0 ? { expiresAt } : {}
-  };
-}
-__name(parseSessionRule, "parseSessionRule");
-function parseApprovalReplyMetadata(value) {
-  if (!isRecord2(value) || value.type !== "approval_reply") return null;
-  const approvalId = normalizeString(value.approvalId, 128);
-  if (!approvalId) return null;
-  const decision = value.decision;
-  if (decision !== "allow" && decision !== "deny") return null;
-  let sessionRule;
-  if (value.sessionRule !== void 0) {
-    const parsed = parseSessionRule(value.sessionRule);
-    if (!parsed) return null;
-    sessionRule = parsed;
-  }
-  return {
-    type: "approval_reply",
-    approvalId,
-    decision,
-    ...sessionRule ? { sessionRule } : {}
-  };
-}
-__name(parseApprovalReplyMetadata, "parseApprovalReplyMetadata");
-
 // ../core/src/unified-diff.ts
 var UNIFIED_DIFF_MAX_TOTAL_BYTES = 96 * 1024;
 var UNIFIED_DIFF_MAX_FILE_BYTES = 24 * 1024;
-var UNIFIED_DIFF_MAX_FILES = 100;
 var textEncoder = new TextEncoder();
-function byteLength(text) {
-  return textEncoder.encode(text).length;
-}
-__name(byteLength, "byteLength");
-function clipDiffText(text, maxBytes) {
-  if (maxBytes <= 0) return { text: "", clipped: true };
-  if (byteLength(text) <= maxBytes) return { text, clipped: false };
-  const lines = text.split("\n");
-  const kept = [];
-  let used = 0;
-  for (const line of lines) {
-    const cost = byteLength(line) + (kept.length > 0 ? 1 : 0);
-    if (used + cost > maxBytes) break;
-    kept.push(line);
-    used += cost;
-  }
-  return { text: kept.join("\n"), clipped: true };
-}
-__name(clipDiffText, "clipDiffText");
-function truncateUnifiedDiff(diff, options) {
-  const maxTotalBytes = options?.maxTotalBytes ?? UNIFIED_DIFF_MAX_TOTAL_BYTES;
-  const maxFileBytes = options?.maxFileBytes ?? UNIFIED_DIFF_MAX_FILE_BYTES;
-  const maxFiles = options?.maxFiles ?? UNIFIED_DIFF_MAX_FILES;
-  let totalBytes = 0;
-  let anyClipped = false;
-  const files = diff.files.slice(0, maxFiles).map((file) => {
-    if (typeof file.diff !== "string" || file.diff.length === 0) {
-      const { diff: _omitted, ...rest } = file;
-      return rest;
-    }
-    let truncated2 = file.truncated === true;
-    let text = file.diff;
-    const perFile = clipDiffText(text, maxFileBytes);
-    if (perFile.clipped) {
-      text = perFile.text;
-      truncated2 = true;
-    }
-    const remaining = maxTotalBytes - totalBytes;
-    const withinTotal = clipDiffText(text, remaining);
-    if (withinTotal.clipped) {
-      text = withinTotal.text;
-      truncated2 = true;
-    }
-    if (truncated2) anyClipped = true;
-    if (text.length === 0) {
-      const { diff: _dropped, ...rest } = file;
-      return { ...rest, truncated: true };
-    }
-    totalBytes += byteLength(text);
-    return { ...file, diff: text, ...truncated2 ? { truncated: true } : {} };
-  });
-  const droppedFiles = diff.files.length > files.length;
-  const truncated = diff.truncated === true || droppedFiles || anyClipped;
-  return { files, ...truncated ? { truncated: true } : {} };
-}
-__name(truncateUnifiedDiff, "truncateUnifiedDiff");
-
-// ../core/src/approval-format.ts
-var seq = 0;
-function generateApprovalId() {
-  const ts = Date.now().toString(36);
-  const r = Math.random().toString(36).slice(2, 6);
-  return `apr_${ts}${r}${++seq}`;
-}
-__name(generateApprovalId, "generateApprovalId");
-function summarizeToolInput(toolName, toolInput) {
-  if (toolName === "Bash" && typeof toolInput.command === "string") {
-    return toolInput.command;
-  }
-  if ((toolName === "Edit" || toolName === "Write") && typeof toolInput.file_path === "string") {
-    return toolInput.file_path;
-  }
-  const json = JSON.stringify(toolInput);
-  return json.length > 200 ? json.slice(0, 200) + "..." : json;
-}
-__name(summarizeToolInput, "summarizeToolInput");
-function redactSecrets(text, patterns) {
-  let result = text;
-  for (const pat of patterns) {
-    result = result.replace(new RegExp(pat, "gi"), "[REDACTED]");
-  }
-  return result;
-}
-__name(redactSecrets, "redactSecrets");
-function redactApprovalDetails(details, patterns) {
-  if (!details?.length) return void 0;
-  return details.slice(0, 8).map((detail) => ({
-    ...detail,
-    label: detail.label.slice(0, 80),
-    value: patterns?.length ? redactSecrets(detail.value.slice(0, 500), patterns) : detail.value.slice(0, 500)
-  }));
-}
-__name(redactApprovalDetails, "redactApprovalDetails");
-function buildApprovalRequest(approvalId, toolName, toolInput, opts) {
-  let summary = opts.toolSummary ?? summarizeToolInput(toolName, toolInput);
-  if (opts.redactPatterns?.length) {
-    summary = redactSecrets(summary, opts.redactPatterns);
-  }
-  summary = summary.slice(0, 1e3);
-  const risk = opts.risk ?? opts.riskLevel ?? "normal";
-  const riskLevel = risk === "destructive" ? "destructive" : opts.riskLevel ?? "normal";
-  const details = redactApprovalDetails(opts.details, opts.redactPatterns);
-  const diff = opts.diff ? truncateUnifiedDiff(opts.diff) : void 0;
-  const timeoutMin = Math.round(
-    (new Date(opts.expiresAt).getTime() - Date.now()) / 6e4
-  );
-  const lines = [
-    `Action Approval Required [${approvalId}]`,
-    "",
-    `Tool: ${toolName}`,
-    summary,
-    ""
-  ];
-  if (risk === "high" || risk === "destructive") {
-    lines.push(risk === "destructive" ? "This is a destructive operation" : "This is a high-risk operation");
-    lines.push("");
-  }
-  lines.push(`Reply "approve" or "deny" (expires in ${timeoutMin}m)`);
-  const metadata = {
-    type: "approval_request",
-    approvalId,
-    ...opts.responseUserId ? { responseUserId: opts.responseUserId.slice(0, 128) } : {},
-    toolName,
-    toolSummary: summary,
-    ...opts.category ? { category: opts.category } : {},
-    risk,
-    riskLevel,
-    ...opts.runtimeId ? { runtimeId: opts.runtimeId } : {},
-    ...opts.turnId ? { turnId: opts.turnId } : {},
-    ...opts.native ? { native: opts.native } : {},
-    ...details ? { details } : {},
-    ...diff ? { diff } : {},
-    expiresAt: opts.expiresAt
-  };
-  return { text: lines.join("\n"), metadata };
-}
-__name(buildApprovalRequest, "buildApprovalRequest");
-function buildApprovalOutcome(approvalId, toolName, toolSummary, decision, reason) {
-  const icon = decision === "allow" ? "Approved" : "Denied";
-  const short = toolSummary.length > 60 ? toolSummary.slice(0, 60) + "..." : toolSummary;
-  if (reason === "timeout") {
-    return `Expired [${approvalId}] -- ${toolName}: ${short} (auto-denied)`;
-  }
-  if (reason === "session-rule") {
-    const label = decision === "allow" ? "Auto-approved" : "Auto-denied";
-    return `${label} (session rule) -- ${toolName}: ${short}`;
-  }
-  return `${icon} [${approvalId}] -- ${toolName}: ${short}`;
-}
-__name(buildApprovalOutcome, "buildApprovalOutcome");
-
-// ../core/src/approval-manager.ts
-var ApprovalManager = class extends RuntimeRequestManager {
-  static {
-    __name(this, "ApprovalManager");
-  }
-  config;
-  constructor(client, agentId, ownerId, config) {
-    super(client, { agentId, ownerId });
-    this.config = { ...DEFAULT_APPROVAL_CONFIG, ...config };
-    this.register("approval", this.buildApprovalDescriptor());
-  }
-  /**
-   * Request approval for a tool call.
-   *
-   * 1. Checks session rules — may resolve immediately.
-   * 2. Sends a message with approval card metadata.
-   * 3. Waits for the owner's reply (or timeout).
-   */
-  requestApproval(conversationId, toolName, toolInput, opts, runtimeOptions) {
-    return this.request(
-      "approval",
-      conversationId,
-      { toolName, toolInput, opts },
-      runtimeOptions
-    );
-  }
-  buildApprovalDescriptor() {
-    return {
-      kind: "approval",
-      generateId: /* @__PURE__ */ __name(() => generateApprovalId(), "generateId"),
-      resolveExpiry: /* @__PURE__ */ __name(({ options }) => options.expiresAt ?? Date.now() + this.config.timeoutSeconds * 1e3, "resolveExpiry"),
-      pollMs: /* @__PURE__ */ __name(() => 1e3, "pollMs"),
-      preflight: /* @__PURE__ */ __name(({ conversationId, payload }) => {
-        const { toolName, toolInput, opts } = payload;
-        const nonOwnerResponder = Boolean(
-          opts?.responseUserId && opts.responseUserId !== this.ctx.ownerId
-        );
-        const matchingRule = opts?.ignoreSessionRules || nonOwnerResponder ? null : this.checkSessionRules(toolName, conversationId);
-        if (!matchingRule) return null;
-        const decision = matchingRule.type === "deny-tool" ? "deny" : "allow";
-        const rawSummary = opts?.toolSummary ?? summarizeTool(toolName, toolInput);
-        const summary = this.config.redactPatterns.length ? redactSecrets(rawSummary, this.config.redactPatterns) : rawSummary;
-        const logMsg = buildApprovalOutcome("", toolName, summary, decision, "session-rule");
-        this.client.sendMessage(conversationId, logMsg, {
-          metadata: { type: "approval_outcome", decision, reason: "session-rule" }
-        }).catch(() => {
-        });
-        return { decision };
-      }, "preflight"),
-      create: /* @__PURE__ */ __name(async ({ conversationId, requestId, payload, expiresAt }) => {
-        const { toolName, toolInput, opts } = payload;
-        const approvalId = requestId;
-        const expiresAtIso = new Date(expiresAt).toISOString();
-        const requestedResponseUserId = opts?.responseUserId || this.ctx.ownerId || void 0;
-        const requestedAllowSessionRule = requestedResponseUserId === this.ctx.ownerId && opts?.allowSessionRule !== false;
-        const { metadata } = buildApprovalRequest(approvalId, toolName, toolInput, {
-          riskLevel: opts?.riskLevel,
-          risk: opts?.risk,
-          category: opts?.category,
-          responseUserId: requestedResponseUserId,
-          runtimeId: opts?.runtimeId,
-          turnId: opts?.turnId,
-          native: opts?.native,
-          toolSummary: opts?.toolSummary,
-          details: opts?.details,
-          diff: opts?.diff,
-          expiresAt: expiresAtIso,
-          redactPatterns: this.config.redactPatterns
-        });
-        const created = await this.client.createRuntimeApprovalRequest({
-          conversationId,
-          approvalId,
-          toolName,
-          toolSummary: metadata.toolSummary,
-          expiresAt: Date.parse(expiresAtIso),
-          ...requestedResponseUserId ? { responseUserId: requestedResponseUserId } : {},
-          ...opts?.riskLevel ? { riskLevel: opts.riskLevel } : {},
-          ...opts?.risk ? { risk: opts.risk } : {},
-          ...opts?.category ? { category: opts.category } : {},
-          ...opts?.runtimeId ? { runtimeId: opts.runtimeId } : {},
-          ...opts?.turnId ? { turnId: opts.turnId } : {},
-          ...metadata.native ? { native: metadata.native } : {},
-          ...metadata.details ? { details: metadata.details } : {},
-          ...metadata.diff ? { diff: metadata.diff } : {},
-          ...!requestedAllowSessionRule ? { allowSessionRule: false } : {}
-        });
-        return {
-          requestId: approvalId,
-          expiresAt,
-          state: {
-            toolName,
-            toolSummary: metadata.toolSummary,
-            allowSessionRule: created.allowSessionRule ?? requestedAllowSessionRule
-          }
-        };
-      }, "create"),
-      consume: /* @__PURE__ */ __name(async ({ conversationId, requestId }) => {
-        const response = await this.client.consumeRuntimeApprovalResponse({
-          conversationId,
-          approvalId: requestId
-        });
-        if (response.status === "allow" || response.status === "deny") {
-          return {
-            state: "resolved",
-            result: {
-              decision: response.status,
-              ...response.sessionRule ? { sessionRule: response.sessionRule } : {},
-              ...response.respondedBy ? { respondedBy: response.respondedBy } : {}
-            }
-          };
-        }
-        if (response.status === "timeout") return { state: "timeout" };
-        return { state: "pending" };
-      }, "consume"),
-      cancel: /* @__PURE__ */ __name(async ({ conversationId, requestId }) => {
-        await this.client.consumeRuntimeApprovalResponse({
-          conversationId,
-          approvalId: requestId,
-          cancel: true
-        });
-      }, "cancel"),
-      timeoutResult: /* @__PURE__ */ __name(() => ({ decision: "deny" }), "timeoutResult"),
-      finalize: /* @__PURE__ */ __name(({ conversationId, requestId, state, result, reason }) => {
-        const toolName = state?.toolName ?? "";
-        const toolSummary = state?.toolSummary ?? "";
-        if (reason === "timeout") {
-          const msg = buildApprovalOutcome(requestId, toolName, toolSummary, "deny", "timeout");
-          this.client.sendMessage(conversationId, msg, {
-            metadata: {
-              type: "approval_outcome",
-              approvalId: requestId,
-              decision: "deny",
-              reason: "timeout"
-            }
-          }).catch(() => {
-          });
-          return { decision: "deny" };
-        }
-        const acceptedSessionRule = state?.allowSessionRule ? result.sessionRule : void 0;
-        if (acceptedSessionRule) {
-          this.addSessionRule(conversationId, acceptedSessionRule);
-        }
-        const outcomeMsg = buildApprovalOutcome(
-          requestId,
-          toolName,
-          toolSummary,
-          result.decision,
-          "replied"
-        );
-        this.client.sendMessage(conversationId, outcomeMsg, {
-          metadata: {
-            type: "approval_outcome",
-            approvalId: requestId,
-            decision: result.decision,
-            reason: "replied"
-          }
-        }).catch(() => {
-        });
-        if (acceptedSessionRule) {
-          const ruleDesc = describeRule(acceptedSessionRule);
-          this.client.sendMessage(conversationId, `Session rule set: ${ruleDesc}`, {
-            metadata: { type: "approval_outcome", decision: result.decision, reason: "session-rule" }
-          }).catch(() => {
-          });
-        }
-        return {
-          decision: result.decision,
-          ...acceptedSessionRule ? { sessionRule: acceptedSessionRule } : {},
-          ...result.respondedBy ? { respondedBy: result.respondedBy } : {}
-        };
-      }, "finalize"),
-      matchPush: /* @__PURE__ */ __name(({ conversationId, message }) => {
-        void conversationId;
-        if (message.metadata?.type !== "approval_reply") return null;
-        const parsed = parseApprovalReplyMetadata(message.metadata);
-        if (!parsed) return null;
-        return { requestId: parsed.approvalId };
-      }, "matchPush")
-    };
-  }
-};
-function summarizeTool(toolName, toolInput) {
-  if (toolName === "Bash" && typeof toolInput.command === "string") {
-    return toolInput.command;
-  }
-  if ((toolName === "Edit" || toolName === "Write") && typeof toolInput.file_path === "string") {
-    return toolInput.file_path;
-  }
-  const json = JSON.stringify(toolInput);
-  return json.length > 100 ? json.slice(0, 100) + "..." : json;
-}
-__name(summarizeTool, "summarizeTool");
-function describeRule(rule) {
-  if (rule.type === "approve-all") {
-    if (rule.expiresAt) {
-      const min = Math.round((new Date(rule.expiresAt).getTime() - Date.now()) / 6e4);
-      return `auto-approving all tools for ${min}m`;
-    }
-    return "auto-approving all tools for this session";
-  }
-  if (rule.type === "approve-tool") {
-    return `auto-approving all ${rule.toolPattern} commands`;
-  }
-  if (rule.type === "deny-tool") {
-    return `auto-denying all ${rule.toolPattern} commands`;
-  }
-  return "unknown rule";
-}
-__name(describeRule, "describeRule");
-
-// ../core/src/silent-turn.ts
-var NO_REPLY_REASON_SENTINEL = "given";
-function reportNoReplyOutcome(client, params) {
-  try {
-    const hasReason = Boolean(params.reason?.trim());
-    const wire = projectVerbIntentToWire(
-      "no_reply",
-      {
-        conversationId: params.conversationId,
-        ...params.messageId ? { messageId: params.messageId } : {},
-        ...hasReason ? { reason: NO_REPLY_REASON_SENTINEL } : {}
-      },
-      { now: params.now ?? Date.now() }
-    );
-    void client.executeVerbWire(wire).catch(() => {
-    });
-  } catch {
-  }
-}
-__name(reportNoReplyOutcome, "reportNoReplyOutcome");
 
-// ../core/src/turn-verbosity.ts
-var DEFAULT_TURN_VERBOSITY_BY_CONVERSATION_TYPE = {
-  direct: "verbose",
-  group: "quiet",
-  // Fail OPEN to today's behavior: 'unknown' is reachable whenever the
-  // conversation fetch fails, and silence-by-accident is worse than noise.
-  unknown: "verbose"
-};
-function normalizeTurnVerbosityConversationType(value) {
-  const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
-  if (normalized === "direct") return "direct";
-  if (normalized === "group") return "group";
-  return "unknown";
-}
-__name(normalizeTurnVerbosityConversationType, "normalizeTurnVerbosityConversationType");
-function resolveTurnVerbosity(input) {
-  const configured = parseTurnVerbosityConfig(input.configured);
-  if (configured === "verbose" || configured === "quiet") return configured;
-  return DEFAULT_TURN_VERBOSITY_BY_CONVERSATION_TYPE[normalizeTurnVerbosityConversationType(input.conversationType)];
-}
-__name(resolveTurnVerbosity, "resolveTurnVerbosity");
-function parseTurnVerbosityConfig(raw) {
-  const normalized = typeof raw === "string" ? raw.trim().toLowerCase() : "";
-  if (normalized === "verbose" || normalized === "quiet" || normalized === "auto") {
-    return normalized;
-  }
-  return null;
-}
-__name(parseTurnVerbosityConfig, "parseTurnVerbosityConfig");
+// ../core/src/runtime-cards.ts
+var FIELD_TYPE_SET = new Set(RUNTIME_CARD_FIELD_TYPES);
+var LINE_ITEM_COLUMN_TYPE_SET = new Set(RUNTIME_CARD_LINE_ITEM_COLUMN_TYPES);
 
 // ../core/src/rtdb-rest.ts
 var CLEARED_LOCAL_RUNTIME_FIELDS = {
@@ -11792,62 +11014,12 @@ function createRuntimeStatePublisher(options) {
 __name(createRuntimeStatePublisher, "createRuntimeStatePublisher");
 
 // ../core/src/retry.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
 var CANON_MESSAGE_TEXT_MAX_BYTES = 4 * 1024;
-var DEFAULT_CHUNKED_MESSAGE_TEXT_MAX_BYTES = 3800;
 function isPendingCanonOperation(error) {
-  if (isChunkedSendMessageError(error)) return isPendingCanonOperation(error.cause);
   return !!error && typeof error === "object" && "code" in error && ["OPERATION_PENDING", "OPERATION_UNCERTAIN", "ENDPOINT_CLOSED"].includes(String(error.code));
 }
 __name(isPendingCanonOperation, "isPendingCanonOperation");
-var ChunkedSendMessageError = class extends Error {
-  static {
-    __name(this, "ChunkedSendMessageError");
-  }
-  /** Ids of the parts that are durable in Canon, in part order. */
-  deliveredMessageIds;
-  /** The part the send stopped on (1-based). */
-  failedPart;
-  /** How many parts the text splits into in total. */
-  totalParts;
-  /** The underlying send failure — what callers should classify. */
-  cause;
-  constructor(input) {
-    const detail = input.cause instanceof Error ? input.cause.message : String(input.cause);
-    super(`Chunked send failed at part ${input.failedPart} of ${input.totalParts}: ${detail}`);
-    this.name = "ChunkedSendMessageError";
-    this.deliveredMessageIds = [...input.deliveredMessageIds];
-    this.failedPart = input.failedPart;
-    this.totalParts = input.totalParts;
-    this.cause = input.cause;
-  }
-  /** How many parts are durable — a resume starts at the next one. */
-  get deliveredParts() {
-    return this.deliveredMessageIds.length;
-  }
-};
-function isChunkedSendMessageError(error) {
-  if (error instanceof ChunkedSendMessageError) return true;
-  return error instanceof Error && error.name === "ChunkedSendMessageError" && Array.isArray(error.deliveredMessageIds);
-}
-__name(isChunkedSendMessageError, "isChunkedSendMessageError");
 var textEncoder2 = new TextEncoder();
-function isRetryableCanonDeliveryError(error) {
-  if (error instanceof CanonApiError) {
-    return error.status === 429 || error.status >= 500;
-  }
-  return error instanceof Error;
-}
-__name(isRetryableCanonDeliveryError, "isRetryableCanonDeliveryError");
-async function sendMessageWithRetry(client, conversationId, text, options, retryOptions = {}) {
-  try {
-    return await (retryOptions.operationId ? client.sendMessage(conversationId, text, options, { operationId: retryOptions.operationId }) : client.sendMessage(conversationId, text, options));
-  } catch (error) {
-    if (!(error instanceof CanonApiError) || !error.operationId) throw error;
-    return client.waitForOperation(error.operationId, { signal: retryOptions.signal, timeoutMs: retryOptions.timeoutMs });
-  }
-}
-__name(sendMessageWithRetry, "sendMessageWithRetry");
 function utf8ByteLength(value) {
   return textEncoder2.encode(value).byteLength;
 }
@@ -11946,8 +11118,7 @@ ${renderedFence.marker}` : "";
   };
 }
 __name(takeChunk, "takeChunk");
-function splitTextByUtf8Bytes(text, maxBytes = DEFAULT_CHUNKED_MESSAGE_TEXT_MAX_BYTES) {
-  const byteLimit = Math.min(maxBytes, CANON_MESSAGE_TEXT_MAX_BYTES);
+function splitTextWithinBytes(text, byteLimit) {
   if (!Number.isFinite(byteLimit) || byteLimit < 4) {
     throw new Error("maxBytes must be at least 4");
   }
@@ -11972,115 +11143,7 @@ function splitTextByUtf8Bytes(text, maxBytes = DEFAULT_CHUNKED_MESSAGE_TEXT_MAX_
   }
   return chunks;
 }
-__name(splitTextByUtf8Bytes, "splitTextByUtf8Bytes");
-function chunkMessageId(baseMessageId, index) {
-  if (!baseMessageId) return void 0;
-  const suffix = `-part-${index}`;
-  const maxBaseLength = 160 - suffix.length;
-  return `${baseMessageId.slice(0, Math.max(0, maxBaseLength))}${suffix}`;
-}
-__name(chunkMessageId, "chunkMessageId");
-function stripTrailTextBlocks(trail) {
-  if (!Array.isArray(trail)) return null;
-  return trail.filter((block) => {
-    if (!block || typeof block !== "object") return true;
-    return block.kind !== "text";
-  });
-}
-__name(stripTrailTextBlocks, "stripTrailTextBlocks");
-function buildChunkedMessagePartMetadata(input) {
-  if (input.count <= 1) return { ...input.metadata ?? {} };
-  const chunk = {
-    type: "text",
-    index: input.index,
-    count: input.count,
-    ...input.groupId ? { groupId: input.groupId } : {}
-  };
-  if (input.index >= input.count) {
-    const metadata = { ...input.metadata ?? {} };
-    const trail = stripTrailTextBlocks(metadata.turnTrail);
-    if (trail) {
-      if (trail.length > 0) metadata.turnTrail = trail;
-      else delete metadata.turnTrail;
-    }
-    return {
-      ...metadata,
-      messageChunk: chunk
-    };
-  }
-  const {
-    turnSemantics: _turnSemantics,
-    turnTrail: _turnTrail,
-    ...rest
-  } = input.metadata ?? {};
-  return {
-    ...rest,
-    turnSemantics: "progress",
-    replyBehavior: "suppress_auto_reply",
-    messageChunk: chunk
-  };
-}
-__name(buildChunkedMessagePartMetadata, "buildChunkedMessagePartMetadata");
-async function sendMessageWithRetryChunked(client, conversationId, text, options, retryOptions = {}, chunkingOptions = {}) {
-  const chunks = splitTextByUtf8Bytes(
-    text,
-    chunkingOptions.maxTextBytes ?? DEFAULT_CHUNKED_MESSAGE_TEXT_MAX_BYTES
-  );
-  const alreadyDelivered = chunkingOptions.deliveredMessageIds ?? [];
-  const resumable = chunkingOptions.resumable === true || alreadyDelivered.length > 0;
-  if (chunks.length === 1) {
-    if (alreadyDelivered.length > 0) {
-      throw new ChunkedSendMessageError({
-        cause: new Error(
-          `Resume cursor holds ${alreadyDelivered.length} part(s) but the text now fits in one message`
-        ),
-        deliveredMessageIds: alreadyDelivered,
-        failedPart: 1,
-        totalParts: 1
-      });
-    }
-    const result = await sendMessageWithRetry(client, conversationId, text, options, retryOptions);
-    return { messageIds: [result.messageId] };
-  }
-  const rootMessageId = options?.messageId ?? randomUUID6();
-  const parts = chunks.map((text2, index) => ({ text: text2, options: {
-    ...options ?? {},
-    messageId: chunkMessageId(rootMessageId, index + 1),
-    metadata: buildChunkedMessagePartMetadata({ groupId: rootMessageId, metadata: options?.metadata, index: index + 1, count: chunks.length })
-  } }));
-  const group = await client.prepareMessageGroup(conversationId, rootMessageId, parts, retryOptions);
-  const groupId = group.id;
-  const cancel = /* @__PURE__ */ __name(() => {
-    void client.cancelMessageGroup(groupId).catch(() => {
-    });
-  }, "cancel");
-  retryOptions.signal?.addEventListener("abort", cancel, { once: true });
-  try {
-    const startIndex = Math.min(alreadyDelivered.length, chunks.length);
-    const messageIds = [...alreadyDelivered.slice(0, startIndex)];
-    for (let index = startIndex; index < chunks.length; index += 1) {
-      const part = index + 1;
-      try {
-        if (retryOptions.signal?.aborted) throw new CanonApiError(409, JSON.stringify({ code: "OPERATION_PENDING", message: "Reply delivery was interrupted" }));
-        const result = await group.sendPart(index, retryOptions);
-        messageIds.push(result.messageId);
-      } catch (error) {
-        if (!resumable) throw error;
-        throw new ChunkedSendMessageError({
-          cause: error,
-          deliveredMessageIds: messageIds,
-          failedPart: part,
-          totalParts: chunks.length
-        });
-      }
-    }
-    return { messageIds };
-  } finally {
-    retryOptions.signal?.removeEventListener("abort", cancel);
-    if (retryOptions.signal?.aborted) await client.cancelMessageGroup(groupId);
-  }
-}
-__name(sendMessageWithRetryChunked, "sendMessageWithRetryChunked");
+__name(splitTextWithinBytes, "splitTextWithinBytes");
 
 // ../core/src/cli-metadata.ts
 import { readFileSync as readFileSync3, realpathSync } from "node:fs";
@@ -12144,7 +11207,7 @@ function runCli(moduleUrl, main, onError, metadata) {
 __name(runCli, "runCli");
 
 // ../core/src/completed-output-journal.ts
-import { createHash as createHash4, randomUUID as randomUUID7 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
 import {
   closeSync as closeSync3,
   existsSync as existsSync2,
@@ -12221,7 +11284,7 @@ function createCompletedOutputJournal(directory, scope5, options) {
         if (readFileSync4(path, "utf8") !== serialized) throw new Error(`Completed ${label} output cannot be replaced`);
         return;
       }
-      const temporary = `${path.slice(0, -5)}.${process.pid}.${randomUUID7()}.tmp`;
+      const temporary = `${path.slice(0, -5)}.${process.pid}.${randomUUID6()}.tmp`;
       try {
         const fd = openSync3(temporary, "wx", 384);
         try {
@@ -12261,12 +11324,6 @@ function createCompletedOutputJournal(directory, scope5, options) {
   };
 }
 __name(createCompletedOutputJournal, "createCompletedOutputJournal");
-function assertCompletedOutputAudience(record6, current, label) {
-  if (!record6.audience || !current || record6.audience.membershipRevision !== void 0 && record6.audience.membershipRevision !== current.membershipRevision || JSON.stringify([...record6.audience.memberIds].sort()) !== JSON.stringify([...current.memberIds].sort())) {
-    throw new Error(`Completed ${label} output audience changed; operator reconciliation is required`);
-  }
-}
-__name(assertCompletedOutputAudience, "assertCompletedOutputAudience");
 
 // src/bounded-file-read.ts
 var BoundedFileReadError = class extends Error {
@@ -12545,7 +11602,7 @@ async function materializeAttachment(attachment, options) {
     if (!response.body) {
       throw new Error("Canon media response had no body");
     }
-    const tempPath = `${path}.${process.pid}.${randomUUID8()}.part`;
+    const tempPath = `${path}.${process.pid}.${randomUUID7()}.part`;
     const limiter = byteLimitTransform(maxBytes);
     try {
       await pipeline2(
@@ -12641,7 +11698,7 @@ async function uploadMediaFile(client, conversationId, filePath, options) {
   const media = await client.getFileMediaPipeline(options?.fetchImpl);
   const [attachment] = await media.prepare({
     conversationId,
-    attachmentId: options?.attachmentId ?? randomUUID8(),
+    attachmentId: options?.attachmentId ?? randomUUID7(),
     files: [{ source: filePath, descriptor: {
       mimeType,
       sizeBytes: fileStat.size,
@@ -12670,7 +11727,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 ?? randomUUID8();
+  const messageId = sendOptions.messageId ?? randomUUID7();
   const pipeline3 = await client.getFileMediaPipeline(fetchImpl);
   const delivered = await pipeline3.send({
     conversationId,
@@ -12845,21 +11902,14 @@ export {
   acquireLock,
   clearPendingRegistration,
   ensureAgentProfile,
-  ApprovalManager,
-  reportNoReplyOutcome,
-  resolveTurnVerbosity,
   initRTDBAuth,
   renderCanonHostInboundContent,
   createRuntimeStatePublisher,
   isPendingCanonOperation,
-  isRetryableCanonDeliveryError,
-  splitTextByUtf8Bytes,
-  buildChunkedMessagePartMetadata,
-  sendMessageWithRetryChunked,
+  splitTextWithinBytes,
   readCliPackageVersion,
   runCli,
   createCompletedOutputJournal,
-  assertCompletedOutputAudience,
   BoundedFileReadError,
   readBoundedRegularFileHandle,
   DEFAULT_MEDIA_CACHE_DIR,