@canonmsg/agent-sdk 13.2.0 → 13.3.0

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

@@ -5,8 +5,9 @@ import {
   createHttpEndpointTransport,
   createNodeEndpointStore,
   validateEndpointContentBoundary
-} from "./chunk-YJUPKU47.js";
+} from "./chunk-HFT75BNB.js";
 import {
+  AGENT_HOME_ELSEWHERE,
   CANON_ENDPOINT_PROTOCOL,
   CANON_VERB_WIRE_SCHEMA_VERSION,
   ENDPOINT_ACTION_PATTERN,
@@ -15,6 +16,7 @@ import {
   MLS_DEV_DISCLOSED_PROCESSING_FIELDS,
   MLS_DEV_GROUP_RECEIPT_CLOCK_SKEW,
   MLS_DEV_INTERACTION_LIMITS,
+  MLS_DEV_KEY_PACKAGE_CLAIM_LEASE_MS,
   MLS_DEV_REPLY_QUOTE_MAX_CHARACTERS,
   MLS_DEV_TEXT_PROTOCOL_V3,
   MLS_DEV_UNSUPPORTED_CONTENT_ACTIONS,
@@ -22,6 +24,7 @@ import {
   RUNTIME_CARD_FIELD_TYPES,
   RUNTIME_CARD_LINE_ITEM_COLUMN_TYPES,
   __name,
+  agentHomeElsewhereMessage,
   assertMlsDevInteractionPayloadBinding,
   canonicalEndpointJson,
   createMlsDevCredentialSigningInput,
@@ -36,12 +39,11 @@ import {
   getCanonEnvironmentContract,
   isCanonMediaOrigin,
   isCanonUploadUrl,
+  isConnectorRelayInstallation,
   isMlsDevInteractionAnswerAllowed,
   isMlsDevTextProtocol,
   isMlsEnvironmentId,
   isMlsPrincipalAlias,
-  logicalMediaBlobId,
-  mergeDeliveryObservation,
   mlsAdmissionWait,
   mlsDevProtocolCarriesCards,
   normalizePublicRuntimeDescriptor,
@@ -102,12 +104,11 @@ import {
   parseMlsPrincipalOpening,
   parseMlsRoomIdentities,
   prepareJsonContent,
-  projectDeliveryStatus,
   projectVerbIntentToWire,
   readMembershipChangeMetadata,
   resolveAllowedUploadMimeType,
   sanitizeDownloadFileName
-} from "./chunk-5WPAB5MB.js";
+} from "./chunk-CUPSYLBV.js";
 
 // src/media.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
@@ -587,7 +588,6 @@ function endpointIntentOrdering(intent2) {
   const body = { ...intent2.body, ...intent2.envelope };
   if (intent2.action === "consume_runtime_signal") return "independent";
   if (intent2.action === "generate_image") return "provider";
-  if (["append_artifact_command", "retain_artifact_asset"].includes(intent2.action) && typeof body.artifactId === "string") return "artifact";
   if (intent2.action === "session_control" && !body.primitive && typeof body.agentId === "string") {
     const type = body.signal?.type;
     if (type === "interrupt" || type === "stop_and_drop") return "signal";
@@ -609,12 +609,10 @@ async function orderOperation(tx, operation) {
 }
 __name(orderOperation, "orderOperation");
 var outboxKey = /* @__PURE__ */ __name((operation) => operation.queueOrder === void 0 ? `outbox/${operation.operationId}` : `outbox/${ordinal(operation.queueOrder)}/${operation.operationId}`, "outboxKey");
-var artifactOrderingPrefix = /* @__PURE__ */ __name((conversationId, artifactId) => `outbound-artifact-order/${scope(conversationId)}/${scope(artifactId)}/`, "artifactOrderingPrefix");
 var controlOrderingKey = /* @__PURE__ */ __name((operation) => operation.action === "session_control" && operation.conversationId && operation.agentId ? `outbound-control-order/${scope(operation.conversationId)}/${scope(operation.agentId)}/` : void 0, "controlOrderingKey");
 var operationOrderingKey = /* @__PURE__ */ __name((operation) => {
   if (!operation.conversationId || operation.ordering === "independent" || operation.ordering === "provider") return void 0;
   if (operation.ordering === "signal") return controlOrderingKey(operation);
-  if (operation.ordering === "artifact") return artifactOrderingPrefix(operation.conversationId, operation.artifactId ?? "~");
   return operation.ordering === "message" ? `outbound-ack-order/${scope(operation.conversationId)}/${scope(operation.messageId)}/` : `outbound-order/${scope(operation.conversationId)}/`;
 }, "operationOrderingKey");
 var outboundPrefix = /* @__PURE__ */ __name((operation) => operationOrderingKey(operation), "outboundPrefix");
@@ -1106,42 +1104,18 @@ var ROOM_QUERIES = /* @__PURE__ */ new Set([
   "list_voice_sessions",
   "get_voice_session"
 ]);
-var ARTIFACT_QUERIES = /* @__PURE__ */ new Set(["list_artifacts", "get_artifact_log", "get_artifact_asset"]);
 var INBOX_QUERIES = /* @__PURE__ */ new Set(["list_conversations", "get_unread_summary"]);
 var CONTACT_QUERIES = /* @__PURE__ */ new Set(["list_contacts", "get_contact", "list_contact_requests"]);
 var ROOM_OPERATIONS = /* @__PURE__ */ new Set(["send_message", "mls_application", "mls_group_control", "react", "delete_message", "mark_read"]);
-var ARTIFACT_OPERATIONS = /* @__PURE__ */ new Set(["append_artifact_command", "retain_artifact_asset"]);
 function queryAffectedByOperation(operation, query, parameters) {
-  if (ARTIFACT_OPERATIONS.has(operation.action)) {
-    if (operation.status !== "succeeded" || !ARTIFACT_QUERIES.has(query)) return false;
-    return typeof parameters.conversationId !== "string" || !operation.conversationId || parameters.conversationId === operation.conversationId;
-  }
-  if (ARTIFACT_QUERIES.has(query)) return false;
   if (!ROOM_OPERATIONS.has(operation.action)) return true;
   if (operation.status !== "succeeded" && !(operation.action === "mls_application" && ["rejected", "uncertain"].includes(operation.status))) return false;
   return queryAffectedByEvent({ kind: "conversation.changed", data: { conversationId: operation.conversationId } }, query, parameters);
 }
 __name(queryAffectedByOperation, "queryAffectedByOperation");
-function artifactQueryAffected(event, query, parameters) {
-  const conversationId = parameters.conversationId;
-  const sameRoom = typeof conversationId !== "string" || typeof event.data.conversationId !== "string" || event.data.conversationId === conversationId;
-  if (event.kind === "artifact.changed") {
-    if (!sameRoom) return false;
-    return query === "list_artifacts" || typeof parameters.artifactId !== "string" || typeof event.data.artifactId !== "string" || parameters.artifactId === event.data.artifactId;
-  }
-  if (event.kind === "conversation.removed") return sameRoom;
-  if (event.kind === "conversations.changed") {
-    const removed = event.data.removedConversationIds;
-    return Array.isArray(removed) && (typeof conversationId !== "string" || removed.includes(conversationId));
-  }
-  return false;
-}
-__name(artifactQueryAffected, "artifactQueryAffected");
 function queryAffectedByEvent(event, query, parameters) {
-  if (!ROOM_QUERIES.has(query) && !ARTIFACT_QUERIES.has(query) && !INBOX_QUERIES.has(query) && !CONTACT_QUERIES.has(query)) return true;
+  if (!ROOM_QUERIES.has(query) && !INBOX_QUERIES.has(query) && !CONTACT_QUERIES.has(query)) return true;
   if (event.kind === "agent.context" || event.kind.startsWith("replay.")) return true;
-  if (ARTIFACT_QUERIES.has(query)) return artifactQueryAffected(event, query, parameters);
-  if (event.kind === "artifact.changed") return false;
   if (/^contacts?\./.test(event.kind)) return CONTACT_QUERIES.has(query);
   if (!/^(message\.|conversations?\.|voice\.session\.)/.test(event.kind)) return true;
   if (CONTACT_QUERIES.has(query)) return false;
@@ -1172,10 +1146,10 @@ async function prepareEndpointIntent(input) {
   const { intent: intent2 } = input;
   const nested = intent2.action === "verb_execute";
   const action = nested ? intent2.body.verb : intent2.action;
-  if (!["remove_member", "update_member_role", "leave_conversation", "append_artifact_command", "retain_artifact_asset"].includes(String(action))) return intent2;
+  if (!["remove_member", "update_member_role", "leave_conversation"].includes(String(action))) return intent2;
   const body = intentBody(intent2);
   const conversationId = body.conversationId ?? body.targetConversationId;
-  const ownAdmission = ["leave_conversation", "append_artifact_command", "retain_artifact_asset"].includes(String(action));
+  const ownAdmission = action === "leave_conversation";
   const targetUserId = body.targetUserId ?? body.userId ?? body.agentId;
   if (typeof conversationId !== "string" || !ownAdmission && typeof targetUserId !== "string") {
     throw new EndpointError("Membership control requires a conversation and target", { status: 400, code: "INVALID_MEMBERSHIP_CONTROL", retryable: false });
@@ -1345,19 +1319,22 @@ async function recordMlsInteractionProjection(tx, event, timestamp) {
   await tx.put(key2, { event: copyJson(event), state: "settled", reason: "mls_interaction", createdAt: timestamp, updatedAt: timestamp });
 }
 __name(recordMlsInteractionProjection, "recordMlsInteractionProjection");
+var WORK_FLOOR_KEY = "recovery/work-floor";
+var beforeWorkFloor = /* @__PURE__ */ __name((floor, acceptedAt) => !!floor && Date.parse(acceptedAt) < Date.parse(floor.cutoverAt), "beforeWorkFloor");
 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 key2 = `inbound/${event.id}`, existing = await tx.get(key2);
   if (existing && existing.reason !== "mls_plaintext_withheld") return false;
+  const history = !own && beforeWorkFloor(await tx.get(WORK_FLOOR_KEY), timestamp);
   const record6 = {
     event: copyJson(event),
-    state: own ? "settled" : "observed",
-    ...own ? { reason: "own_mls_message" } : { queueKey: `inbound-ready/${encodeURIComponent(event.conversationId)}/mls/${String(feedOrdinal).padStart(16, "0")}/${encodeURIComponent(event.id)}` },
+    state: own || history ? "settled" : "observed",
+    ...own ? { reason: "own_mls_message" } : history ? { reason: "before_take_over" } : { queueKey: `inbound-ready/${encodeURIComponent(event.conversationId)}/mls/${String(feedOrdinal).padStart(16, "0")}/${encodeURIComponent(event.id)}` },
     createdAt: timestamp,
     updatedAt: timestamp
   };
   await tx.put(key2, record6);
-  if (!own) await enqueueInbound(tx, record6);
+  if (!own && !history) await enqueueInbound(tx, record6);
   return true;
 }
 __name(recordVerifiedMlsInboundEvent, "recordVerifiedMlsInboundEvent");
@@ -2035,7 +2012,7 @@ __name(createEndpointMigration, "createEndpointMigration");
 
 // ../endpoint/src/media.ts
 function createEndpointMediaPipeline(options) {
-  const { endpoint, store, bytes, background } = options;
+  const { endpoint, store, bytes } = options;
   const clock = options.clock ?? Date.now;
   const ids = options.ids ?? (() => crypto.randomUUID());
   const leaseMs = Math.max(1e3, options.leaseMs ?? 3e4);
@@ -2090,14 +2067,6 @@ function createEndpointMediaPipeline(options) {
   const listeners = /* @__PURE__ */ new Set();
   let closed = false;
   let foreground = true;
-  let restoredNativeObservations = false;
-  const reconciliation = /* @__PURE__ */ new Map();
-  const observations = /* @__PURE__ */ new Map();
-  let backgroundCapability;
-  let lastServerBackgroundCapability;
-  let serverPreparedContentVersion;
-  const preparationGeneration = background ? endpoint.ready().then(() => readPreparationGeneration(store)) : Promise.resolve(0);
-  void preparationGeneration.catch(() => void 0);
   let timer;
   const prefix3 = "media-flow/";
   const attachmentFor = /* @__PURE__ */ __name((file, value, resultUploadId) => {
@@ -2117,7 +2086,6 @@ function createEndpointMediaPipeline(options) {
       for (const file of previous?.files ?? []) if (file.uploadId && !currentIds.has(file.uploadId)) await tx.delete(`media-prepared-upload/${file.uploadId}`);
       for (const uploadId of currentIds) await tx.put(`media-prepared-upload/${uploadId}`, { id: flow.id });
     }
-    if (flow.status === "succeeded" || flow.status === "cancelled") delete flow.preparedContent;
     await tx.put(`${prefix3}${flow.id}`, flow);
     if (flow.status === "pending" || flow.status === "sending") await tx.put(`media-pending/${flow.id}`, { id: flow.id });
     else await tx.delete(`media-pending/${flow.id}`);
@@ -2158,10 +2126,6 @@ function createEndpointMediaPipeline(options) {
     timer.unref?.();
   }
   __name(schedule, "schedule");
-  const stopConnections = background ? endpoint.observeEvents?.(() => void 0, { families: ["messages"], onConnected: /* @__PURE__ */ __name(() => {
-    for (const state of reconciliation.values()) state.nextAt = Math.min(state.nextAt, clock() + 5e3);
-    schedule();
-  }, "onConnected") }) : void 0;
   const unsubscribe = endpoint.subscribe((operation) => {
     if (operation.status === "succeeded" && operation.action.endsWith("_upload")) schedule();
   });
@@ -2170,265 +2134,21 @@ function createEndpointMediaPipeline(options) {
     await Promise.allSettled(flow.files.filter((file) => file.reference).map((file) => bytes.release(file.reference)));
   }
   __name(release, "release");
-  function probeBackgroundCapability() {
-    if (!background) return Promise.resolve(false);
-    if (!backgroundCapability) {
-      const check = Promise.resolve().then(() => Promise.all([background.available(), endpoint.capabilities()])).then(([nativeAvailable, capabilities]) => {
-        if (capabilities) serverPreparedContentVersion = capabilities.preparedMediaContentVersion;
-        if (capabilities) lastServerBackgroundCapability = capabilities.actions.includes("stage_media_message") && (background.observationVersion !== 2 || capabilities.mediaDeliveryObservationVersion === 2);
-        return nativeAvailable && lastServerBackgroundCapability === true;
-      }).catch(() => false).then((enabled) => {
-        if (!enabled && backgroundCapability === check) backgroundCapability = void 0;
-        return enabled;
-      });
-      backgroundCapability = check;
-    }
-    return backgroundCapability;
-  }
-  __name(probeBackgroundCapability, "probeBackgroundCapability");
   const encryptedRoom = /* @__PURE__ */ __name(async (conversationId) => await endpoint.getConversationContentMode(conversationId) !== "plaintext", "encryptedRoom");
-  async function canSendInBackground(options2) {
-    if (!background) return false;
-    if (options2?.conversationId !== void 0 && await encryptedRoom(options2.conversationId).catch(() => true)) return false;
-    if (options2?.maxProbeWaitMs === void 0) return probeBackgroundCapability();
-    const nativeAvailable = await Promise.resolve().then(() => background.available()).catch(() => false);
-    if (!nativeAvailable) return false;
-    if (lastServerBackgroundCapability === false) {
-      void probeBackgroundCapability();
-      return false;
-    }
-    const check = probeBackgroundCapability();
-    const waitMs = Math.max(0, options2.maxProbeWaitMs);
-    if (waitMs === 0) return false;
-    return new Promise((resolve3) => {
-      const timer2 = setTimeout(() => resolve3(false), waitMs);
-      void check.then((enabled) => {
-        clearTimeout(timer2);
-        resolve3(enabled);
-      });
-    });
-  }
-  __name(canSendInBackground, "canSendInBackground");
-  async function applyBackgroundSnapshot(snapshot) {
-    if (closed || !background) return;
-    const flow = await read(snapshot.deliveryId);
-    if (!flow || flow.deliveryMode !== "background") return;
-    if (snapshot.schemaVersion === 2) {
-      const identity = await endpoint.ready();
-      if (!snapshot.identity || snapshot.identity.installationId !== identity.installationId || snapshot.identity.environmentId !== identity.environmentId || snapshot.identity.conversationId !== flow.conversationId || snapshot.identity.messageId !== flow.messageId) {
-        schedule();
-        return;
-      }
-    }
-    const owner = await acquire(flow.id).catch(() => null);
-    if (!owner) {
-      schedule();
-      return;
-    }
-    try {
-      const current = await read(flow.id);
-      if (!current || current.deliveryMode !== "background" || current.status === "succeeded" || current.status === "cancelled") return;
-      if (snapshot.schemaVersion === 2) {
-        const identity = await endpoint.ready();
-        if (snapshot.observation) current.observation = mergeDeliveryObservation(current.observation, snapshot.observation, {
-          deliveryId: flow.id,
-          conversationId: flow.conversationId,
-          messageId: flow.messageId,
-          installationId: identity.installationId,
-          environmentId: identity.environmentId
-        });
-        current.attention = snapshot.attention;
-        const phase = ["published", "cancelled", "expired", "rejected"].includes(snapshot.status) ? "idle" : snapshot.status;
-        current.status = projectDeliveryStatus(current.observation?.outcome ?? "unknown", phase);
-        current.background = { phase: snapshot.status, uploadedBytes: Math.max(0, snapshot.uploadedBytes), totalBytes: Math.max(0, snapshot.totalBytes) };
-        if (current.attention) current.error = { code: current.attention.code, message: snapshot.errorMessage ?? "Delivery needs attention. Its server outcome is being checked." };
-        else delete current.error;
-      } else {
-        current.background = {
-          phase: snapshot.status,
-          uploadedBytes: Math.max(0, snapshot.uploadedBytes),
-          totalBytes: Math.max(0, snapshot.totalBytes)
-        };
-        if (snapshot.status === "published") {
-          current.status = "succeeded";
-          delete current.error;
-        } else if (snapshot.status === "cancelled") {
-          current.status = "cancelled";
-          delete current.error;
-        } else if (snapshot.status === "expired" || snapshot.status === "rejected") {
-          current.status = "rejected";
-          current.error = { code: snapshot.errorCode ?? (snapshot.status === "expired" ? "MEDIA_BACKGROUND_EXPIRED" : "MEDIA_BACKGROUND_REJECTED"), message: snapshot.errorMessage ?? "Attachment delivery needs attention" };
-        } else {
-          current.status = snapshot.status === "sending" ? "sending" : "pending";
-          delete current.error;
-        }
-      }
-      await write(current, owner);
-      if (current.status === "succeeded" || current.status === "cancelled") {
-        delete current.attention;
-        delete current.error;
-        await Promise.allSettled(current.files.filter((file) => file.descriptor.cleanupAfterSend).map((file) => background.cleanupSource?.(file.reference)));
-        await write({ ...current, message: {}, files: [] }, owner);
-      }
-      if (current.status === "pending" || current.status === "sending") schedule();
-    } finally {
-      await unlock(flow.id, owner);
-    }
-  }
-  __name(applyBackgroundSnapshot, "applyBackgroundSnapshot");
-  async function authoritativeSnapshot(id2) {
-    if (!background?.reconcile || !foreground) return void 0;
-    const state = reconciliation.get(id2) ?? { nextAt: 0, failures: 0 };
-    if (state.pending) return state.pending;
-    if (clock() < state.nextAt) {
-      schedule();
-      return void 0;
-    }
-    state.nextAt = clock() + 5e3;
-    const pending = background.reconcile(id2).then((snapshot) => {
-      state.failures = 0;
-      state.nextAt = clock() + 5e3;
-      return snapshot;
-    }, (error) => {
-      state.failures += 1;
-      state.nextAt = clock() + Math.min(3e5, 5e3 * 2 ** Math.min(6, state.failures));
-      schedule();
-      throw error;
-    }).finally(() => {
-      delete state.pending;
-    });
-    state.pending = pending;
-    reconciliation.set(id2, state);
-    return pending;
-  }
-  __name(authoritativeSnapshot, "authoritativeSnapshot");
-  async function resumeBackground(flow, onProgress) {
-    if (!background) throw new EndpointError("This delivery needs a Canon version with background transfer support", { code: "MEDIA_BACKGROUND_MODULE_UNAVAILABLE", retryable: false });
+  async function retireBackground(flow) {
     if (flow.status === "succeeded") return flow.messageId;
-    if (flow.status === "cancelled") throw new EndpointError("Attachment was cancelled", { code: "MEDIA_FLOW_CANCELLED", retryable: false });
-    const snapshots = await background.inspect();
-    let snapshot = snapshots.find((item) => item.deliveryId === flow.id);
-    if (!snapshot && flow.background?.phase === "cancelling") {
-      throw new EndpointError("Cancellation is being reconciled", { code: "MEDIA_CANCELLING", retryable: true });
-    }
-    if (!snapshot) {
-      const identity = await endpoint.ready();
-      snapshot = await background.enqueue({
-        deliveryId: flow.id,
-        installationId: identity.installationId,
-        conversationId: flow.conversationId,
-        messageId: flow.messageId,
-        message: copyJson(flow.message),
-        ...flow.preparedContent ? { preparedContent: copyJson(flow.preparedContent) } : {},
-        files: flow.files.map((file) => ({ source: file.reference, descriptor: copyJson(file.descriptor) }))
-      });
-    }
-    await applyBackgroundSnapshot(snapshot);
-    if (background.reconcile) {
-      const authoritative = await authoritativeSnapshot(flow.id).catch(() => void 0);
-      if (authoritative) {
-        snapshot = authoritative;
-        await applyBackgroundSnapshot(snapshot);
-      }
-      schedule();
-    }
-    if (snapshot.schemaVersion !== 2 && (snapshot.status === "expired" || snapshot.status === "rejected")) {
-      throw new EndpointError(snapshot.errorMessage ?? "Attach this file again to send it", {
-        code: snapshot.errorCode ?? (snapshot.status === "expired" ? "MEDIA_BACKGROUND_EXPIRED" : "MEDIA_BACKGROUND_REJECTED"),
-        retryable: false
-      });
-    }
-    const phase = snapshot.status === "waiting_for_connection" ? "waiting_for_connection" : snapshot.status === "cancelling" ? "cancelling" : snapshot.status === "sending" || snapshot.status === "published" ? "sending" : snapshot.status === "uploading" ? "uploading" : "preparing";
-    onProgress?.({ phase, uploadedBytes: snapshot.uploadedBytes, totalBytes: snapshot.totalBytes });
-    return flow.messageId;
-  }
-  __name(resumeBackground, "resumeBackground");
-  async function stageBackground(input, sendOptions) {
-    if (!background) throw new Error("Background media adapter is missing");
-    const id2 = flowId(input.conversationId, input.messageId);
-    const existing = staging.get(id2);
-    if (existing) {
-      await existing;
-      return stageBackground(input, sendOptions);
-    }
-    const staged = (async () => {
-      if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-      const fingerprint = await hash(canonicalEndpointJson({ message: input.message, files: input.files.map((file) => ({ descriptor: file.descriptor, source: background.sourceIdentity(file.source) })) }));
-      if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-      const owner = await acquire(id2);
-      try {
-        if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-        const prior = await read(id2);
-        if (prior) {
-          if (prior.deliveryMode !== "background" || prior.fingerprint !== fingerprint) throw new EndpointError("Message identity already belongs to another attachment", { status: 409, code: "MEDIA_FLOW_CONFLICT", retryable: false });
-        } else {
-          const flow = {
-            id: id2,
-            conversationId: input.conversationId,
-            messageId: input.messageId,
-            message: copyJson(input.message),
-            fingerprint,
-            createdAt: new Date(clock()).toISOString(),
-            files: input.files.map((file) => ({ descriptor: copyJson(file.descriptor), reference: background.sourceIdentity(file.source) })),
-            deliveryMode: "background",
-            status: "pending",
-            background: { phase: "preparing", uploadedBytes: 0, totalBytes: input.files.reduce((sum, file) => sum + file.descriptor.sizeBytes, 0) }
-          };
-          if (background.preparedContentVersion === 1 && serverPreparedContentVersion === 1) {
-            const generation2 = await preparationGeneration;
-            const operationId = `media:${id2}`;
-            await reservePreparedIdentity(store, { operationId, action: "send_message", fingerprint, installationGeneration: generation2 });
-            const committed = await prepareAndCommitContent({
-              store,
-              scope: input.conversationId,
-              installationGeneration: generation2,
-              existing: /* @__PURE__ */ __name((tx) => tx.get(`${prefix3}${id2}`), "existing"),
-              prepare: /* @__PURE__ */ __name(async (snapshot) => ({ nextProtocolState: snapshot.protocolState, payload: prepareJsonContent({
-                context: { action: "send_message", conversationId: input.conversationId, messageId: input.messageId },
-                body: { ...input.message, conversationId: input.conversationId, messageId: input.messageId },
-                blobs: input.files.map((_, index) => ({ id: logicalMediaBlobId(input.conversationId, input.messageId, index), index })),
-                expected: { installationGeneration: generation2, protocolRevision: snapshot.protocolRevision, ...snapshot.admission ? { admission: snapshot.admission } : {} }
-              }) }), "prepare"),
-              commit: /* @__PURE__ */ __name(async (tx, preparedContent) => {
-                if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-                const sealed = { ...flow, preparedContent };
-                await writeInTransaction(tx, sealed, owner);
-                await tx.delete(`preparation/${operationId}`);
-                return sealed;
-              }, "commit")
-            });
-            notifyFlow(committed);
-          } else await write(flow, owner);
-        }
-      } finally {
-        await unlock(id2, owner);
-      }
-      const onAbort = /* @__PURE__ */ __name(() => {
-        void pipeline3.cancel(id2).catch(() => void 0);
-      }, "onAbort");
-      sendOptions?.signal?.addEventListener("abort", onAbort, { once: true });
+    if (flow.status !== "cancelled") {
+      const owner = await acquire(flow.id);
       try {
-        if (sendOptions?.signal?.aborted) onAbort();
-        return await resumeBackground(await read(id2), sendOptions?.onProgress);
+        const { id: id2, conversationId, messageId, createdAt, deliveryMode } = flow;
+        await write({ id: id2, conversationId, messageId, createdAt, deliveryMode, message: {}, files: [], status: "cancelled" }, owner);
       } finally {
-        sendOptions?.signal?.removeEventListener("abort", onAbort);
+        await unlock(flow.id, owner);
       }
-    })();
-    staging.set(id2, staged);
-    try {
-      return await staged;
-    } finally {
-      if (staging.get(id2) === staged) staging.delete(id2);
     }
+    throw new EndpointError("Attachment was cancelled", { code: "MEDIA_FLOW_CANCELLED", retryable: false });
   }
-  __name(stageBackground, "stageBackground");
-  const stopBackground = background?.subscribe((snapshot) => {
-    const next = (observations.get(snapshot.deliveryId) ?? Promise.resolve()).then(() => applyBackgroundSnapshot(snapshot)).catch(() => schedule());
-    observations.set(snapshot.deliveryId, next);
-    void next.finally(() => {
-      if (observations.get(snapshot.deliveryId) === next) observations.delete(snapshot.deliveryId);
-    });
-  });
+  __name(retireBackground, "retireBackground");
   async function stage(input, sendOptions, prepareOnly = false) {
     if (closed) throw new Error("Endpoint media pipeline is closed");
     const id2 = flowId(input.conversationId, input.messageId);
@@ -2470,7 +2190,7 @@ function createEndpointMediaPipeline(options) {
             files.push({ descriptor: copyJson(file.descriptor), reference: await bytes.retain(`${id2}:${fingerprint}:${index}`, file.source) });
           }
           checkOpen();
-          await write({ id: id2, ...prepareOnly ? { purpose: "prepare" } : {}, conversationId: input.conversationId, messageId: input.messageId, fingerprint, createdAt: new Date(clock()).toISOString(), ...sendOptions?.beforePublish ? { requiresPublicationApproval: true } : {}, message: copyJson(input.message), files, deliveryMode: "legacy", status: "pending" }, owner);
+          await write({ id: id2, ...prepareOnly ? { purpose: "prepare" } : {}, conversationId: input.conversationId, messageId: input.messageId, fingerprint, createdAt: new Date(clock()).toISOString(), ...sendOptions?.beforePublish ? { requiresPublicationApproval: true } : {}, message: copyJson(input.message), files, status: "pending" }, owner);
         }
       } catch (error) {
         await Promise.allSettled(files.map((file) => bytes.release(file.reference)));
@@ -2492,18 +2212,9 @@ function createEndpointMediaPipeline(options) {
   }
   __name(stage, "stage");
   const pipeline3 = {
-    canSendInBackground,
     async send(input, sendOptions) {
-      const id2 = flowId(input.conversationId, input.messageId);
-      const prior = await read(id2);
-      if (prior?.deliveryMode === "background") return stageBackground(input, sendOptions);
-      if (!prior && !sendOptions?.beforePublish && sendOptions?.handoffMode !== "legacy") {
-        const encrypted = await encryptedRoom(input.conversationId);
-        if (encrypted && sendOptions?.handoffMode === "background") {
-          throw new EndpointError("An encrypted room's attachments are prepared on this device", { code: "MEDIA_BACKGROUND_UNAVAILABLE", retryable: false });
-        }
-        if (!encrypted && (sendOptions?.handoffMode === "background" || await canSendInBackground())) return stageBackground(input, sendOptions);
-      }
+      const prior = await read(flowId(input.conversationId, input.messageId));
+      if (prior?.deliveryMode === "background") return retireBackground(prior);
       return stage(input, sendOptions);
     },
     async prepare(input, prepareOptions) {
@@ -2515,7 +2226,7 @@ function createEndpointMediaPipeline(options) {
     },
     async resume(id2, resumeOptions) {
       const persisted = await read(id2);
-      if (persisted?.deliveryMode === "background") return resumeBackground(persisted, resumeOptions?.onProgress);
+      if (persisted?.deliveryMode === "background") return retireBackground(persisted);
       installGuard(id2, resumeOptions?.beforePublish);
       const existing = running.get(id2);
       if (existing) return existing;
@@ -2557,7 +2268,7 @@ function createEndpointMediaPipeline(options) {
           const progress = /* @__PURE__ */ __name((phase) => resumeOptions?.onProgress?.({ phase, totalBytes, uploadedBytes: offsets.reduce((sum, offset) => sum + offset, 0) }), "progress");
           const publicationOperationId = /* @__PURE__ */ __name(() => `message:${flow.conversationId}:${flow.messageId}${flow.publicationGeneration ? `:g${flow.publicationGeneration}` : ""}`, "publicationOperationId");
           const publish = /* @__PURE__ */ __name(async (reconciling = false) => {
-            if (!reconciling && flow.requiresPublicationApproval && !await publicationGuards.get(id2)?.check()) {
+            if (!reconciling && flow.requiresPublicationApproval && !await publicationGuards.get(id2)?.check({ automaticResend: false })) {
               throw new EndpointError("Attachment publication requires a current audience approval", { code: "MEDIA_PUBLICATION_APPROVAL_REQUIRED", retryable: true });
             }
             flow.status = "sending";
@@ -2771,15 +2482,6 @@ function createEndpointMediaPipeline(options) {
     },
     async resumePending() {
       if (closed) return;
-      if (background?.reconcile && !restoredNativeObservations) {
-        restoredNativeObservations = true;
-        try {
-          for (const snapshot of await background.inspect()) await applyBackgroundSnapshot(snapshot);
-        } catch {
-          restoredNativeObservations = false;
-          schedule();
-        }
-      }
       let after;
       do {
         const records = await store.transaction((tx) => tx.scan("media-pending/", { after, limit: 100 }));
@@ -2793,20 +2495,9 @@ function createEndpointMediaPipeline(options) {
       if (saved) await pipeline3.cancel(saved.id);
     },
     async cancel(id2) {
-      const backgroundFlow = await read(id2);
-      if (backgroundFlow?.deliveryMode === "background") {
-        if (!background || backgroundFlow.status === "succeeded" || backgroundFlow.status === "cancelled") return;
-        const owner2 = await acquire(id2);
-        try {
-          const current = await read(id2);
-          if (!current || current.status === "succeeded" || current.status === "cancelled") return;
-          current.background = { phase: "cancelling", uploadedBytes: current.background?.uploadedBytes ?? 0, totalBytes: current.background?.totalBytes ?? 0 };
-          await write(current, owner2);
-        } finally {
-          await unlock(id2, owner2);
-        }
-        await background.cancel(id2);
-        schedule();
+      const retired = await read(id2);
+      if (retired?.deliveryMode === "background") {
+        await retireBackground(retired).catch(() => void 0);
         return;
       }
       if (staging.has(id2)) cancelledStages.add(id2);
@@ -2829,15 +2520,12 @@ function createEndpointMediaPipeline(options) {
     async close(closeOptions) {
       closed = true;
       unsubscribe();
-      stopConnections?.();
-      stopBackground?.();
       listeners.clear();
       for (const guard of publicationGuards.values()) guard.unregister();
       publicationGuards.clear();
       if (timer) clearTimeout(timer);
       for (const controller of controllers.values()) controller.abort();
       await Promise.allSettled([...staging.values(), ...running.values()]);
-      if (closeOptions?.discard) await background?.cleanup();
       if (closeOptions?.discard) {
         let after;
         do {
@@ -3412,13 +3100,6 @@ function createExternalInboundClaims(input) {
 }
 __name(createExternalInboundClaims, "createExternalInboundClaims");
 
-// ../endpoint/src/artifact-context.ts
-var contexts = /* @__PURE__ */ new WeakMap();
-function registerArtifactEndpoint(endpoint, context) {
-  contexts.set(endpoint, context);
-}
-__name(registerArtifactEndpoint, "registerArtifactEndpoint");
-
 // ../endpoint/src/receipts.ts
 function endpointReceiptResult(receipt) {
   if (receipt.resultError) throw new EndpointError(receipt.resultError.message, { status: receipt.resultError.status, code: receipt.resultError.code, retryable: receipt.resultError.retryable, operationId: receipt.operationId });
@@ -5295,6 +4976,12 @@ var appIntentKey = /* @__PURE__ */ __name((operationId) => `mls-dev-group/applic
 var appOperationKey = /* @__PURE__ */ __name((deviceId, operationId) => `mls-dev-group/application-operation/${encodeURIComponent(deviceId)}/${encodeURIComponent(operationId)}`, "appOperationKey");
 var acceptedReceiptKey = /* @__PURE__ */ __name((operationId) => `mls-dev-group/accepted-receipt/${encodeURIComponent(operationId)}`, "acceptedReceiptKey");
 var appMessageKey = /* @__PURE__ */ __name((cid, messageId) => `mls-dev-group/application-id/${encodeURIComponent(cid)}/${encodeURIComponent(messageId)}`, "appMessageKey");
+var BEHIND_CODES = ["MLS_DEV_GROUP_HEAD_CHANGED", "MLS_DEV_GROUP_ADMISSION_CHANGED"];
+var MLS_DEV_RESEND_MAX = 3;
+var readersOf = /* @__PURE__ */ __name((roster) => [...new Set(roster.flatMap(({ device: { principal, installationId } }) => [
+  `${principal.type}:${principal.id}`,
+  ...isConnectorRelayInstallation(installationId) ? [`relay:${installationId}`] : []
+]))].sort(), "readersOf");
 var same6 = /* @__PURE__ */ __name((a, b) => canonicalEndpointJson(a) === canonicalEndpointJson(b), "same");
 async function roomRemoval(tx, conversationId) {
   const room = await tx.get(`conversation/${conversationId}`);
@@ -5322,6 +5009,10 @@ function fail6(code = "MLS_DEV_GROUP_STATE_INVALID", retryable = false) {
   throw new EndpointError(code, { code, retryable });
 }
 __name(fail6, "fail");
+function admissionOf(operation) {
+  return operation.request?.body.value?.preconditions?.admissionId;
+}
+__name(admissionOf, "admissionOf");
 function id(value) {
   if (typeof value !== "string" || !ENDPOINT_ID_PATTERN.test(value) || value === "." || value === "..") fail6("INVALID_MLS_DEV_GROUP_INPUT");
   return value;
@@ -6065,9 +5756,10 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       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 } : {};
+      const outside = !!room && !!room.mls && (!group || group.removed);
+      const noted = { ...missed, ...outside ? { outside: 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] : []), ...missed });
+        return Object.freeze({ held: outside, waitingPrincipalIds: Object.freeze(outside ? [init.identity.principalId] : []), ...noted });
       }
       const accounts = mlsRoomAccounts(room, init.binding.environmentId);
       const admitted = new Set((group && !group.removed ? group.roster : []).map((entry) => mlsAccountOf(accounts, entry.device.principal)));
@@ -6080,7 +5772,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
         joinedAtMs: Number(room.mlsMemberJoinedAtMs),
         nowMs: context.clock()
       });
-      return Object.freeze({ held: waiting.length > 0, waitingPrincipalIds: Object.freeze(waiting), ...missed });
+      return Object.freeze({ held: waiting.length > 0, waitingPrincipalIds: Object.freeze(waiting), ...noted });
     });
   }
   __name(admissionHold, "admissionHold");
@@ -6088,7 +5780,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     if ((await admissionHold(conversationId)).held) fail6("MLS_DEV_GROUP_ADMISSION_PENDING", true);
   }
   __name(assertNotHeld, "assertNotHeld");
-  async function sendText(input, operationId, guardId) {
+  async function sendText(input, operationId, guardId, resend) {
     const cid = input.conversationId, init = await initialized();
     const authoredHash = await bridge.hash(canonicalEndpointJson(guardId ? { ...input, guardId } : input));
     async function existing(tx) {
@@ -6100,10 +5792,11 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     __name(existing, "existing");
     const previous = await store.transaction(existing);
     if (previous) return previous;
-    if (!await caughtUp(cid)) await refresh(cid);
+    if (resend || !await caughtUp(cid)) await refresh(cid);
     await assertNotHeld(cid);
     const messageId = input.messageId ?? id(context.ids());
     let captured, replyTo;
+    let replaced, written;
     const operation = await prepareAndCommitContent({
       store,
       scope: scope4(cid),
@@ -6111,7 +5804,9 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       existing: /* @__PURE__ */ __name(async (tx, state) => {
         const previous2 = await existing(tx);
         if (previous2) return previous2;
-        if (await tx.get(appMessageKey(cid, messageId)) !== void 0 || await tx.get(mlsDevTextMessageKey(cid, messageId)) !== void 0) fail6("MLS_DEV_APPLICATION_ID_CONFLICT");
+        const mapped = await tx.get(appMessageKey(cid, messageId)), local = await tx.get(mlsDevTextMessageKey(cid, messageId));
+        if (resend ? mapped !== resend.previous.operationId || local?.message.operationId !== resend.previous.operationId || local.feedOrdinal !== null || local.deleted : mapped !== void 0 || local !== void 0) fail6("MLS_DEV_APPLICATION_ID_CONFLICT");
+        written = local?.createdAtMs;
         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");
@@ -6120,7 +5815,8 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
           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) {
+        if (resend?.replyTo) replyTo = resend.replyTo;
+        else if (input.replyTo) {
           const quote = mlsDevReplyQuote(await tx.get(mlsDevTextMessageKey(cid, input.replyTo)), MLS_DEV_REPLY_QUOTE_MAX_CHARACTERS);
           replyTo = { messageId: input.replyTo, quote: quote ?? fail6("MLS_DEV_REPLY_UNAVAILABLE") };
         }
@@ -6128,6 +5824,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
         await assertRoomOpen(tx, cid, group.roster);
         if (group.pending) fail6("MLS_DEV_GROUP_PENDING_CONTROL", true);
         if (!same6(group.head, current.authority?.marker?.head)) fail6("MLS_DEV_GROUP_HEAD_CHANGED", true);
+        if (resend?.readers && (readersOf(group.roster).some((reader) => !resend.readers.includes(reader)) || current.authority?.admissionId !== admissionOf(resend.previous))) fail6("MLS_DEV_RESEND_AUDIENCE_CHANGED");
         captured = current;
         return void 0;
       }, "existing"),
@@ -6179,8 +5876,24 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       commit: /* @__PURE__ */ __name(async (tx, prepared, state) => {
         const current = await capture(tx, state, init, cid);
         if (current.fingerprint !== prepared.fingerprint) fail6("MLS_DEV_GROUP_DEPENDENCY_CHANGED", true);
-        const createdAtMs = context.clock(), timestamp = new Date(createdAtMs).toISOString();
-        await tx.put(appIntentKey(operationId), { version: 1, authoredHash, envelope: prepared.wire, envelopeHash: prepared.envelopeHash });
+        const timestamp = new Date(context.clock()).toISOString();
+        let queueOrder;
+        if (resend) {
+          const before = await tx.get(`operation/${resend.previous.operationId}`);
+          const settled = before && resend.receipt ? await bridge.settle(tx, before, resend.receipt, false) : before;
+          if (settled?.status !== "rejected" || settled.resentAs) fail6("MLS_DEV_RESEND_UNAVAILABLE");
+          if (resend.receipt) queueOrder = settled.queueOrder;
+          replaced = { ...settled, resentAs: operationId, updatedAt: timestamp };
+          await tx.put(`operation/${settled.operationId}`, replaced);
+        }
+        await tx.put(appIntentKey(operationId), {
+          version: 1,
+          authoredHash,
+          envelope: prepared.wire,
+          envelopeHash: prepared.envelopeHash,
+          readers: resend?.readers ?? readersOf(current.envelope.roster),
+          resends: resend?.resends ?? 0
+        });
         await tx.put(appMessageKey(cid, messageId), operationId);
         await putMlsDevTextMessage(tx, {
           version: 1,
@@ -6188,7 +5901,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
           senderId: init.binding.principal.id,
           senderType: principal.type,
           status: "queued",
-          createdAtMs,
+          createdAtMs: written ?? context.clock(),
           feedOrdinal: null
         });
         const media = prepared.text.kind === "item" ? { mediaUploadIds: [prepared.text.item.uploadId] } : {};
@@ -6201,7 +5914,9 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
           messageId,
           fingerprint: prepared.envelopeHash,
           ordering: "conversation",
+          ...queueOrder === void 0 ? {} : { queueOrder },
           ...guardId ? { guardId } : {},
+          ...resend?.receipt ? { automaticResend: true } : {},
           sensitive: false,
           status: "queued",
           attempts: 0,
@@ -6219,10 +5934,45 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
         });
       }, "commit")
     });
+    if (replaced) await bridge.afterReceipt(replaced);
     bridge.submitted(operation);
     return operation;
   }
   __name(sendText, "sendText");
+  async function resendText(operation, receipt) {
+    const cid = operation.conversationId, messageId = operation.messageId;
+    if (operation.action !== "mls_application" || !cid || !messageId) return void 0;
+    if (receipt && (receipt.status !== "rejected" || !BEHIND_CODES.includes(receipt.error?.code ?? ""))) return void 0;
+    const { intent: intent2, local } = await store.transaction(async (tx) => ({
+      intent: await tx.get(appIntentKey(operation.operationId)),
+      local: await tx.get(mlsDevTextMessageKey(cid, messageId))
+    }));
+    const message = local?.message;
+    if (!intent2 || !local || local.deleted || local.feedOrdinal !== null || message?.operationId !== operation.operationId || message.kind !== "text" && message.kind !== "item") return void 0;
+    if (receipt && (!intent2.readers || (intent2.resends ?? 0) >= MLS_DEV_RESEND_MAX)) return void 0;
+    const { replyTo, mentions, ...item } = message.kind === "item" ? message.item : { replyTo: message.replyTo, mentions: message.mentions };
+    const replyAuthority = operation.request?.body.value.replyAuthority;
+    const input = {
+      conversationId: cid,
+      messageId,
+      ...message.kind === "item" ? { item } : { text: message.text },
+      ...replyTo ? { replyTo: replyTo.messageId } : {},
+      ...mentions?.length ? { mentions: [...mentions] } : {},
+      ...replyAuthority ? { replyAuthority } : {}
+    };
+    const successor = id(await bridge.hash(canonicalEndpointJson(["canon.mls.dev-resend.v1", operation.operationId])));
+    try {
+      return await sendText(input, successor, operation.guardId, {
+        previous: operation,
+        ...replyTo ? { replyTo } : {},
+        ...receipt ? { receipt, readers: intent2.readers, resends: (intent2.resends ?? 0) + 1 } : { resends: 0 }
+      });
+    } catch (error) {
+      if (!receipt || !(error instanceof EndpointError) || error.retryable || ["ENDPOINT_CLOSED", "PREPARATION_INSTALLATION_FENCED"].includes(error.code)) throw error;
+      return void 0;
+    }
+  }
+  __name(resendText, "resendText");
   async function holdText(input, operationId) {
     const cid = input.conversationId;
     if (input.item || input.replyAuthority || typeof input.text !== "string") return sendText(input, operationId);
@@ -7069,6 +6819,11 @@ 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)));
     },
+    /** A person's Retry of a text or item Canon refused: encrypted again for the room as it is now (`resendText`). */
+    resendText(operation) {
+      const cid = id(operation.conversationId);
+      return run(() => serializeInboundPreparation(store, cid, () => resendText(operation)));
+    },
     /** `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);
@@ -7116,9 +6871,9 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
         return receipt;
       });
     },
-    async settleReceipt(operation, receipt) {
+    async settleReceipt(operation, receipt, options2) {
       if (!["mls_group_control", "mls_application"].includes(operation.action)) return false;
-      if (operation.action === "mls_application" && receipt.status !== "succeeded") return false;
+      if (operation.action === "mls_application" && receipt.status !== "succeeded") return !options2?.reconcileOnly && receipt.status === "rejected" && BEHIND_CODES.includes(receipt.error?.code ?? "") && !!operation.conversationId && await run(() => serializeInboundPreparation(store, operation.conversationId, () => resendText(operation, receipt))) !== void 0;
       if (receipt.status === "succeeded" && isMlsDevTextProtocol(await bridge.resolveProtocol?.(operation.conversationId ?? fail6()))) {
         const cid = operation.conversationId;
         const accepted2 = operation.action === "mls_application" ? parseMlsDevApplicationReceipt(receipt.result) : parseMlsDevGroupAcceptedControl(receipt.result);
@@ -7204,6 +6959,8 @@ function terminal(status) {
   return status === "succeeded" || status === "rejected";
 }
 __name(terminal, "terminal");
+var TAKE_OVER_OPERATION = "initialize-endpoint:take-over:";
+var TAKE_OVER_DISCARDED = "A take-over is not sent again by itself; start the runner with --take-over again";
 function safeError(error) {
   return error instanceof EndpointError ? error : new EndpointError("Canon delivery is deferred until the connection recovers");
 }
@@ -7295,6 +7052,19 @@ function createEndpoint(options) {
     return identity;
   });
   void initialization.catch(() => void 0);
+  const opened = initialization.then(() => store.transaction(async (tx) => {
+    for (let after; ; ) {
+      const page = await tx.scan("outbox/", { ...after ? { after } : {}, limit: 100 });
+      for (const entry of page) {
+        if (!entry.value.operationId.startsWith(TAKE_OVER_OPERATION)) continue;
+        const operation = await tx.get(key2(entry.value.operationId));
+        if (operation && !terminal(operation.status)) await discardOperation(tx, operation, TAKE_OVER_DISCARDED);
+      }
+      if (page.length < 100) return;
+      after = page.at(-1).key;
+    }
+  }));
+  void opened.catch(() => void 0);
   let mlsPrincipal;
   function readMlsPrincipalId() {
     mlsPrincipal ??= (async () => {
@@ -7506,6 +7276,7 @@ function createEndpoint(options) {
   const admissionTimers = /* @__PURE__ */ new Map();
   const ADMISSION_IDLE_MS = 10 * 6e4, CLAIM_JOURNAL_KEEP_MS = 60 * 6e4;
   const admissionUnfinished = /* @__PURE__ */ new Set();
+  const announcementLooks = /* @__PURE__ */ new Map();
   const claimAdds = /* @__PURE__ */ new Map(), CLAIM_ADDS_MAX = 3;
   const admissionRetry = { initial: options.mlsAdmissionRetryMs?.initial ?? 3e4, maximum: options.mlsAdmissionRetryMs?.maximum ?? 12e4 };
   function scheduleAdmission(conversationId, delayMs, discover = false) {
@@ -7532,13 +7303,24 @@ function createEndpoint(options) {
     const inRoster = new Set(group.roster.map((entry) => mlsAccountOf(accounts, entry.device.principal)));
     const invitee = local?.mlsInviteeId;
     const missing = [...local?.memberIds ?? [], ...typeof invitee === "string" ? [invitee] : []].some((memberId) => !inRoster.has(memberId)) || admissionUnfinished.has(conversationId);
-    if (!missing) admissionDelays.delete(conversationId);
-    const delay = admissionDelays.get(conversationId) ?? admissionRetry.initial;
     const announced = local?.mlsDeviceAnnouncedAtMs;
-    const due = announced !== announcementsSeen.get(conversationId) ? -Infinity : (admissionRuns.get(conversationId) ?? -Infinity) + (missing ? delay : ADMISSION_IDLE_MS);
-    if (clock() < due) return missing ? scheduleAdmission(conversationId, due - clock()) : void 0;
+    const fresh = announced !== announcementsSeen.get(conversationId);
+    if ((announcementLooks.get(conversationId)?.roster ?? Infinity) < group.roster.length) announcementLooks.delete(conversationId);
+    const look = announcementLooks.get(conversationId), retrying = missing || !!look;
+    if (!retrying) admissionDelays.delete(conversationId);
+    const delay = admissionDelays.get(conversationId) ?? admissionRetry.initial;
+    let due = fresh ? -Infinity : (admissionRuns.get(conversationId) ?? -Infinity) + (retrying ? delay : ADMISSION_IDLE_MS);
+    if (look && !missing) due = Math.min(due, look.untilMs);
+    if (clock() < due) return retrying ? scheduleAdmission(conversationId, due - clock()) : void 0;
     admitting.add(conversationId);
+    const watched = announcementsSeen.has(conversationId);
     announcementsSeen.set(conversationId, announced);
+    if (fresh && typeof announced === "number" && (watched || clock() < announced + MLS_DEV_KEY_PACKAGE_CLAIM_LEASE_MS)) {
+      announcementLooks.set(conversationId, {
+        untilMs: clock() + MLS_DEV_KEY_PACKAGE_CLAIM_LEASE_MS + admissionRetry.initial,
+        roster: group.roster.length
+      });
+    }
     try {
       admissionRuns.set(conversationId, clock());
       await mlsDevKeyPackages.pruneClaims(clock() - CLAIM_JOURNAL_KEEP_MS);
@@ -7596,13 +7378,16 @@ function createEndpoint(options) {
         admissionRuns.delete(conversationId);
         admissionDelays.delete(conversationId);
         admissionUnfinished.delete(conversationId);
+        announcementLooks.delete(conversationId);
         return scheduleAdmission(conversationId, admissionRetry.initial);
       }
       if (unfinished) admissionUnfinished.add(conversationId);
       else admissionUnfinished.delete(conversationId);
-      if (missing || unfinished) {
+      if ((announcementLooks.get(conversationId)?.untilMs ?? -Infinity) <= clock()) announcementLooks.delete(conversationId);
+      const looking = !missing && !unfinished ? announcementLooks.get(conversationId) : void 0;
+      if (missing || unfinished || looking) {
         admissionDelays.set(conversationId, Math.min(delay * 2, admissionRetry.maximum));
-        scheduleAdmission(conversationId, delay);
+        scheduleAdmission(conversationId, looking ? Math.min(delay, Math.max(0, looking.untilMs - clock())) : delay);
       }
     } finally {
       admitting.delete(conversationId);
@@ -7931,6 +7716,51 @@ function createEndpoint(options) {
     }
   }
   __name(refreshMlsRoomFromHint, "refreshMlsRoomFromHint");
+  const roomHints = /* @__PURE__ */ new Map();
+  let roomHintWorker;
+  function queueRoomHint(key3, run, last = false) {
+    if (closed) return Promise.resolve();
+    let hint = roomHints.get(key3);
+    if (hint && last) roomHints.delete(key3);
+    if (!hint) {
+      let settle;
+      const done = new Promise((resolve3, reject) => {
+        settle = /* @__PURE__ */ __name((error) => error === void 0 ? resolve3() : reject(error), "settle");
+      });
+      done.catch(() => void 0);
+      hint = { run, done, settle };
+    }
+    roomHints.set(key3, hint);
+    drainRoomHints();
+    return hint.done;
+  }
+  __name(queueRoomHint, "queueRoomHint");
+  function drainRoomHints() {
+    if (roomHintWorker) return;
+    roomHintWorker = (async () => {
+      for (const [key3, hint] of roomHints) {
+        roomHints.delete(key3);
+        if (closed) {
+          hint.settle();
+          continue;
+        }
+        try {
+          await hint.run();
+          hint.settle();
+        } catch (error) {
+          hint.settle(error);
+        }
+      }
+    })().finally(() => {
+      roomHintWorker = void 0;
+      if (roomHints.size) drainRoomHints();
+    });
+  }
+  __name(drainRoomHints, "drainRoomHints");
+  const hintRoom = /* @__PURE__ */ __name((conversationId) => queueRoomHint(`room/${conversationId}`, async () => {
+    await refreshMlsRoomFromHint(conversationId);
+    await sendDeferredOpeners(conversationId);
+  }), "hintRoom");
   const queryObserver = createEndpointQueryObserver({ query: /* @__PURE__ */ __name((name, parameters) => endpoint.query(name, parameters), "query"), getPollInterval: /* @__PURE__ */ __name(() => events.isConnected() ? Math.max(options.queryIntervalMs ?? 0, 6e4) : options.queryIntervalMs ?? 3e3, "getPollInterval") });
   const invalidateEvent = /* @__PURE__ */ __name((event) => queryObserver.invalidate(event ? (query, parameters) => queryAffectedByEvent(event, query, parameters) : void 0), "invalidateEvent");
   const syncConversation = createConversationSynchronizer({ store, query: /* @__PURE__ */ __name((name, parameters) => endpoint.query(name, parameters), "query"), ready: /* @__PURE__ */ __name(() => initialization, "ready"), clock, invalidate: /* @__PURE__ */ __name((conversationId) => invalidateEvent({ kind: "conversation.changed", data: { conversationId } }), "invalidate"), admitRecoveredMessages: options.admitRecoveredMessages, preparationGeneration: /* @__PURE__ */ __name(() => installationGeneration, "preparationGeneration"), prepareProtocol: /* @__PURE__ */ __name((id2) => refreshMlsRoom(id2, true), "prepareProtocol"), syncProtocol: /* @__PURE__ */ __name(async (id2, opts) => {
@@ -7939,19 +7769,20 @@ function createEndpoint(options) {
     return mlsDevGroups.syncText(id2, opts);
   }, "syncProtocol") });
   const events = createEndpointEventHub({ transport, invalidate: invalidateEvent, onDisconnected: /* @__PURE__ */ __name(() => queryObserver.reschedule(), "onDisconnected"), onEvent: /* @__PURE__ */ __name(async (event) => {
+    const hinted = [];
     if (mlsDevGroups && ["conversation.changed", "conversation.updated", "conversation.removed"].includes(event.kind)) {
       const id2 = event.data.conversationId ?? event.data.id;
       if (typeof id2 === "string" && ENDPOINT_ID_PATTERN.test(id2)) {
         if (event.kind === "conversation.changed" && event.data.projection === void 0) forgetStubReads(id2);
         const unseenRemoval = event.kind === "conversation.removed" && await store.transaction(async (tx) => await tx.get(`conversation/${id2}`) === void 0 && !await isMlsDevRoomProtected(tx, id2));
-        if (!unseenRemoval) await refreshMlsRoomFromHint(id2);
-        await sendDeferredOpeners(id2);
+        if (!unseenRemoval) hinted.push(hintRoom(id2));
+        else await sendDeferredOpeners(id2);
       }
     }
     if (mlsDevGroups && event.kind === "conversations.changed" && Array.isArray(event.data.conversationIds)) {
       for (const id2 of event.data.conversationIds) {
         if (typeof id2 === "string" && ENDPOINT_ID_PATTERN.test(id2) && await store.transaction((tx) => isMlsDevRoomProtected(tx, id2))) {
-          await refreshMlsRoomFromHint(id2);
+          hinted.push(hintRoom(id2));
         }
       }
     }
@@ -7963,13 +7794,16 @@ function createEndpoint(options) {
       if (event.kind === "connected") serverRoomMode = void 0;
       for (let after; ; ) {
         const page = await store.transaction((tx) => tx.scan("mls-dev-group/mode/", { after, limit: 100 }));
-        for (const item of page) await refreshMlsRoomFromHint(decodeURIComponent(item.key.slice("mls-dev-group/mode/".length)));
+        for (const item of page) hinted.push(hintRoom(decodeURIComponent(item.key.slice("mls-dev-group/mode/".length))));
         if (page.length < 100) break;
         after = page[page.length - 1].key;
       }
-      await sendDeferredOpeners();
-      await discoverInviteeRooms().catch(() => void 0);
+      hinted.push(queueRoomHint("after/reconnect", async () => {
+        await sendDeferredOpeners();
+        await discoverInviteeRooms().catch(() => void 0);
+      }, true));
     }
+    if (event.id) await Promise.all(hinted);
     if ((event.kind === "message.updated" || event.kind === "message.deleted") && typeof event.data.conversationId === "string" && typeof event.data.messageId === "string" && ENDPOINT_ID_PATTERN.test(event.data.conversationId)) {
       const room = event.data.conversationId, message = event.data.messageId;
       const applied = await store.transaction(async (tx) => {
@@ -8050,6 +7884,24 @@ function createEndpoint(options) {
     else await enqueueInbound(tx, next);
   }
   __name(writeInboundState, "writeInboundState");
+  async function discardOperation(tx, operation, message) {
+    const status = operation.attempted ? "uncertain" : "rejected";
+    const next = { ...operation, status, updatedAt: now(), receipt: {
+      ...deferredReceipt(operation),
+      status,
+      updatedAt: now(),
+      error: { code: "OPERATION_DISCARDED", message, retryable: false }
+    } };
+    delete next.request;
+    delete next.preparedContent;
+    delete next.lease;
+    delete next.nextAttemptAt;
+    await tx.put(key2(operation.operationId), next);
+    await settleMlsDevTextOperation(tx, next);
+    await removeOperationOutbox(tx, operation);
+    if (!operation.attempted) await settleOperationOrder(tx, operation);
+  }
+  __name(discardOperation, "discardOperation");
   function deferredReceipt(operation, error) {
     return operation.receipt ?? {
       protocol: CANON_ENDPOINT_PROTOCOL,
@@ -8171,12 +8023,18 @@ function createEndpoint(options) {
     if (mlsDevGroups && typeof made === "string" && ENDPOINT_ID_PATTERN.test(made)) void refreshMlsRoom(made, true).catch(() => void 0);
   }
   __name(afterReceipt, "afterReceipt");
-  async function persistReceipt(operation, receipt) {
-    if (await mlsDevGroups?.settleReceipt(operation, receipt)) return;
+  async function persistReceipt(operation, receipt, reconcileOnly = false) {
+    if (await mlsDevGroups?.settleReceipt(operation, receipt, { reconcileOnly })) return;
     const updated = await store.transaction((tx) => commitReceipt(tx, operation, receipt));
     await afterReceipt(updated);
   }
   __name(persistReceipt, "persistReceipt");
+  async function answerOf(operationId, receipt, reconcileOnly = false) {
+    if (receipt.action !== "mls_application" || receipt.status !== "rejected") return receipt;
+    const resentAs = (await store.transaction((tx) => tx.get(key2(operationId))))?.resentAs;
+    return resentAs ? endpoint.retry(resentAs, { reconcileOnly }) : receipt;
+  }
+  __name(answerOf, "answerOf");
   async function dispatch(operationId, reconcileOnly = false) {
     assertOpen();
     await initialization;
@@ -8216,12 +8074,17 @@ function createEndpoint(options) {
       await tx.put(key2(operationId), next);
       return { operation: next, acquired: true };
     });
+    if (operation.resentAs) return endpoint.retry(operation.resentAs, { reconcileOnly });
     if (terminal(operation.status) && operation.receipt) {
       if ((operation.receipt.resultReference || operation.resultEvicted) && operation.status === "succeeded") {
         const hydrated = await transport.getOperation(operationId, operation.installationId, controller.signal);
         if (!hydrated) throw new EndpointError("The private operation result is no longer available", { status: 410, code: "RESULT_EXPIRED", retryable: false, operationId });
         return hydrated;
       }
+      if (!reconcileOnly && operation.action === "mls_application" && operation.status === "rejected") {
+        await mlsDevGroups?.settleReceipt(operation, operation.receipt);
+        return answerOf(operationId, operation.receipt);
+      }
       return operation.receipt;
     }
     if (!acquired) {
@@ -8263,8 +8126,8 @@ function createEndpoint(options) {
           });
           return receipt2;
         }
-        await persistReceipt(operation, receipt2);
-        return receipt2;
+        await persistReceipt(operation, receipt2, reconcileOnly);
+        return answerOf(operationId, receipt2, reconcileOnly);
       }
       if (operation.attempted) {
         resolvingReceipt = true;
@@ -8272,7 +8135,7 @@ function createEndpoint(options) {
         resolvingReceipt = false;
         if (receipt2 && (receipt2.status !== "pending" || !operation.request && !sensitiveRequests.has(operationId))) {
           await persistReceipt(operation, receipt2);
-          return receipt2;
+          return answerOf(operationId, receipt2, reconcileOnly);
         }
       }
       if (clock() - Date.parse(operation.createdAt) > retryHorizonMs) {
@@ -8297,7 +8160,7 @@ function createEndpoint(options) {
         checkingDeliveryGuard = true;
         const guard = deliveryGuards.get(operation.guardId);
         if (!guard) throw new EndpointError("This publication requires its runtime to recheck the current audience", { code: "DELIVERY_GUARD_REQUIRED", retryable: true });
-        if (!await guard()) throw new EndpointError("Publication is withheld by the runtime policy", { code: "DELIVERY_GUARD_WITHHELD", retryable: true });
+        if (!await guard({ automaticResend: operation.automaticResend === true })) throw new EndpointError("Publication is withheld by the runtime policy", { code: "DELIVERY_GUARD_WITHHELD", retryable: true });
         assertOpen();
         checkingDeliveryGuard = false;
       }
@@ -8332,7 +8195,7 @@ function createEndpoint(options) {
       });
       const receipt = await transport.execute(request, controller.signal);
       await persistReceipt(operation, receipt);
-      return receipt;
+      return answerOf(operationId, receipt, reconcileOnly);
     } catch (error) {
       const failure = safeError(error);
       if (reconcileOnly && failure.retryable) {
@@ -8540,7 +8403,6 @@ function createEndpoint(options) {
           ...endpointIntentConversationId(normalized) ? { conversationId: endpointIntentConversationId(normalized) } : {},
           ...typeof routedBody.messageId === "string" ? { messageId: routedBody.messageId } : {},
           ...normalized.action === "session_control" && typeof routedBody.agentId === "string" ? { agentId: routedBody.agentId } : {},
-          ...endpointIntentOrdering(normalized) === "artifact" && typeof routedBody.artifactId === "string" ? { artifactId: routedBody.artifactId } : {},
           sensitive,
           status: "queued",
           attempts: 0,
@@ -8598,15 +8460,26 @@ function createEndpoint(options) {
       running.set(operationId, work);
       return work;
     },
-    async drain(drainOptions = {}) {
+    async resend(operationId) {
       assertOpen();
       await initialization;
+      let operation = await endpoint.getOperation(operationId);
+      while (operation?.resentAs) operation = await endpoint.getOperation(operation.resentAs);
+      if (!operation) throw new EndpointError("Unknown endpoint operation", { status: 404, code: "OPERATION_NOT_FOUND", retryable: false, operationId });
+      if (operation.status !== "rejected") return operation;
+      const resent = operation.action === "mls_application" && mlsDevGroups ? await mlsDevGroups.resendText(operation) : void 0;
+      if (!resent) throw new EndpointError("This message can no longer be sent again", { code: "OPERATION_NOT_RESENDABLE", retryable: false, operationId });
+      return resent;
+    },
+    async drain(drainOptions = {}) {
+      assertOpen();
+      await opened;
       await compactExpiredPayloads(store, clock());
       await sendDeferredOpeners(void 0, true).catch(() => void 0);
       let dispatched = 0;
       let hasDeferred = false;
       const blockedKeys = /* @__PURE__ */ new Set();
-      for (const ordering of ["independent", "signal", "message", "provider", "artifact", "conversation"]) {
+      for (const ordering of ["independent", "signal", "message", "provider", "conversation"]) {
         let after;
         do {
           const batch = await store.transaction(async (tx) => {
@@ -8649,7 +8522,8 @@ function createEndpoint(options) {
       await initialization;
       return store.transaction((tx) => tx.get(key2(operationId)));
     },
-    waitForOperation(operationId, waitOptions = {}) {
+    waitForOperation(waited, waitOptions = {}) {
+      let operationId = waited;
       return new Promise((resolve3, reject) => {
         let finished = false;
         let checking = false;
@@ -8675,7 +8549,11 @@ function createEndpoint(options) {
           if (finished || checking) return;
           checking = true;
           try {
-            const operation = await endpoint.getOperation(operationId);
+            let operation = await endpoint.getOperation(operationId);
+            while (operation?.resentAs) {
+              operationId = operation.resentAs;
+              operation = await endpoint.getOperation(operationId);
+            }
             if (!operation) return finish(void 0, new EndpointError("Unknown endpoint operation", { status: 404, code: "OPERATION_NOT_FOUND", retryable: false, operationId }));
             if (operation.status === "uncertain") return finish(void 0, new EndpointError("Delivery outcome requires reconciliation", { code: "OPERATION_UNCERTAIN", retryable: false, operationId }));
             if (terminal(operation.status) && operation.receipt) {
@@ -8782,9 +8660,9 @@ function createEndpoint(options) {
     },
     refreshQueries: /* @__PURE__ */ __name(() => queryObserver.invalidate(), "refreshQueries"),
     observeEvents: events.observe,
-    createMediaPipeline(bytes, mediaOptions) {
+    createMediaPipeline(bytes) {
       assertOpen();
-      const pipeline3 = createEndpointMediaPipeline({ endpoint, store, bytes, hash, ids, clock, background: mediaOptions?.background });
+      const pipeline3 = createEndpointMediaPipeline({ endpoint, store, bytes, hash, ids, clock });
       mediaPipelines2.add(pipeline3);
       return pipeline3;
     },
@@ -8938,6 +8816,57 @@ function createEndpoint(options) {
     startRecovery: recovery.start,
     configureRecoveryBaseline: recovery.configureBaseline,
     getRecoveryBaseline: recovery.getBaseline,
+    async startWorkAt(cutoverAt) {
+      assertOpen();
+      await initialization;
+      if (typeof cutoverAt !== "string" || !Number.isFinite(Date.parse(cutoverAt))) {
+        throw new EndpointError("Invalid work floor", { code: "INVALID_RECOVERY_BASELINE", retryable: false });
+      }
+      const sweep = await store.transaction(async (tx) => {
+        const floor = await tx.get(WORK_FLOOR_KEY);
+        const at = floor ? Date.parse(floor.cutoverAt) : -Infinity, next = Date.parse(cutoverAt);
+        if (at > next || at === next && floor?.swept) return false;
+        if (at < next) await tx.put(WORK_FLOOR_KEY, { cutoverAt });
+        return true;
+      });
+      if (!sweep) return;
+      for (let after; ; ) {
+        const page = await store.transaction(async (tx) => {
+          const floor = await tx.get(WORK_FLOOR_KEY);
+          const answered = await completions.answered(tx);
+          const entries2 = await tx.scan("inbound/", { ...after ? { after } : {}, limit: 100 });
+          for (const { key: recordKey, value } of entries2) {
+            if (value.state === "settled" || value.externalClaim || answered.has(value.event.id) || !beforeWorkFloor(floor, value.createdAt)) continue;
+            const next = { ...value, state: "settled", reason: "before_take_over", updatedAt: now() };
+            delete next.lease;
+            delete next.handoffGeneration;
+            delete next.handoffInstallationGeneration;
+            await removeInboundReady(tx, value);
+            await tx.put(recordKey, next);
+          }
+          return entries2;
+        });
+        if (page.length < 100) break;
+        after = page.at(-1).key;
+      }
+      await store.transaction(async (tx) => {
+        const floor = await tx.get(WORK_FLOOR_KEY);
+        if (floor && Date.parse(floor.cutoverAt) === Date.parse(cutoverAt)) await tx.put(WORK_FLOOR_KEY, { cutoverAt: floor.cutoverAt, swept: true });
+      });
+    },
+    async takeOverHome() {
+      assertOpen();
+      await opened;
+      const operationId = `${TAKE_OVER_OPERATION}${ids()}`;
+      const { cutoverAt } = await endpoint.executeResult({ action: "initialize_endpoint", body: {} }, { operationId }).catch(async (error) => {
+        await store.transaction(async (tx) => {
+          const current = await tx.get(key2(operationId));
+          if (current && !terminal(current.status)) await discardOperation(tx, current, TAKE_OVER_DISCARDED);
+        });
+        throw error;
+      });
+      await endpoint.startWorkAt(cutoverAt);
+    },
     refreshRecovery: recovery.refresh,
     planRecoveryMigration(baseline, conversationIds) {
       assertOpen();
@@ -9046,23 +8975,11 @@ function createEndpoint(options) {
         const batch = await store.transaction(async (tx) => {
           const entries2 = await tx.scan("operation/", { after, limit: 100 });
           for (const entry of entries2) {
-            if (!terminal(entry.value.status)) {
-              const status = entry.value.attempted ? "uncertain" : "rejected";
-              const next = { ...entry.value, status, updatedAt: now(), receipt: {
-                ...deferredReceipt(entry.value),
-                status,
-                updatedAt: now(),
-                error: { code: "OPERATION_DISCARDED", message: "Local delivery was cancelled", retryable: false }
-              } };
-              delete next.request;
-              delete next.preparedContent;
-              delete next.lease;
-              delete next.nextAttemptAt;
-              await tx.put(entry.key, next);
-              await settleMlsDevTextOperation(tx, next);
+            if (!terminal(entry.value.status)) await discardOperation(tx, entry.value, "Local delivery was cancelled");
+            else {
+              await removeOperationOutbox(tx, entry.value);
+              await settleOperationOrder(tx, entry.value);
             }
-            await removeOperationOutbox(tx, entry.value);
-            if (!entry.value.attempted || terminal(entry.value.status)) await settleOperationOrder(tx, entry.value);
           }
           return entries2;
         });
@@ -9088,7 +9005,7 @@ function createEndpoint(options) {
       listeners.clear();
       closing = (async () => {
         await Promise.allSettled([handoffs.close(), recovery.close(), syncConversation.close(), events.close(), ...[...consumers].map((consumer) => consumer.close()), ...[...mediaPipelines2].map((pipeline3) => pipeline3.close({ discard: true }))]);
-        await Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization]);
+        await Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization, roomHintWorker]);
         await endpoint.discardPending();
         await eraseEndpointPlaintext(store);
         await store.close();
@@ -9111,11 +9028,10 @@ function createEndpoint(options) {
       sensitiveRequests.clear();
       sensitiveFingerprints.clear();
       listeners.clear();
-      closing = Promise.allSettled([handoffs.close(), recovery.close(), syncConversation.close(), events.close(), ...[...consumers].map((consumer) => consumer.close()), ...[...mediaPipelines2].map((pipeline3) => pipeline3.close())]).then(() => Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization])).then(() => store.close());
+      closing = Promise.allSettled([handoffs.close(), recovery.close(), syncConversation.close(), events.close(), ...[...consumers].map((consumer) => consumer.close()), ...[...mediaPipelines2].map((pipeline3) => pipeline3.close())]).then(() => Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization, roomHintWorker])).then(() => store.close());
       return closing;
     }
   };
-  registerArtifactEndpoint(endpoint, { store, closed: /* @__PURE__ */ __name(() => closed, "closed"), assertCurrent: assertCurrentInstallation });
   void initialization.then(() => scheduleRetry(0)).catch(() => void 0);
   void initialization.then(() => sendDeferredOpeners()).catch(() => void 0);
   if (mlsDevGroups) void initialization.then(() => resumeHeldTexts()).catch(() => void 0);
@@ -9173,7 +9089,7 @@ async function acquireAgentEndpoint(input) {
   }
   const requestedMls = input.options.mlsDev;
   const mls = requestedMls ? await (async () => {
-    const crypto2 = await import("./mls-crypto-NZVMSUFU.js");
+    const crypto2 = await import("./mls-crypto-AW7TY744.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;
@@ -9358,6 +9274,17 @@ function isDiscoverAgentsResult(value) {
   return isRecord(value) && Array.isArray(value.agents) && value.agents.every(isAgentDirectoryEntry) && (value.nextCursor === null || typeof value.nextCursor === "string");
 }
 __name(isDiscoverAgentsResult, "isDiscoverAgentsResult");
+function homeClaim(input) {
+  const first = input.baseline ? void 0 : "initialize-endpoint";
+  if (isConnectorRelayInstallation(input.installationId)) return first;
+  if (input.home?.kind === "connector") return input.runner ? "refuse" : void 0;
+  const holder = input.home?.installationId;
+  if (holder === void 0 || holder === input.installationId) return first;
+  if (!input.runner) return void 0;
+  if (!input.baseline) return first;
+  return input.takeOver ? "take-over" : "refuse";
+}
+__name(homeClaim, "homeClaim");
 var CanonClient = class {
   static {
     __name(this, "CanonClient");
@@ -9389,12 +9316,29 @@ var CanonClient = class {
         options: this.endpointOptions
       });
       try {
-        if (context.endpointBootstrapEligible && this.endpointOptions.autoDrain !== false && !await lease.endpoint.getRecoveryBaseline()) {
-          const baseline = await lease.endpoint.executeResult(
-            { action: "initialize_endpoint", body: {} },
-            { operationId: "initialize-endpoint" }
-          );
-          await lease.endpoint.configureRecoveryBaseline(baseline);
+        if (context.endpointBootstrapEligible && this.endpointOptions.autoDrain !== false) {
+          const baseline = await lease.endpoint.getRecoveryBaseline();
+          const { installationId } = await lease.endpoint.ready();
+          const home = context.home;
+          const claim = homeClaim({
+            installationId,
+            home,
+            baseline: !!baseline,
+            runner: !!this.endpointOptions.claimHome,
+            takeOver: !!this.endpointOptions.takeOver
+          });
+          if (claim === "refuse") {
+            throw new EndpointError(agentHomeElsewhereMessage(context.displayName, home), { status: 409, code: AGENT_HOME_ELSEWHERE, retryable: false });
+          }
+          if (claim === "take-over") await lease.endpoint.takeOverHome();
+          else if (claim) {
+            await lease.endpoint.configureRecoveryBaseline(await lease.endpoint.executeResult(
+              { action: "initialize_endpoint", body: {} },
+              { operationId: claim }
+            ));
+          } else if (home?.kind === "runner" && home.installationId === installationId && home.since) {
+            await lease.endpoint.startWorkAt(new Date(home.since).toISOString());
+          }
         }
         return lease;
       } catch (error) {
@@ -10559,8 +10503,16 @@ async function ensureAgentProfile(options) {
     await verifyCanonRuntimeConnection(connection);
     return { status: "approved", apiKey: existing.apiKey, agentId: existing.agentId, agentName: existing.agentName };
   }
+  const requestedAgentId = input.requestedAgentId ?? (options.reconnect && !pending ? existing?.agentId : void 0);
+  if (options.reconnect && !pending && !requestedAgentId) {
+    throw new Error(`Canon profile "${profile}" has no saved agent to reconnect: give input.requestedAgentId, or register without reconnect`);
+  }
+  if (options.reconnect && !pending && existing && requestedAgentId !== existing.agentId) {
+    throw new Error("Saved Canon profile belongs to another agent identity");
+  }
   return resumeRegistration({
     ...options,
+    input: { ...input, ...requestedAgentId ? { requestedAgentId } : {} },
     store: {
       load: /* @__PURE__ */ __name(() => loadPendingRegistrations()[profile], "load"),
       save: /* @__PURE__ */ __name((session) => {
@@ -11813,14 +11765,15 @@ export {
   loadProfiles,
   isProfileLocked,
   acquireLock,
+  loadPendingRegistrations,
   clearPendingRegistration,
   ensureAgentProfile,
   initRTDBAuth,
   renderCanonHostInboundContent,
   createRuntimeStatePublisher,
   isPendingCanonOperation,
+  utf8ByteLength,
   splitTextWithinBytes,
-  readCliPackageVersion,
   runCli,
   BoundedFileReadError,
   readBoundedRegularFileHandle,