memeloop 0.1.2 → 0.2.0

package/dist/index.cjs

@@ -20607,7 +20607,7 @@ var init_builtinProfileSources = __esm({
         '  "name": "\u901A\u7528\u52A9\u624B",',
         '  "description": "\u53EF\u9760\u7684\u901A\u7528\u667A\u80FD\u4F53\uFF0C\u7528\u4E8E\u5BF9\u8BDD\u3001Wiki \u77E5\u8BC6\u5DE5\u4F5C\u3001\u76EE\u6807\u63A8\u8FDB\u548C\u65E5\u5E38\u8BA1\u7B97\u673A\u64CD\u4F5C\u3002",',
         '  "loopId": "agent-tool-loop",',
-        `  "systemPrompt": "You are MemeLoop, a reliable general-purpose agent for conversation, knowledge work, goal completion, and everyday computer tasks.\\n\\nOperating contract:\\n- Treat the user request as the active goal. For a task with three or more meaningful steps, use the planning tool actually listed in the tool instructions (for example manage-todo or todoWrite) to create a short plan, keep exactly one item in progress, and update it as work advances. Continue until the goal is achieved or genuinely blocked.\\n- Use tools for actions and for facts that must be read from the user's environment. Never claim that an action succeeded without a successful tool result. Never invent search results, file contents, counts, or completion evidence.\\n- Use the exact tool name and parameter schema shown in the tool list. When calling a tool, output ONLY one tool call in this exact XML format:\\n<tool_use name=\\"TOOL_NAME\\">{\\"param\\":\\"value\\"}</tool_use>\\n  The JSON must be valid. Never wrap the call in markdown or add text before or after it. After the tool result, reassess the goal and continue.\\n- If a tool fails, read the error and change the arguments or approach. Do not repeat an identical failed call more than once, and do not retry the same approach more than twice.\\n- For Wiki work, use an injected available workspace name or ID; do not guess one. Search before relying on stored knowledge. For wiki-search, exact-title filter syntax is [title[Exact Title]], tag syntax is [tag[Tag]], and semantic search uses searchType \\"vector\\" with query. A filter search uses searchType \\"filter\\" with filter. After a write, verify important content with a valid exact-title search. If verification fails, report that honestly.\\n- Save durable facts, decisions, plans, and user-requested memories to Wiki when useful. Do not store credentials or other sensitive data unless the user explicitly asks.\\n- For UI or computer actions, inspect the current state before acting, prefer reversible changes, verify the resulting state, and ask before destructive actions or consequential external communication.\\n- Do not ask for confirmation before an explicitly requested reversible action when the target is already known. Ask a concise question only when missing information materially changes the result. Otherwise make safe, explicit assumptions and proceed.\\n- In the final response, lead with the outcome, cite concrete verification, and state any remaining limitation briefly.",`,
+        `  "systemPrompt": "You are MemeLoop, a reliable general-purpose agent for conversation, knowledge work, goal completion, and everyday computer tasks.\\n\\nOperating contract:\\n- Treat the user request as the active goal. For a task with three or more meaningful steps, use an enabled planning tool listed in the injected tool instructions to create a short plan, keep exactly one item in progress, and update it as work advances. Continue until the goal is achieved or genuinely blocked.\\n- Use tools for actions and for facts that must be read from the user's environment. Never claim that an action succeeded without a successful tool result. Never invent search results, file contents, counts, or completion evidence.\\n- Use the exact tool name and parameter schema shown in the tool list. When calling a tool, output ONLY one tool call in this exact XML format:\\n<tool_use name=\\"TOOL_NAME\\">{\\"param\\":\\"value\\"}</tool_use>\\n  The JSON must be valid. Never wrap the call in markdown or add text before or after it. After the tool result, reassess the goal and continue.\\n- If a tool fails, read the error and change the arguments or approach. Do not repeat an identical failed call more than once, and do not retry the same approach more than twice.\\n- For Wiki work, use an injected available workspace name or ID; do not guess one. Search before relying on stored knowledge. When an enabled Wiki search tool is listed, use its exact injected name and schema. For filter-capable search, exact-title syntax is [title[Exact Title]] and tag syntax is [tag[Tag]]. If semantic or vector search is available, use the documented mode and arguments. After a write, verify important content with an exact-title search. If verification fails, report that honestly.\\n- Save durable facts, decisions, plans, and user-requested memories to Wiki when useful. Do not store credentials or other sensitive data unless the user explicitly asks.\\n- For UI or computer actions, inspect the current state before acting, prefer reversible changes, verify the resulting state, and ask before destructive actions or consequential external communication.\\n- Do not ask for confirmation before an explicitly requested reversible action when the target is already known. Ask a concise question only when missing information materially changes the result. Otherwise make safe, explicit assumptions and proceed.\\n- In the final response, lead with the outcome, cite concrete verification, and state any remaining limitation briefly.",`,
         '  "tools": [',
         '    "workspacesList",',
         '    "wikiSearch",',
@@ -20694,7 +20694,7 @@ var init_builtinProfileSources = __esm({
         "      {",
         '        "id": "builtin-system",',
         '        "role": "system",',
-        `        "text": "You are MemeLoop, a reliable general-purpose agent for conversation, knowledge work, goal completion, and everyday computer tasks.\\n\\nOperating contract:\\n- Treat the user request as the active goal. For a task with three or more meaningful steps, use the planning tool actually listed in the tool instructions (for example manage-todo or todoWrite) to create a short plan, keep exactly one item in progress, and update it as work advances. Continue until the goal is achieved or genuinely blocked.\\n- Use tools for actions and for facts that must be read from the user's environment. Never claim that an action succeeded without a successful tool result. Never invent search results, file contents, counts, or completion evidence.\\n- Use the exact tool name and parameter schema shown in the tool list. When calling a tool, output ONLY one tool call in this exact XML format:\\n<tool_use name=\\"TOOL_NAME\\">{\\"param\\":\\"value\\"}</tool_use>\\n  The JSON must be valid. Never wrap the call in markdown or add text before or after it. After the tool result, reassess the goal and continue.\\n- If a tool fails, read the error and change the arguments or approach. Do not repeat an identical failed call more than once, and do not retry the same approach more than twice.\\n- For Wiki work, use an injected available workspace name or ID; do not guess one. Search before relying on stored knowledge. For wiki-search, exact-title filter syntax is [title[Exact Title]], tag syntax is [tag[Tag]], and semantic search uses searchType \\"vector\\" with query. A filter search uses searchType \\"filter\\" with filter. After a write, verify important content with a valid exact-title search. If verification fails, report that honestly.\\n- Save durable facts, decisions, plans, and user-requested memories to Wiki when useful. Do not store credentials or other sensitive data unless the user explicitly asks.\\n- For UI or computer actions, inspect the current state before acting, prefer reversible changes, verify the resulting state, and ask before destructive actions or consequential external communication.\\n- Do not ask for confirmation before an explicitly requested reversible action when the target is already known. Ask a concise question only when missing information materially changes the result. Otherwise make safe, explicit assumptions and proceed.\\n- In the final response, lead with the outcome, cite concrete verification, and state any remaining limitation briefly."`,
+        `        "text": "You are MemeLoop, a reliable general-purpose agent for conversation, knowledge work, goal completion, and everyday computer tasks.\\n\\nOperating contract:\\n- Treat the user request as the active goal. For a task with three or more meaningful steps, use an enabled planning tool listed in the injected tool instructions to create a short plan, keep exactly one item in progress, and update it as work advances. Continue until the goal is achieved or genuinely blocked.\\n- Use tools for actions and for facts that must be read from the user's environment. Never claim that an action succeeded without a successful tool result. Never invent search results, file contents, counts, or completion evidence.\\n- Use the exact tool name and parameter schema shown in the tool list. When calling a tool, output ONLY one tool call in this exact XML format:\\n<tool_use name=\\"TOOL_NAME\\">{\\"param\\":\\"value\\"}</tool_use>\\n  The JSON must be valid. Never wrap the call in markdown or add text before or after it. After the tool result, reassess the goal and continue.\\n- If a tool fails, read the error and change the arguments or approach. Do not repeat an identical failed call more than once, and do not retry the same approach more than twice.\\n- For Wiki work, use an injected available workspace name or ID; do not guess one. Search before relying on stored knowledge. When an enabled Wiki search tool is listed, use its exact injected name and schema. For filter-capable search, exact-title syntax is [title[Exact Title]] and tag syntax is [tag[Tag]]. If semantic or vector search is available, use the documented mode and arguments. After a write, verify important content with an exact-title search. If verification fails, report that honestly.\\n- Save durable facts, decisions, plans, and user-requested memories to Wiki when useful. Do not store credentials or other sensitive data unless the user explicitly asks.\\n- For UI or computer actions, inspect the current state before acting, prefer reversible changes, verify the resulting state, and ask before destructive actions or consequential external communication.\\n- Do not ask for confirmation before an explicitly requested reversible action when the target is already known. Ask a concise question only when missing information materially changes the result. Otherwise make safe, explicit assumptions and proceed.\\n- In the final response, lead with the outcome, cite concrete verification, and state any remaining limitation briefly."`,
         "      }",
         "    ],",
         '    "plugins": [{ "toolId": "fullReplacement" }],',
@@ -20706,7 +20706,7 @@ var init_builtinProfileSources = __esm({
         '    "temperature": 0.5,',
         '    "maxTokens": 4096',
         "  },",
-        '  "version": "1.1.0"',
+        '  "version": "1.1.1"',
         "}",
         ""
       ].join("\n"),
@@ -21121,6 +21121,7 @@ function createMemeLoopRuntime(context) {
         lastMessageTimestamp: now,
         messageCount: context.runAgentToolLoop || !options.initialMessage ? 0 : 1,
         originNodeId: "local",
+        originClock: 1,
         definitionId: options.definitionId,
         isUserInitiated: true
       };
@@ -26462,11 +26463,13 @@ __export(src_exports, {
   DRIVER_MANIFEST_API_VERSION: () => DRIVER_MANIFEST_API_VERSION,
   DRIVER_MANIFEST_KIND: () => DRIVER_MANIFEST_KIND,
   DRIVER_REQUEST_API_VERSION: () => DRIVER_REQUEST_API_VERSION,
+  DeviceCloudConnectionCoordinator: () => DeviceCloudConnectionCoordinator,
   FLEET_ROLLOUT_API_VERSION: () => FLEET_ROLLOUT_API_VERSION,
   FLEET_ROLLOUT_KIND: () => FLEET_ROLLOUT_KIND,
   HookRegistry: () => HookRegistry,
   IMChannelManager: () => IMChannelManager,
   IM_SESSION_TOOL_IDS: () => IM_SESSION_TOOL_IDS,
+  JsonFrameError: () => JsonFrameError,
   LIBP2P_RPC_REQUEST_TYPE: () => LIBP2P_RPC_REQUEST_TYPE,
   LIBP2P_RPC_RESPONSE_TYPE: () => LIBP2P_RPC_RESPONSE_TYPE,
   LIBP2P_SYNC_REQUEST_TYPE: () => LIBP2P_SYNC_REQUEST_TYPE,
@@ -26484,6 +26487,7 @@ __export(src_exports, {
   MODEL_ENDPOINT_API_VERSION: () => MODEL_ENDPOINT_API_VERSION,
   MODEL_ENDPOINT_KIND: () => MODEL_ENDPOINT_KIND,
   MemoryDeviceNetworkService: () => MemoryDeviceNetworkService,
+  MemoryDeviceSyncStateStore: () => MemoryDeviceSyncStateStore,
   NETWORK_ATTACHMENT_API_VERSION: () => NETWORK_ATTACHMENT_API_VERSION,
   NETWORK_ATTACHMENT_KIND: () => NETWORK_ATTACHMENT_KIND,
   NETWORK_CLASS_API_VERSION: () => NETWORK_CLASS_API_VERSION,
@@ -26582,6 +26586,7 @@ __export(src_exports, {
   canDriverSatisfyClass: () => canDriverSatisfyClass,
   cancelPendingApprovals: () => cancelPendingApprovals,
   canonicalControlStoreValue: () => canonicalControlStoreValue,
+  canonicalDevicePairingInviteBytes: () => canonicalDevicePairingInviteBytes,
   canonicalDriverValue: () => canonicalDriverValue,
   canonicalWorkerBootstrapDescriptorBytes: () => canonicalWorkerBootstrapDescriptorBytes,
   canonicalWorkerProtocolRequestBytes: () => canonicalWorkerProtocolRequestBytes,
@@ -26591,6 +26596,7 @@ __export(src_exports, {
   clearHooks: () => clearHooks,
   clearPluginRegistrations: () => clearPluginRegistrations,
   compactMessages: () => compactMessages,
+  computeMissingVersionRanges: () => computeMissingVersionRanges,
   consumeWorkloadCapabilityGrant: () => consumeWorkloadCapabilityGrant,
   containsSecrets: () => containsSecrets,
   controlStoreApplyMatches: () => controlStoreApplyMatches,
@@ -26678,6 +26684,7 @@ __export(src_exports, {
   createInProcessLoopRuntimeDriver: () => createInProcessLoopRuntimeDriver,
   createInProcessToolExecutionDriver: () => createInProcessToolExecutionDriver,
   createInstanceDeltaFromDefinition: () => createInstanceDeltaFromDefinition,
+  createJsonFrameReader: () => createJsonFrameReader,
   createLoopRuntimeManagementConformanceSuite: () => createLoopRuntimeManagementConformanceSuite,
   createManagedArtifactDriverAdapter: () => createManagedArtifactDriverAdapter,
   createManagedCredentialBrokerAdapter: () => createManagedCredentialBrokerAdapter,
@@ -26759,6 +26766,8 @@ __export(src_exports, {
   detectMimeConfusion: () => detectMimeConfusion,
   digestNormalizedScript: () => digestNormalizedScript,
   encodeDevicePairingInvite: () => encodeDevicePairingInvite,
+  encodeJsonFrame: () => encodeJsonFrame,
+  encodeJsonFrames: () => encodeJsonFrames,
   enrollWorker: () => enrollWorker,
   evaluateApproval: () => evaluateApproval,
   evaluateToolAdmission: () => evaluateToolAdmission,
@@ -27163,48 +27172,85 @@ function decodeAttachmentBlobRpc(result) {
   };
 }
 
+// src/device-network/deviceSyncStateStore.ts
+var MemoryDeviceSyncStateStore = class {
+  versionVector;
+  constructor(initial = {}) {
+    this.versionVector = { ...initial };
+  }
+  async loadVersionVector() {
+    return { ...this.versionVector };
+  }
+  async saveVersionVector(versionVector) {
+    this.versionVector = { ...versionVector };
+  }
+};
+
 // src/sync/chatSyncEngine.ts
 var ChatSyncEngine = class {
   nodeId;
   storage;
   getPeers;
+  stateStore;
   versionVector = {};
+  loadStatePromise;
+  stateMutation = Promise.resolve();
   constructor(options) {
     this.nodeId = options.nodeId;
     this.storage = options.storage;
     this.getPeers = options.peers;
-    this.versionVector[this.nodeId] = 0;
+    this.stateStore = options.stateStore ?? new MemoryDeviceSyncStateStore();
   }
   /**
    * 在本节点新产生一条消息时调用，增加本节点的 lamportClock。
    */
   bumpLocalVersion() {
-    this.versionVector[this.nodeId] = (this.versionVector[this.nodeId] ?? 0) + 1;
+    let nextClock = 0;
+    const mutation = this.stateMutation.then(async () => {
+      await this.ensureStateLoaded();
+      nextClock = (this.versionVector[this.nodeId] ?? 0) + 1;
+      this.versionVector[this.nodeId] = nextClock;
+      await this.stateStore.saveVersionVector(this.versionVector);
+    });
+    this.stateMutation = mutation.catch(() => void 0);
+    return mutation.then(() => nextClock);
   }
   /**
    * 执行一次与所有 peer 的增量同步（metadata 级别），并尽力拉取缺失消息。
    */
   async syncOnce() {
+    await this.ensureStateLoaded();
+    await this.stateMutation;
+    await this.reconcileVersionVectorFromStorage();
     const peers = this.getPeers();
     if (peers.length === 0) return;
-    const localVersion = { ...this.versionVector };
     const pulledConversations = /* @__PURE__ */ new Set();
     for (const peer of peers) {
-      const { remoteVersion, missingForRemote } = await peer.exchangeVersionVector(localVersion);
-      const missingForLocal = await peer.pullMissingMetadata(this.versionVector);
-      for (const meta of missingForLocal) {
-        await this.storage.upsertConversationMetadata(meta);
-        pulledConversations.add(meta.conversationId);
-      }
+      const { remoteVersion } = await peer.exchangeVersionVector({ ...this.versionVector });
+      let cursor;
+      do {
+        const page = await peer.pullMissingMetadata(this.versionVector, cursor);
+        for (const meta of page.items) {
+          await this.storage.upsertConversationMetadata(meta);
+          pulledConversations.add(meta.conversationId);
+        }
+        cursor = page.nextCursor;
+      } while (cursor !== void 0);
       for (const [nodeId, clock] of Object.entries(remoteVersion)) {
         const current = this.versionVector[nodeId] ?? 0;
-        if (clock > current) {
-          this.versionVector[nodeId] = clock;
-        }
+        if (clock > current) this.versionVector[nodeId] = clock;
       }
-      if (missingForRemote.length > 0) {
-        this.bumpLocalVersion();
+      await this.stateStore.saveVersionVector(this.versionVector);
+    }
+    const pageSize = 100;
+    let offset = 0;
+    for (; ; ) {
+      const conversations = await this.storage.listConversations({ limit: pageSize, offset });
+      for (const conversation of conversations) {
+        pulledConversations.add(conversation.conversationId);
       }
+      if (conversations.length < pageSize) break;
+      offset += conversations.length;
     }
     for (const conversationId of pulledConversations) {
       await this.pullMessagesForConversationFromPeers(conversationId, peers);
@@ -27215,11 +27261,6 @@ var ChatSyncEngine = class {
    */
   async antiEntropyOnce() {
     await this.syncOnce();
-    const list = await this.storage.listConversations({ limit: 500 });
-    const peers = this.getPeers();
-    for (const meta of list) {
-      await this.pullMessagesForConversationFromPeers(meta.conversationId, peers);
-    }
   }
   async pullMessagesForConversationFromPeers(conversationId, peers) {
     const localMsgs = await this.storage.getMessages(conversationId, { mode: "full-content" });
@@ -27272,12 +27313,39 @@ var ChatSyncEngine = class {
       }
     }
   }
-  getVersionVector() {
+  async getVersionVector() {
+    await this.ensureStateLoaded();
+    await this.stateMutation;
     return { ...this.versionVector };
   }
   getStorage() {
     return this.storage;
   }
+  ensureStateLoaded() {
+    this.loadStatePromise ??= (async () => {
+      const stored = await this.stateStore.loadVersionVector();
+      this.versionVector = { ...stored, [this.nodeId]: stored[this.nodeId] ?? 0 };
+    })();
+    return this.loadStatePromise;
+  }
+  async reconcileVersionVectorFromStorage() {
+    const pageSize = 100;
+    let offset = 0;
+    let changed = false;
+    for (; ; ) {
+      const conversations = await this.storage.listConversations({ limit: pageSize, offset });
+      for (const conversation of conversations) {
+        const current = this.versionVector[conversation.originNodeId] ?? 0;
+        if (conversation.originClock > current) {
+          this.versionVector[conversation.originNodeId] = conversation.originClock;
+          changed = true;
+        }
+      }
+      if (conversations.length < pageSize) break;
+      offset += conversations.length;
+    }
+    if (changed) await this.stateStore.saveVersionVector(this.versionVector);
+  }
 };
 
 // src/sync/peerNodeAdapter.ts
@@ -27291,8 +27359,8 @@ var PeerNodeSyncAdapter = class {
   exchangeVersionVector(localVersion) {
     return this.transport.exchangeVersionVector(this.nodeId, localVersion);
   }
-  pullMissingMetadata(sinceVersion) {
-    return this.transport.pullMissingMetadata(this.nodeId, sinceVersion);
+  pullMissingMetadata(sinceVersion, cursor) {
+    return this.transport.pullMissingMetadata(this.nodeId, sinceVersion, cursor);
   }
   pullMissingMessages(conversationId, knownMessageIds) {
     const function_ = this.transport.pullMissingMessages?.bind(this.transport);
@@ -27385,6 +27453,7 @@ async function runStorageConformance(storage, options = {}) {
       lastMessageTimestamp: Date.now(),
       messageCount: 0,
       originNodeId: "local",
+      originClock: 1,
       definitionId: "conformance-agent",
       isUserInitiated: true
     });
@@ -28696,6 +28765,7 @@ async function upsertConversationForRemoteTurn(input) {
     lastMessageTimestamp: now,
     messageCount: 0,
     originNodeId: input.localNodeId ?? "remote",
+    originClock: 1,
     definitionId: input.definitionId,
     isUserInitiated: true
   });
@@ -28747,82 +28817,456 @@ function isChatMessage(value) {
 function isConversationMetaLike(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
   const record2 = value;
-  return typeof record2.conversationId === "string" && typeof record2.title === "string" && typeof record2.lastMessageTimestamp === "number" && typeof record2.messageCount === "number" && typeof record2.originNodeId === "string" && typeof record2.definitionId === "string" && typeof record2.isUserInitiated === "boolean";
+  return typeof record2.conversationId === "string" && typeof record2.title === "string" && typeof record2.lastMessageTimestamp === "number" && typeof record2.messageCount === "number" && typeof record2.originNodeId === "string" && typeof record2.originClock === "number" && typeof record2.definitionId === "string" && typeof record2.isUserInitiated === "boolean";
 }
 
+// src/device-network/deviceCloudConnectionCoordinator.ts
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 6e4;
+var DEFAULT_INITIAL_BACKOFF_MS = 1e3;
+var DEFAULT_MAX_BACKOFF_MS = 6e4;
+var DEFAULT_JITTER_RATIO = 0.2;
+function emptyComponents() {
+  return {
+    authorizer: "not-run",
+    registration: "not-run",
+    relay: "not-run",
+    heartbeat: "not-run",
+    directory: "not-run"
+  };
+}
+function assertNonNegativeFinite(value, name) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(`${name} must be a finite non-negative number`);
+  }
+}
+var DeviceCloudConnectionCoordinator = class {
+  constructor(options) {
+    this.options = options;
+    this.configuration = options.configuration;
+    this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+    this.initialBackoffMs = options.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF_MS;
+    this.maxBackoffMs = options.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+    this.jitterRatio = options.jitterRatio ?? DEFAULT_JITTER_RATIO;
+    this.now = options.now ?? Date.now;
+    this.random = options.random ?? Math.random;
+    assertNonNegativeFinite(this.heartbeatIntervalMs, "heartbeatIntervalMs");
+    assertNonNegativeFinite(this.initialBackoffMs, "initialBackoffMs");
+    assertNonNegativeFinite(this.maxBackoffMs, "maxBackoffMs");
+    assertNonNegativeFinite(this.jitterRatio, "jitterRatio");
+    if (this.jitterRatio > 1) throw new TypeError("jitterRatio must not exceed 1");
+    this.resetSnapshot();
+  }
+  configuration;
+  generation = 0;
+  controller = new AbortController();
+  timer;
+  inFlight;
+  started = false;
+  consecutiveFailures = 0;
+  snapshotValue = {
+    status: "not-configured",
+    generation: 0,
+    components: emptyComponents()
+  };
+  heartbeatIntervalMs;
+  initialBackoffMs;
+  maxBackoffMs;
+  jitterRatio;
+  now;
+  random;
+  get snapshot() {
+    return {
+      ...this.snapshotValue,
+      components: { ...this.snapshotValue.components }
+    };
+  }
+  async start() {
+    if (this.started) return this.runNow();
+    this.started = true;
+    await this.runNow();
+  }
+  async stop() {
+    this.started = false;
+    this.clearTimer();
+    this.controller.abort(new Error("device cloud coordinator stopped"));
+    await this.inFlight?.catch(() => void 0);
+  }
+  async setConfiguration(configuration) {
+    this.configuration = configuration;
+    this.generation += 1;
+    this.consecutiveFailures = 0;
+    this.clearTimer();
+    this.controller.abort(new Error("device cloud configuration changed"));
+    this.controller = new AbortController();
+    this.inFlight = void 0;
+    this.resetSnapshot();
+    if (this.started && this.options.adapter.isConfigured(configuration)) await this.runNow();
+  }
+  runNow() {
+    if (this.inFlight) return this.inFlight;
+    if (!this.options.adapter.isConfigured(this.configuration)) {
+      this.resetSnapshot();
+      return Promise.resolve();
+    }
+    const generation = this.generation;
+    const configuration = this.configuration;
+    const signal = this.controller.signal;
+    const run = this.maintain(configuration, generation, signal);
+    const tracked = run.finally(() => {
+      if (this.inFlight === tracked) this.inFlight = void 0;
+    });
+    this.inFlight = tracked;
+    return tracked;
+  }
+  async maintain(configuration, generation, signal) {
+    if (!this.isCurrent(generation, signal)) return;
+    await this.updateSnapshot(generation, {
+      status: "connecting",
+      lastError: void 0,
+      nextRetryAt: void 0
+    });
+    try {
+      if (this.snapshotValue.components.authorizer !== "ready") {
+        await this.runStep("authorizer", generation, signal, () => this.options.adapter.ensureAuthorizer(configuration, signal));
+      }
+      if (this.snapshotValue.components.registration !== "ready") {
+        await this.runStep("registration", generation, signal, () => this.options.adapter.registerDevice(configuration, signal));
+      }
+      let relayError;
+      try {
+        await this.runStep("relay", generation, signal, () => this.options.adapter.ensureRelay(configuration, signal));
+      } catch (error2) {
+        relayError = error2;
+        this.options.logWarning?.("Cloud relay maintenance failed", error2);
+      }
+      await this.runStep("heartbeat", generation, signal, () => this.options.adapter.heartbeat(configuration, signal));
+      let directoryError;
+      try {
+        await this.runStep("directory", generation, signal, () => this.options.adapter.syncDirectory(configuration, signal));
+      } catch (error2) {
+        directoryError = error2;
+        this.options.logWarning?.("Cloud directory synchronization failed", error2);
+      }
+      if (!this.isCurrent(generation, signal)) return;
+      this.consecutiveFailures = 0;
+      const relayRequired = this.options.adapter.relayRequiredForOnline(configuration);
+      await this.updateSnapshot(generation, {
+        status: directoryError || relayRequired && relayError ? "degraded" : "online",
+        lastError: directoryError ?? relayError,
+        nextRetryAt: this.now() + this.heartbeatIntervalMs
+      });
+      this.schedule(this.heartbeatIntervalMs, generation);
+    } catch (error2) {
+      if (!this.isCurrent(generation, signal)) return;
+      this.consecutiveFailures += 1;
+      if (this.snapshotValue.components.heartbeat === "failed") {
+        this.snapshotValue.components.registration = "not-run";
+      }
+      const status = this.options.adapter.classifyError?.(error2) ?? "offline";
+      const delay = this.backoffDelay();
+      await this.updateSnapshot(generation, {
+        status,
+        lastError: error2,
+        nextRetryAt: this.now() + delay
+      });
+      this.schedule(delay, generation);
+      throw error2;
+    }
+  }
+  async runStep(component, generation, signal, operation) {
+    if (!this.isCurrent(generation, signal)) return;
+    await this.setComponent(component, "pending", generation);
+    try {
+      const result = await operation();
+      if (!this.isCurrent(generation, signal)) return;
+      await result?.commit?.();
+      if (!this.isCurrent(generation, signal)) return;
+      await this.setComponent(component, "ready", generation);
+    } catch (error2) {
+      if (this.isCurrent(generation, signal)) await this.setComponent(component, "failed", generation);
+      throw error2;
+    }
+  }
+  backoffDelay() {
+    const exponential = Math.min(
+      this.maxBackoffMs,
+      this.initialBackoffMs * 2 ** Math.max(0, this.consecutiveFailures - 1)
+    );
+    const jitter = exponential * this.jitterRatio * (this.random() * 2 - 1);
+    return Math.max(0, Math.round(exponential + jitter));
+  }
+  schedule(delayMs, generation) {
+    if (!this.started || generation !== this.generation) return;
+    this.clearTimer();
+    this.timer = setTimeout(() => {
+      if (generation !== this.generation) return;
+      void this.runNow().catch((error2) => {
+        this.options.logWarning?.("Cloud maintenance failed", error2);
+      });
+    }, delayMs);
+  }
+  clearTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+  isCurrent(generation, signal) {
+    return generation === this.generation && !signal.aborted;
+  }
+  async setComponent(component, status, generation) {
+    if (generation !== this.generation) return;
+    this.snapshotValue = {
+      ...this.snapshotValue,
+      components: { ...this.snapshotValue.components, [component]: status }
+    };
+    await this.emit();
+  }
+  async updateSnapshot(generation, update) {
+    if (generation !== this.generation) return;
+    this.snapshotValue = { ...this.snapshotValue, ...update };
+    await this.emit();
+  }
+  resetSnapshot() {
+    this.snapshotValue = {
+      status: this.options.adapter.isConfigured(this.configuration) ? "offline" : "not-configured",
+      generation: this.generation,
+      components: emptyComponents()
+    };
+    void this.emit();
+  }
+  async emit() {
+    await this.options.onStatus?.(this.snapshot);
+  }
+};
+
 // src/device-network/deviceOrchestrationTransport.ts
 init_errors();
-var DEVICE_ORCHESTRATION_PROTOCOL = "/memeloop/orchestration/1.0.0";
-var DEFAULT_MAX_FRAME_BYTES = 1024 * 1024;
-function orchestrationTransportError(code, message) {
-  return new OrchestrationError({
-    code,
-    message,
-    retryable: code === "UNAVAILABLE"
-  });
+
+// src/device-network/jsonFrame.ts
+var JsonFrameError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "JsonFrameError";
+    this.code = code;
+  }
+};
+var HEADER_BYTES = 4;
+var MAX_UINT32 = 4294967295;
+function assertPositiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError(`${name} must be a positive safe integer`);
+  }
 }
-function assertFrameLimit(limit) {
-  if (!Number.isSafeInteger(limit) || limit < 256) {
-    throw new TypeError("maxFrameBytes must be a safe integer of at least 256");
+function validateMaxPayloadBytes(maxPayloadBytes) {
+  assertPositiveInteger(maxPayloadBytes, "maxPayloadBytes");
+  if (maxPayloadBytes > MAX_UINT32) {
+    throw new TypeError("maxPayloadBytes must fit in an unsigned 32-bit frame length");
   }
 }
-async function* encodeLines(values, maxFrameBytes) {
-  const encoder3 = new TextEncoder();
+function encodeJsonFrame(value, maxPayloadBytes = MAX_UINT32) {
+  validateMaxPayloadBytes(maxPayloadBytes);
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch (error2) {
+    throw new JsonFrameError("INVALID_JSON", "JSON frame value cannot be serialized", {
+      cause: error2
+    });
+  }
+  if (serialized === void 0) {
+    throw new JsonFrameError("INVALID_JSON", "JSON frame value cannot be serialized");
+  }
+  const payload = new TextEncoder().encode(serialized);
+  if (payload.byteLength > maxPayloadBytes) {
+    throw new JsonFrameError(
+      "FRAME_TOO_LARGE",
+      `JSON frame payload exceeds ${maxPayloadBytes} bytes`
+    );
+  }
+  const frame = new Uint8Array(HEADER_BYTES + payload.byteLength);
+  new DataView(frame.buffer, frame.byteOffset, HEADER_BYTES).setUint32(0, payload.byteLength, false);
+  frame.set(payload, HEADER_BYTES);
+  return frame;
+}
+async function* encodeJsonFrames(values, maxPayloadBytes = MAX_UINT32) {
   for await (const value of values) {
-    const frame = encoder3.encode(`${JSON.stringify(value)}
-`);
-    if (frame.byteLength > maxFrameBytes) {
-      throw orchestrationTransportError(
-        "EXHAUSTED",
-        `device orchestration frame exceeds ${maxFrameBytes} bytes`
-      );
-    }
-    yield frame;
+    yield encodeJsonFrame(value, maxPayloadBytes);
   }
 }
-async function* decodeLines(source, maxFrameBytes) {
-  const decoder = new TextDecoder();
-  let buffered = "";
-  for await (const chunk of source) {
-    buffered += decoder.decode(chunk, { stream: true });
-    for (; ; ) {
-      const newline = buffered.indexOf("\n");
-      if (newline < 0) break;
-      const line = buffered.slice(0, newline);
-      buffered = buffered.slice(newline + 1);
-      if (!line) continue;
-      if (new TextEncoder().encode(line).byteLength > maxFrameBytes) {
-        throw orchestrationTransportError(
-          "EXHAUSTED",
-          `device orchestration frame exceeds ${maxFrameBytes} bytes`
+function concatBytes(left, right) {
+  if (left.byteLength === 0) return right.slice();
+  if (right.byteLength === 0) return left;
+  const combined = new Uint8Array(left.byteLength + right.byteLength);
+  combined.set(left);
+  combined.set(right, left.byteLength);
+  return combined;
+}
+function abortedError(signal) {
+  return new JsonFrameError("ABORTED", "JSON frame reading was aborted", {
+    cause: signal?.reason
+  });
+}
+async function readNextChunk(iterator, idleDeadline, totalDeadline, signal) {
+  if (signal?.aborted) throw abortedError(signal);
+  const now = Date.now();
+  const deadline = totalDeadline === void 0 ? idleDeadline : Math.min(idleDeadline, totalDeadline);
+  if (deadline <= now) {
+    throw new JsonFrameError(
+      totalDeadline !== void 0 && totalDeadline <= idleDeadline ? "TOTAL_TIMEOUT" : "IDLE_TIMEOUT",
+      totalDeadline !== void 0 && totalDeadline <= idleDeadline ? "JSON frame total timeout expired" : "JSON frame idle timeout expired"
+    );
+  }
+  return new Promise((resolve, reject2) => {
+    let settled = false;
+    const finish = (callback) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      callback();
+    };
+    const onAbort = () => {
+      finish(() => {
+        reject2(abortedError(signal));
+      });
+    };
+    const timer = setTimeout(() => {
+      const currentTime = Date.now();
+      const totalExpired = totalDeadline !== void 0 && currentTime >= totalDeadline;
+      finish(() => {
+        reject2(
+          new JsonFrameError(
+            totalExpired ? "TOTAL_TIMEOUT" : "IDLE_TIMEOUT",
+            totalExpired ? "JSON frame total timeout expired" : "JSON frame idle timeout expired"
+          )
         );
+      });
+    }, Math.max(1, deadline - now));
+    signal?.addEventListener("abort", onAbort, { once: true });
+    void iterator.next().then(
+      (result) => {
+        finish(() => {
+          resolve(result);
+        });
+      },
+      (error2) => {
+        finish(() => {
+          reject2(
+            error2 instanceof Error ? error2 : new Error("JSON frame source failed", {
+              cause: error2
+            })
+          );
+        });
       }
-      try {
-        yield JSON.parse(line);
-      } catch {
-        throw orchestrationTransportError(
-          "INVALID",
-          "device orchestration stream contains invalid JSON"
+    );
+  });
+}
+function createJsonFrameReader(source, options) {
+  validateMaxPayloadBytes(options.maxPayloadBytes);
+  assertPositiveInteger(options.idleTimeoutMs, "idleTimeoutMs");
+  assertPositiveInteger(options.totalTimeoutMs, "totalTimeoutMs");
+  return (async function* readFrames() {
+    const iterator = source[Symbol.asyncIterator]();
+    let buffered = new Uint8Array(0);
+    let expectedPayloadBytes;
+    let idleDeadline = Date.now() + options.idleTimeoutMs;
+    let totalDeadline;
+    let abortCalled = false;
+    const abortOnce = async (error2) => {
+      if (abortCalled) return;
+      abortCalled = true;
+      await Promise.resolve(options.abort?.(error2)).catch(() => void 0);
+    };
+    try {
+      for (; ; ) {
+        if (expectedPayloadBytes === void 0 && buffered.byteLength >= HEADER_BYTES) {
+          expectedPayloadBytes = new DataView(
+            buffered.buffer,
+            buffered.byteOffset,
+            HEADER_BYTES
+          ).getUint32(0, false);
+          buffered = buffered.slice(HEADER_BYTES);
+          totalDeadline ??= Date.now() + options.totalTimeoutMs;
+          if (expectedPayloadBytes > options.maxPayloadBytes) {
+            throw new JsonFrameError(
+              "FRAME_TOO_LARGE",
+              `JSON frame payload exceeds ${options.maxPayloadBytes} bytes`
+            );
+          }
+        }
+        if (expectedPayloadBytes !== void 0 && buffered.byteLength >= expectedPayloadBytes) {
+          const payload = buffered.slice(0, expectedPayloadBytes);
+          buffered = buffered.slice(expectedPayloadBytes);
+          expectedPayloadBytes = void 0;
+          totalDeadline = buffered.byteLength > 0 ? Date.now() + options.totalTimeoutMs : void 0;
+          let text;
+          try {
+            text = new TextDecoder("utf-8", { fatal: true }).decode(payload);
+          } catch (error2) {
+            throw new JsonFrameError("INVALID_UTF8", "JSON frame payload is not valid UTF-8", {
+              cause: error2
+            });
+          }
+          let value;
+          try {
+            value = JSON.parse(text);
+          } catch (error2) {
+            throw new JsonFrameError("INVALID_JSON", "JSON frame payload is not valid JSON", {
+              cause: error2
+            });
+          }
+          yield value;
+          idleDeadline = Date.now() + options.idleTimeoutMs;
+          continue;
+        }
+        const result = await readNextChunk(
+          iterator,
+          idleDeadline,
+          totalDeadline,
+          options.signal
         );
+        if (result.done) {
+          if (buffered.byteLength > 0 || expectedPayloadBytes !== void 0) {
+            throw new JsonFrameError("TRUNCATED_FRAME", "JSON frame stream ended mid-frame");
+          }
+          return;
+        }
+        if (!(result.value instanceof Uint8Array)) {
+          throw new TypeError("JSON frame source must yield Uint8Array chunks");
+        }
+        if (result.value.byteLength === 0) continue;
+        const now = Date.now();
+        idleDeadline = now + options.idleTimeoutMs;
+        totalDeadline ??= now + options.totalTimeoutMs;
+        buffered = concatBytes(buffered, result.value);
       }
+    } catch (error2) {
+      const frameError = error2 instanceof JsonFrameError ? error2 : new JsonFrameError("ABORTED", "JSON frame source failed", { cause: error2 });
+      await abortOnce(frameError);
+      throw frameError;
+    } finally {
+      void iterator.return?.().catch(() => void 0);
     }
-    if (new TextEncoder().encode(buffered).byteLength > maxFrameBytes) {
-      throw orchestrationTransportError(
-        "EXHAUSTED",
-        `device orchestration frame exceeds ${maxFrameBytes} bytes`
-      );
-    }
-  }
-  buffered += decoder.decode();
-  if (buffered.trim()) {
-    try {
-      yield JSON.parse(buffered);
-    } catch {
-      throw orchestrationTransportError(
-        "INVALID",
-        "device orchestration stream contains invalid trailing JSON"
-      );
-    }
+  })();
+}
+
+// src/device-network/deviceOrchestrationTransport.ts
+var DEVICE_ORCHESTRATION_PROTOCOL = "/memeloop/orchestration/2.0.0";
+var DEFAULT_MAX_FRAME_BYTES = 1024 * 1024;
+var REQUEST_IDLE_TIMEOUT_MS = 1e4;
+var REQUEST_TOTAL_TIMEOUT_MS = 3e4;
+var WATCH_IDLE_TIMEOUT_MS = 9e4;
+var WATCH_BOOKMARK_INTERVAL_MS = 3e4;
+function orchestrationTransportError(code, message) {
+  return new OrchestrationError({
+    code,
+    message,
+    retryable: code === "UNAVAILABLE"
+  });
+}
+function assertFrameLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit < 256) {
+    throw new TypeError("maxFrameBytes must be a safe integer of at least 256");
   }
 }
 function throwIfAborted(signal) {
@@ -28843,11 +29287,41 @@ async function openAuthenticatedStream(options) {
 }
 async function writeRequest(stream, request, grant, maxFrameBytes) {
   const envelope = {
-    type: "memeloop-device-orchestration-request-v1",
+    type: "memeloop-device-orchestration-request-v2",
     request,
     ...grant ? { grant } : {}
   };
-  await stream.sink(encodeLines([envelope], maxFrameBytes));
+  await stream.sink(encodeJsonFrames([envelope], maxFrameBytes));
+}
+function abortStreamOnce(stream) {
+  let aborted = false;
+  return async (error2) => {
+    if (aborted) return;
+    aborted = true;
+    await stream.abort(error2);
+  };
+}
+function frameReader(stream, maxFrameBytes, idleTimeoutMs, signal, abort) {
+  return createJsonFrameReader(stream.source, {
+    maxPayloadBytes: maxFrameBytes,
+    idleTimeoutMs,
+    totalTimeoutMs: REQUEST_TOTAL_TIMEOUT_MS,
+    signal,
+    abort
+  });
+}
+function mapFrameError(error2) {
+  if (!(error2 instanceof JsonFrameError)) throw error2;
+  if (error2.code === "ABORTED") {
+    throw orchestrationTransportError("CANCELLED", error2.message);
+  }
+  if (error2.code === "FRAME_TOO_LARGE") {
+    throw orchestrationTransportError("EXHAUSTED", error2.message);
+  }
+  if (error2.code === "IDLE_TIMEOUT" || error2.code === "TOTAL_TIMEOUT") {
+    throw orchestrationTransportError("UNAVAILABLE", error2.message);
+  }
+  throw orchestrationTransportError("INVALID", error2.message);
 }
 function createDeviceOrchestrationTransport(options) {
   const maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES;
@@ -28856,8 +29330,9 @@ function createDeviceOrchestrationTransport(options) {
     async request(request, transportOptions = {}) {
       throwIfAborted(transportOptions.signal);
       const { stream, grant } = await openAuthenticatedStream(options);
+      const abort = abortStreamOnce(stream);
       const closeOnAbort = () => {
-        void stream.close();
+        void abort(orchestrationTransportError("CANCELLED", "device orchestration request was cancelled"));
       };
       transportOptions.signal?.addEventListener("abort", closeOnAbort, {
         once: true
@@ -28865,7 +29340,13 @@ function createDeviceOrchestrationTransport(options) {
       try {
         await writeRequest(stream, request, grant, maxFrameBytes);
         let response;
-        for await (const value of decodeLines(stream.source, maxFrameBytes)) {
+        for await (const value of frameReader(
+          stream,
+          maxFrameBytes,
+          REQUEST_IDLE_TIMEOUT_MS,
+          transportOptions.signal,
+          abort
+        )) {
           if (response) {
             throw orchestrationTransportError(
               "INVALID",
@@ -28882,6 +29363,9 @@ function createDeviceOrchestrationTransport(options) {
           );
         }
         return response;
+      } catch (error2) {
+        if (error2 instanceof JsonFrameError) await abort(error2);
+        mapFrameError(error2);
       } finally {
         transportOptions.signal?.removeEventListener("abort", closeOnAbort);
         await stream.close().catch(() => void 0);
@@ -28890,19 +29374,29 @@ function createDeviceOrchestrationTransport(options) {
     async *watch(request, transportOptions = {}) {
       throwIfAborted(transportOptions.signal);
       const { stream, grant } = await openAuthenticatedStream(options);
+      const abort = abortStreamOnce(stream);
       const closeOnAbort = () => {
-        void stream.close();
+        void abort(orchestrationTransportError("CANCELLED", "device orchestration watch was cancelled"));
       };
       transportOptions.signal?.addEventListener("abort", closeOnAbort, {
         once: true
       });
       try {
         await writeRequest(stream, request, grant, maxFrameBytes);
-        for await (const value of decodeLines(stream.source, maxFrameBytes)) {
+        for await (const value of frameReader(
+          stream,
+          maxFrameBytes,
+          WATCH_IDLE_TIMEOUT_MS,
+          transportOptions.signal,
+          abort
+        )) {
           throwIfAborted(transportOptions.signal);
           yield value;
         }
         throwIfAborted(transportOptions.signal);
+      } catch (error2) {
+        if (error2 instanceof JsonFrameError) await abort(error2);
+        mapFrameError(error2);
       } finally {
         transportOptions.signal?.removeEventListener("abort", closeOnAbort);
         await stream.close().catch(() => void 0);
@@ -28911,15 +29405,22 @@ function createDeviceOrchestrationTransport(options) {
   };
 }
 async function readSingleRequest(stream, maxFrameBytes) {
+  const abort = abortStreamOnce(stream);
   let envelope;
-  for await (const value of decodeLines(stream.source, maxFrameBytes)) {
+  for await (const value of frameReader(
+    stream,
+    maxFrameBytes,
+    REQUEST_IDLE_TIMEOUT_MS,
+    void 0,
+    abort
+  )) {
     if (envelope) {
       throw orchestrationTransportError(
         "INVALID",
         "device orchestration stream accepts exactly one request"
       );
     }
-    if (value === null || typeof value !== "object" || Array.isArray(value) || value.type !== "memeloop-device-orchestration-request-v1" || value.request === null || typeof value.request !== "object") {
+    if (value === null || typeof value !== "object" || Array.isArray(value) || value.type !== "memeloop-device-orchestration-request-v2" || value.request === null || typeof value.request !== "object") {
       throw orchestrationTransportError(
         "INVALID",
         "device orchestration request envelope is invalid"
@@ -28932,6 +29433,41 @@ async function readSingleRequest(stream, maxFrameBytes) {
   }
   return envelope;
 }
+async function* withWatchBookmarks(source, request, signal) {
+  const iterator = source[Symbol.asyncIterator]();
+  let pending2 = iterator.next();
+  try {
+    for (; ; ) {
+      const result = await Promise.race([
+        pending2.then((value) => ({ kind: "value", value })),
+        new Promise((resolve) => {
+          const timer = setTimeout(() => {
+            resolve({ kind: "bookmark" });
+          }, WATCH_BOOKMARK_INTERVAL_MS);
+          signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            resolve({ kind: "bookmark" });
+          }, { once: true });
+        })
+      ]);
+      if (signal.aborted) return;
+      if (result.kind === "bookmark") {
+        yield {
+          protocol: request.protocol,
+          requestId: request.requestId,
+          ok: true,
+          result: { type: "BOOKMARK", resourceVersion: String(Date.now()) }
+        };
+        continue;
+      }
+      if (result.value.done) return;
+      yield result.value.value;
+      pending2 = iterator.next();
+    }
+  } finally {
+    void iterator.return?.();
+  }
+}
 function createDeviceOrchestrationStreamHandler(options) {
   const maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES;
   assertFrameLimit(maxFrameBytes);
@@ -28946,10 +29482,13 @@ function createDeviceOrchestrationStreamHandler(options) {
       const handler = await options.resolveHandler(remotePeerId);
       if (request.operation === "watch") {
         await stream.sink(
-          encodeLines(handler.watch(request, { signal: abort.signal }), maxFrameBytes)
+          encodeJsonFrames(
+            withWatchBookmarks(handler.watch(request, { signal: abort.signal }), request, abort.signal),
+            maxFrameBytes
+          )
         );
       } else {
-        await stream.sink(encodeLines([await handler.request(request)], maxFrameBytes));
+        await stream.sink(encodeJsonFrames([await handler.request(request)], maxFrameBytes));
       }
     } finally {
       abort.abort();
@@ -28959,8 +29498,8 @@ function createDeviceOrchestrationStreamHandler(options) {
 }
 
 // src/device-network/libp2pSyncProtocol.ts
-var LIBP2P_SYNC_REQUEST_TYPE = "memeloop-sync-request-v1";
-var LIBP2P_SYNC_RESPONSE_TYPE = "memeloop-sync-response-v1";
+var LIBP2P_SYNC_REQUEST_TYPE = "memeloop-sync-request-v2";
+var LIBP2P_SYNC_RESPONSE_TYPE = "memeloop-sync-response-v2";
 var syncMethods = /* @__PURE__ */ new Set([
   "exchangeVersionVector",
   "pullMissingMetadata",
@@ -29020,8 +29559,11 @@ var Libp2pDeviceSyncTransport = class {
   exchangeVersionVector(peerId, localVersion) {
     return this.request(peerId, "exchangeVersionVector", { localVersion });
   }
-  pullMissingMetadata(peerId, sinceVersion) {
-    return this.request(peerId, "pullMissingMetadata", { sinceVersion });
+  pullMissingMetadata(peerId, sinceVersion, cursor) {
+    return this.request(peerId, "pullMissingMetadata", {
+      sinceVersion,
+      cursor
+    });
   }
   pullMissingMessages(peerId, conversationId, knownMessageIds) {
     return this.request(peerId, "pullMissingMessages", { conversationId, knownMessageIds });
@@ -29032,7 +29574,7 @@ var Libp2pDeviceSyncTransport = class {
   }
   async request(peerId, method, parameters) {
     const grant = await this.grantProvider?.(peerId);
-    const stream = await this.deviceNetwork.openStream(peerId, "/memeloop/sync/1.0.0", grant);
+    const stream = await this.deviceNetwork.openStream(peerId, "/memeloop/sync/2.0.0", grant);
     const request = {
       type: LIBP2P_SYNC_REQUEST_TYPE,
       id: crypto.randomUUID(),
@@ -29040,31 +29582,34 @@ var Libp2pDeviceSyncTransport = class {
       params: parameters,
       grant
     };
-    await writeJsonToStream(stream, request);
-    const response = await readJsonFromStream(stream);
-    await stream.close();
-    if (!isLibp2pSyncResponse(response)) throw new Error("invalid_sync_response");
-    if (response.id !== request.id) throw new Error("sync_response_id_mismatch");
-    if (!response.ok) throw new Error(response.error);
-    return response.result;
+    try {
+      await stream.sink(encodeJsonFrames([request], 16 * 1024 * 1024));
+      let response;
+      for await (const value of createJsonFrameReader(stream.source, {
+        maxPayloadBytes: 16 * 1024 * 1024,
+        idleTimeoutMs: 15e3,
+        totalTimeoutMs: 12e4,
+        abort: async (error2) => stream.abort(error2)
+      })) {
+        if (response !== void 0) throw new Error("sync_response_multiple");
+        response = value;
+      }
+      if (!isLibp2pSyncResponse(response)) throw new Error("invalid_sync_response");
+      if (response.id !== request.id) throw new Error("sync_response_id_mismatch");
+      if (!response.ok) throw new Error(response.error);
+      return response.result;
+    } catch (error2) {
+      if (error2 instanceof JsonFrameError) await stream.abort(error2);
+      throw error2;
+    } finally {
+      await stream.close().catch(() => void 0);
+    }
   }
 };
-async function writeJsonToStream(stream, message) {
-  const payload = new TextEncoder().encode(JSON.stringify(message));
-  await stream.sink((async function* () {
-    yield payload;
-  })());
-}
-async function readJsonFromStream(stream) {
-  const reader = stream.source[Symbol.asyncIterator]();
-  const result = await reader.next();
-  if (result.done || !result.value) throw new Error("sync_response_missing");
-  return JSON.parse(new TextDecoder().decode(result.value));
-}
 
 // src/device-network/libp2pRpcProtocol.ts
-var LIBP2P_RPC_REQUEST_TYPE = "memeloop-rpc-request-v1";
-var LIBP2P_RPC_RESPONSE_TYPE = "memeloop-rpc-response-v1";
+var LIBP2P_RPC_REQUEST_TYPE = "memeloop-rpc-request-v2";
+var LIBP2P_RPC_RESPONSE_TYPE = "memeloop-rpc-response-v2";
 function isLibp2pRpcRequest(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
   const record2 = value;
@@ -29079,7 +29624,7 @@ function isLibp2pRpcResponse(value) {
 }
 
 // src/device-network/localTrustDeviceAuthorizer.ts
-var PAIRING_PROTOCOL = "/memeloop/pairing/1.0.0";
+var PAIRING_PROTOCOL = "/memeloop/pairing/2.0.0";
 var LocalTrustDeviceAuthorizer = class {
   constructor(options = {}) {
     this.options = options;
@@ -29241,6 +29786,8 @@ var MemoryDeviceNetworkService = class {
       async sink() {
       },
       async close() {
+      },
+      abort() {
       }
     };
   }
@@ -29273,7 +29820,7 @@ var MemoryDeviceNetworkService = class {
 };
 
 // src/device-network/pairingInvite.ts
-var DEVICE_PAIRING_INVITE_PROTOCOL = "memeloop-device-pairing-v1";
+var DEVICE_PAIRING_INVITE_PROTOCOL = "memeloop-device-pairing-v2";
 var DEVICE_PAIRING_INVITE_TTL_MS = 5 * 6e4;
 var MAX_INVITE_LENGTH = 16 * 1024;
 var MAX_ADDRESSES = 8;
@@ -29284,37 +29831,82 @@ function requireText(value, name, maxLength) {
   }
   return trimmed;
 }
-function validateAddresses(addresses) {
+function finalPeerId(address) {
+  const parts = address.split("/");
+  for (let index = parts.length - 2; index >= 0; index -= 1) {
+    if (parts[index] === "p2p") return parts[index + 1];
+  }
+  return void 0;
+}
+function validateAddresses(addresses, peerId) {
   const unique = [...new Set(addresses.map((address) => address.trim()))].filter(Boolean);
   if (unique.length === 0 || unique.length > MAX_ADDRESSES || unique.some(
-    (address) => address.length > 2048 || !address.startsWith("/") || !address.includes("/ws") && !address.includes("/wss")
+    (address) => address.length > 2048 || !address.startsWith("/") || !address.includes("/ws") && !address.includes("/wss") || finalPeerId(address) !== peerId
   )) {
-    throw new Error("device pairing invite requires WebSocket multiaddrs");
+    throw new Error("device pairing invite requires PeerId-bound WebSocket multiaddrs");
   }
   return unique;
 }
-function createDevicePairingInvite(device, options = {}) {
+function validateLifetime(createdAt, expiresAt, now) {
+  if (!Number.isSafeInteger(createdAt) || !Number.isSafeInteger(expiresAt) || expiresAt <= createdAt || expiresAt - createdAt > DEVICE_PAIRING_INVITE_TTL_MS) {
+    throw new Error("invalid device pairing invite lifetime");
+  }
+  if (expiresAt <= now) throw new Error("device pairing invite has expired");
+}
+function unsignedPayload(invite) {
+  const peerId = requireText(invite.peerId, "peerId", 256);
+  return {
+    protocol: DEVICE_PAIRING_INVITE_PROTOCOL,
+    peerId,
+    publicKeyMultibase: requireText(invite.publicKeyMultibase, "publicKeyMultibase", 4096),
+    deviceName: requireText(invite.deviceName, "deviceName", 256),
+    multiaddrs: [...validateAddresses(invite.multiaddrs, peerId)].sort(),
+    createdAt: invite.createdAt,
+    expiresAt: invite.expiresAt
+  };
+}
+function canonicalDevicePairingInviteBytes(invite) {
+  const payload = unsignedPayload(invite);
+  const canonical = [
+    DEVICE_PAIRING_INVITE_PROTOCOL,
+    `peerId=${payload.peerId}`,
+    `publicKey=${payload.publicKeyMultibase}`,
+    `deviceName=${payload.deviceName}`,
+    `multiaddrs=${payload.multiaddrs.join(",")}`,
+    `createdAt=${payload.createdAt}`,
+    `expiresAt=${payload.expiresAt}`
+  ].join("\n");
+  return new TextEncoder().encode(canonical);
+}
+async function createDevicePairingInvite(device, options) {
   const createdAt = options.now ?? Date.now();
   const ttlMs = options.ttlMs ?? DEVICE_PAIRING_INVITE_TTL_MS;
-  if (!Number.isSafeInteger(createdAt) || !Number.isSafeInteger(ttlMs) || ttlMs <= 0 || ttlMs > DEVICE_PAIRING_INVITE_TTL_MS) {
+  if (!Number.isSafeInteger(createdAt) || !Number.isSafeInteger(ttlMs) || ttlMs <= 0) {
     throw new Error("invalid device pairing invite lifetime");
   }
-  return {
+  const payload = unsignedPayload({
     protocol: DEVICE_PAIRING_INVITE_PROTOCOL,
-    peerId: requireText(device.peerId, "peerId", 256),
-    deviceName: requireText(device.displayName, "deviceName", 256),
-    multiaddrs: validateAddresses(device.multiaddrs ?? []),
+    peerId: device.peerId,
+    publicKeyMultibase: device.publicKeyMultibase,
+    deviceName: device.displayName,
+    multiaddrs: device.multiaddrs ?? [],
     createdAt,
     expiresAt: createdAt + ttlMs
-  };
+  });
+  validateLifetime(payload.createdAt, payload.expiresAt, createdAt - 1);
+  const signature = requireText(
+    await options.sign(canonicalDevicePairingInviteBytes(payload)),
+    "signature",
+    4096
+  );
+  return { ...payload, signature };
 }
 function encodeDevicePairingInvite(invite) {
-  const validated = parseDevicePairingInvite(JSON.stringify(invite), {
-    now: invite.createdAt
-  });
-  return JSON.stringify(validated);
+  const payload = unsignedPayload(invite);
+  const signature = requireText(invite.signature, "signature", 4096);
+  return JSON.stringify({ ...payload, signature });
 }
-function parseDevicePairingInvite(serialized, options = {}) {
+async function parseDevicePairingInvite(serialized, options) {
   if (!serialized || serialized.length > MAX_INVITE_LENGTH) {
     throw new Error("invalid device pairing invite length");
   }
@@ -29328,20 +29920,30 @@ function parseDevicePairingInvite(serialized, options = {}) {
     throw new Error("invalid device pairing invite");
   }
   const record2 = parsed;
-  if (record2.protocol !== DEVICE_PAIRING_INVITE_PROTOCOL || typeof record2.peerId !== "string" || typeof record2.deviceName !== "string" || !Array.isArray(record2.multiaddrs) || record2.multiaddrs.some((address) => typeof address !== "string") || typeof record2.createdAt !== "number" || typeof record2.expiresAt !== "number" || !Number.isSafeInteger(record2.createdAt) || !Number.isSafeInteger(record2.expiresAt) || record2.expiresAt <= record2.createdAt || record2.expiresAt - record2.createdAt > DEVICE_PAIRING_INVITE_TTL_MS) {
+  if (record2.protocol !== DEVICE_PAIRING_INVITE_PROTOCOL || typeof record2.peerId !== "string" || typeof record2.publicKeyMultibase !== "string" || typeof record2.deviceName !== "string" || !Array.isArray(record2.multiaddrs) || record2.multiaddrs.some((address) => typeof address !== "string") || typeof record2.createdAt !== "number" || typeof record2.expiresAt !== "number" || typeof record2.signature !== "string") {
     throw new Error("invalid device pairing invite");
   }
-  if (record2.expiresAt <= (options.now ?? Date.now())) {
-    throw new Error("device pairing invite has expired");
-  }
-  return {
+  validateLifetime(record2.createdAt, record2.expiresAt, options.now ?? Date.now());
+  const payload = unsignedPayload({
     protocol: DEVICE_PAIRING_INVITE_PROTOCOL,
-    peerId: requireText(record2.peerId, "peerId", 256),
-    deviceName: requireText(record2.deviceName, "deviceName", 256),
-    multiaddrs: validateAddresses(record2.multiaddrs),
+    peerId: record2.peerId,
+    publicKeyMultibase: record2.publicKeyMultibase,
+    deviceName: record2.deviceName,
+    multiaddrs: record2.multiaddrs,
     createdAt: record2.createdAt,
     expiresAt: record2.expiresAt
+  });
+  const invite = {
+    ...payload,
+    signature: requireText(record2.signature, "signature", 4096)
   };
+  if (!await options.verifyIdentity({
+    invite,
+    payload: canonicalDevicePairingInviteBytes(payload)
+  })) {
+    throw new Error("device pairing invite identity verification failed");
+  }
+  return invite;
 }
 
 // src/device-network/peerDriverTransport.ts
@@ -29484,11 +30086,21 @@ function createPeerDriverRpcHandler(handlers) {
 // src/device-network/syncCloudDevices.ts
 async function syncCloudDevices(input) {
   const cloudDevices = await input.cloudClient.listDevices();
-  if (cloudDevices.length === 0) return [];
   const existingRecords = await input.trustStore.loadTrustedDevices();
   const existingByPeerId = new Map(existingRecords.map((r) => [r.peerId, r]));
-  for (const cloudDevice of cloudDevices) {
+  const excludedPeerIds = new Set(input.excludePeerIds ?? []);
+  const activeCloudDevices = cloudDevices.filter(
+    (device) => device.revokedAt === void 0 && !excludedPeerIds.has(device.peerId)
+  );
+  const visibleCloudPeerIds = new Set(activeCloudDevices.map((device) => device.peerId));
+  for (const existing of existingRecords) {
+    if (existing.trustMode === "cloud-account" && !visibleCloudPeerIds.has(existing.peerId)) {
+      await input.trustStore.removeTrustedDevice(existing.peerId);
+    }
+  }
+  for (const cloudDevice of activeCloudDevices) {
     const existing = existingByPeerId.get(cloudDevice.peerId);
+    if (existing?.trustMode === "local-pairing") continue;
     const record2 = {
       peerId: cloudDevice.peerId,
       publicKeyMultibase: cloudDevice.publicKeyMultibase,
@@ -29500,17 +30112,14 @@ async function syncCloudDevices(input) {
       lastSeen: cloudDevice.lastSeen,
       revokedAt: cloudDevice.revokedAt
     };
-    if (existing) {
-      existing.lastSeen = cloudDevice.lastSeen;
-      existing.revokedAt = cloudDevice.revokedAt;
-      if (existing.publicKeyMultibase !== record2.publicKeyMultibase || existing.deviceName !== record2.deviceName || existing.platform !== record2.platform) {
-        await input.trustStore.saveTrustedDevice(record2);
-      }
-    } else {
+    if (!existing || !sameTrustedDevice(existing, record2)) {
       await input.trustStore.saveTrustedDevice(record2);
     }
   }
-  return cloudDevices;
+  return activeCloudDevices;
+}
+function sameTrustedDevice(left, right) {
+  return left.peerId === right.peerId && left.publicKeyMultibase === right.publicKeyMultibase && left.deviceName === right.deviceName && left.platform === right.platform && left.trustMode === right.trustMode && left.accountId === right.accountId && left.createdAt === right.createdAt && left.lastSeen === right.lastSeen && left.revokedAt === right.revokedAt;
 }
 
 // src/network/terminalNotifications.ts
@@ -29847,7 +30456,17 @@ async function imSwitchConversation(rt, conversationId) {
 function isConversationMeta(value) {
   if (value === null || typeof value !== "object") return false;
   const o = value;
-  return typeof o.conversationId === "string" && typeof o.title === "string" && typeof o.originNodeId === "string" && typeof o.definitionId === "string" && typeof o.messageCount === "number" && typeof o.lastMessageTimestamp === "number" && typeof o.isUserInitiated === "boolean";
+  return typeof o.conversationId === "string" && typeof o.title === "string" && typeof o.originNodeId === "string" && typeof o.originClock === "number" && typeof o.definitionId === "string" && typeof o.messageCount === "number" && typeof o.lastMessageTimestamp === "number" && typeof o.isUserInitiated === "boolean";
+}
+function computeMissingVersionRanges(currentVersion, availableVersion) {
+  const ranges = [];
+  for (const [originNodeId, availableClock] of Object.entries(availableVersion)) {
+    const currentClock = currentVersion[originNodeId] ?? 0;
+    if (availableClock > currentClock) {
+      ranges.push({ originNodeId, fromExclusive: currentClock, toInclusive: availableClock });
+    }
+  }
+  return ranges.sort((left, right) => left.originNodeId.localeCompare(right.originNodeId));
 }
 
 // src/index.ts
@@ -31011,11 +31630,13 @@ function getToolDefinition(toolId) {
   DRIVER_MANIFEST_API_VERSION,
   DRIVER_MANIFEST_KIND,
   DRIVER_REQUEST_API_VERSION,
+  DeviceCloudConnectionCoordinator,
   FLEET_ROLLOUT_API_VERSION,
   FLEET_ROLLOUT_KIND,
   HookRegistry,
   IMChannelManager,
   IM_SESSION_TOOL_IDS,
+  JsonFrameError,
   LIBP2P_RPC_REQUEST_TYPE,
   LIBP2P_RPC_RESPONSE_TYPE,
   LIBP2P_SYNC_REQUEST_TYPE,
@@ -31033,6 +31654,7 @@ function getToolDefinition(toolId) {
   MODEL_ENDPOINT_API_VERSION,
   MODEL_ENDPOINT_KIND,
   MemoryDeviceNetworkService,
+  MemoryDeviceSyncStateStore,
   NETWORK_ATTACHMENT_API_VERSION,
   NETWORK_ATTACHMENT_KIND,
   NETWORK_CLASS_API_VERSION,
@@ -31131,6 +31753,7 @@ function getToolDefinition(toolId) {
   canDriverSatisfyClass,
   cancelPendingApprovals,
   canonicalControlStoreValue,
+  canonicalDevicePairingInviteBytes,
   canonicalDriverValue,
   canonicalWorkerBootstrapDescriptorBytes,
   canonicalWorkerProtocolRequestBytes,
@@ -31140,6 +31763,7 @@ function getToolDefinition(toolId) {
   clearHooks,
   clearPluginRegistrations,
   compactMessages,
+  computeMissingVersionRanges,
   consumeWorkloadCapabilityGrant,
   containsSecrets,
   controlStoreApplyMatches,
@@ -31227,6 +31851,7 @@ function getToolDefinition(toolId) {
   createInProcessLoopRuntimeDriver,
   createInProcessToolExecutionDriver,
   createInstanceDeltaFromDefinition,
+  createJsonFrameReader,
   createLoopRuntimeManagementConformanceSuite,
   createManagedArtifactDriverAdapter,
   createManagedCredentialBrokerAdapter,
@@ -31308,6 +31933,8 @@ function getToolDefinition(toolId) {
   detectMimeConfusion,
   digestNormalizedScript,
   encodeDevicePairingInvite,
+  encodeJsonFrame,
+  encodeJsonFrames,
   enrollWorker,
   evaluateApproval,
   evaluateToolAdmission,