memeloop 0.0.1

package/dist/index.js

@@ -0,0 +1,4040 @@
+import {
+  AGENT_AGENT_LOOP_ID,
+  AGENT_TOOL_LOOP_ID,
+  ALL_CATEGORIES,
+  ASK_QUESTION_TOOL_ID,
+  ASK_USER_QUESTION_TOOL_ID,
+  AgentProfileRegistry,
+  BUILTIN_AGENT_AGENT_LOOP_QUALITY_GATE_SCRIPT_ID,
+  BUILTIN_AGENT_PROFILES,
+  BUILTIN_AGENT_TOOL_LOOP_DEFAULT_SCRIPT_ID,
+  BUILTIN_TOOL_PLUGIN_IDS,
+  HookRegistry,
+  MEMELOOP_STRUCTURED_TOOL_KEY,
+  PERMISSIONS_TABLE_DDL,
+  PLUGIN_ASK_QUESTION,
+  PLUGIN_ASK_USER_QUESTION,
+  PLUGIN_MCP_CLIENT,
+  PLUGIN_MCP_FORWARD,
+  PLUGIN_REMOTE_AGENT,
+  PLUGIN_SPAWN_AGENT,
+  PLUGIN_TASK,
+  PLUGIN_TODO_WRITE,
+  ProviderRegistry,
+  TODO_WRITE_TOOL_ID,
+  TokenTracker,
+  __clearTodoStore,
+  askQuestionConfigSchema,
+  askQuestionImpl,
+  askUserQuestionConfigSchema,
+  askUserQuestionImpl,
+  autoCompact,
+  buildAgent,
+  builtinAgentAgentLoopSources,
+  builtinAgentToolLoopSources,
+  cancelPendingApprovals,
+  checkPermission,
+  clearHooks,
+  clearPluginRegistrations,
+  compactMessages,
+  createAgentAgentLoopDefinition,
+  createAgentFrameworkHooks,
+  createAgentInstanceFromDefinition,
+  createAgentLoopRunner,
+  createAgentToolLoopDefinition,
+  createAgentToolLoopRunner,
+  createChatMessage,
+  createHooksWithPlugins,
+  createMemeLoopRuntime,
+  createPluginAPI,
+  evaluateApproval,
+  executeHooks,
+  exploreAgent,
+  extractMemeloopStructuredToolPayload,
+  findPromptById,
+  flattenPrompts,
+  getActivePluginRegistry,
+  getAgentAgentLoopId,
+  getAgentProfileRegistry,
+  getBuiltinAgentAgentLoopSource,
+  getBuiltinAgentToolLoopSource,
+  getBuiltinLoopProfile,
+  getBuiltinLoopProfiles,
+  getBuiltinToolPlugins,
+  getCategoryConfig,
+  getDefaultHookRegistry,
+  getHookCount,
+  getLoadedPlugin,
+  getLoopRegistry,
+  getMcpClientToolId,
+  getMcpForwardToolId,
+  getPendingApprovals,
+  getPluginRegistrations,
+  getRemoteAgentToolId,
+  getSpawnAgentToolId,
+  getTaskToolId,
+  getToolMetadata,
+  getToolParameterSchema,
+  hasHooks,
+  isPluginLoaded,
+  isTaskCategory,
+  librarianAgent,
+  listPlugins,
+  listRegisteredHookTypes,
+  loadAgentAgentLoopScript,
+  loadAgentToolLoopScript,
+  loadPluginModule,
+  loadPluginModules,
+  loadUserPermissions,
+  matchAllToolCallings,
+  matchPattern,
+  matchToolCalling,
+  mcpClientConfigSchema,
+  mcpClientImpl,
+  mcpForwardConfigSchema,
+  mcpForwardImpl,
+  mergePermissionSets,
+  onApprovalRequest,
+  oracleAgent,
+  planAgent,
+  pluginRegistry,
+  promptConcatStream,
+  registerBuiltinLoops,
+  registerBuiltinPromptPlugins,
+  registerBuiltinToolPlugins,
+  registerHook,
+  registerPluginHooks,
+  registerPluginTools,
+  registerToolParameterSchema,
+  remoteAgentConfigSchema,
+  remoteAgentImpl,
+  remoteAgentListImpl,
+  requestApproval,
+  resetAgentProfileRegistry,
+  resetLoopRegistry,
+  resolveAgentToolLoopTerminalState,
+  resolveApproval,
+  resolveCategory,
+  resolvePromptPluginMap,
+  resolveQuestionAnswer,
+  runAgentToolLoopTurn,
+  runPostProcessHooks,
+  runProcessPromptsHooks,
+  runResponseCompleteHooks,
+  runToolExecutedHooks,
+  runWithPluginRegistry,
+  saveUserPermissions,
+  shouldCompact,
+  spawnAgentConfigSchema,
+  spawnAgentImpl,
+  taskToolConfigSchema,
+  taskToolImpl,
+  todoWriteConfigSchema,
+  todoWriteImpl,
+  truncateToolSummary,
+  unloadAllPlugins,
+  unloadPlugin,
+  unregisterHook,
+  validatePluginManifest
+} from "./chunk-3CN7DFBL.js";
+import {
+  createFetchLLMProvider
+} from "./chunk-OVJ7JJBA.js";
+
+// src/sync/attachmentRpcCodec.ts
+function decodeAttachmentBlobRpc(result) {
+  if (result == null || typeof result !== "object") return null;
+  const r = result;
+  if (r.error || !r.found || typeof r.dataBase64 !== "string") return null;
+  const data = Buffer.from(r.dataBase64, "base64");
+  if (!data.length) return null;
+  return {
+    data: new Uint8Array(data),
+    filename: typeof r.filename === "string" ? r.filename : "attachment",
+    mimeType: typeof r.mimeType === "string" ? r.mimeType : "application/octet-stream",
+    size: typeof r.size === "number" && r.size > 0 ? r.size : data.length
+  };
+}
+
+// src/sync/chatSyncEngine.ts
+var ChatSyncEngine = class {
+  nodeId;
+  storage;
+  getPeers;
+  versionVector = {};
+  constructor(options) {
+    this.nodeId = options.nodeId;
+    this.storage = options.storage;
+    this.getPeers = options.peers;
+    this.versionVector[this.nodeId] = 0;
+  }
+  /**
+   * 在本节点新产生一条消息时调用，增加本节点的 lamportClock。
+   */
+  bumpLocalVersion() {
+    this.versionVector[this.nodeId] = (this.versionVector[this.nodeId] ?? 0) + 1;
+  }
+  /**
+   * 执行一次与所有 peer 的增量同步（metadata 级别），并尽力拉取缺失消息。
+   */
+  async syncOnce() {
+    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);
+      }
+      for (const [nodeId, clock] of Object.entries(remoteVersion)) {
+        const current = this.versionVector[nodeId] ?? 0;
+        if (clock > current) {
+          this.versionVector[nodeId] = clock;
+        }
+      }
+      if (missingForRemote.length > 0) {
+        this.bumpLocalVersion();
+      }
+    }
+    for (const conversationId of pulledConversations) {
+      await this.pullMessagesForConversationFromPeers(conversationId, peers);
+    }
+  }
+  /**
+   * Anti-entropy：先 syncOnce，再对已知会话逐个向各 peer 拉取缺失消息（参考审查单「定期对账」）。
+   */
+  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" });
+    const knownIds = localMsgs.map((m) => m.messageId);
+    for (const peer of peers) {
+      if (!peer.pullMissingMessages) continue;
+      try {
+        const incoming = await peer.pullMissingMessages(conversationId, knownIds);
+        if (incoming.length > 0) {
+          await this.storage.insertMessagesIfAbsent(incoming);
+          await this.ensureAttachmentsFromMessages(incoming, peers);
+        }
+      } catch {
+      }
+    }
+  }
+  /** 从消息元数据收集 `attachments[].contentHash`，对本地缺失 BLOB 的哈希向各 peer 拉取并 `saveAttachment`。 */
+  async ensureAttachmentsFromMessages(messages, peers) {
+    const hashes = /* @__PURE__ */ new Set();
+    for (const m of messages) {
+      for (const a of m.attachments ?? []) {
+        if (a.contentHash) hashes.add(a.contentHash);
+      }
+    }
+    for (const h of hashes) {
+      const reference = await this.storage.getAttachment(h);
+      if (reference) {
+        const reader = this.storage.readAttachmentData?.bind(this.storage);
+        if (!reader) continue;
+        const bytes = await reader(h);
+        if (bytes && bytes.length > 0) continue;
+      }
+      for (const peer of peers) {
+        const pull = peer.pullAttachmentBlob?.bind(peer);
+        if (!pull) continue;
+        try {
+          const blob = await pull(h);
+          if (blob?.data?.length) {
+            const ar = {
+              contentHash: h,
+              filename: blob.filename,
+              mimeType: blob.mimeType,
+              size: blob.size > 0 ? blob.size : blob.data.length
+            };
+            await this.storage.saveAttachment(ar, blob.data);
+            break;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  getVersionVector() {
+    return { ...this.versionVector };
+  }
+  getStorage() {
+    return this.storage;
+  }
+};
+
+// src/sync/peerNodeAdapter.ts
+var PeerNodeSyncAdapter = class {
+  nodeId;
+  transport;
+  constructor(nodeId, transport) {
+    this.nodeId = nodeId;
+    this.transport = transport;
+  }
+  exchangeVersionVector(localVersion) {
+    return this.transport.exchangeVersionVector(this.nodeId, localVersion);
+  }
+  pullMissingMetadata(sinceVersion) {
+    return this.transport.pullMissingMetadata(this.nodeId, sinceVersion);
+  }
+  pullMissingMessages(conversationId, knownMessageIds) {
+    const function_ = this.transport.pullMissingMessages?.bind(this.transport);
+    if (!function_) {
+      return Promise.resolve([]);
+    }
+    return function_(this.nodeId, conversationId, knownMessageIds);
+  }
+  pullAttachmentBlob(contentHash) {
+    const function_ = this.transport.pullAttachmentBlob?.bind(this.transport);
+    if (!function_) {
+      return Promise.resolve(null);
+    }
+    return function_(this.nodeId, contentHash);
+  }
+};
+
+// src/types.ts
+function isUserInitiatedConversation(meta) {
+  return meta.isUserInitiated;
+}
+function createInstanceDeltaFromDefinition(definition, overrides) {
+  const delta = {};
+  for (const key of Object.keys(overrides)) {
+    const value = overrides[key];
+    if (value !== void 0 && value !== definition[key]) {
+      delta[key] = value;
+    }
+  }
+  return delta;
+}
+
+// src/storage/sessionStorage.ts
+function createCheckpointRecord(conversationId, messages, savedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const lastMessage = messages[messages.length - 1];
+  const preview = lastMessage && typeof lastMessage.content === "string" ? lastMessage.content.slice(0, 200) : "";
+  return {
+    conversationId,
+    messages: [...messages],
+    savedAt,
+    messageCount: messages.length,
+    lastMessagePreview: preview
+  };
+}
+function parseCheckpointRecord(raw) {
+  try {
+    const record = JSON.parse(raw);
+    return isCheckpointRecord(record) ? record : null;
+  } catch {
+    return null;
+  }
+}
+function serializeCheckpointRecord(record) {
+  return JSON.stringify(record, null, 2);
+}
+var InMemoryCheckpointStore = class {
+  records = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    for (const record of options.records ?? []) {
+      this.records.set(record.conversationId, cloneCheckpointRecord(record));
+    }
+  }
+  async saveCheckpoint(conversationId, messages) {
+    const record = createCheckpointRecord(conversationId, messages);
+    this.records.set(conversationId, cloneCheckpointRecord(record));
+    return cloneCheckpointRecord(record);
+  }
+  async loadCheckpoint(conversationId) {
+    const record = this.records.get(conversationId);
+    return record ? cloneCheckpointRecord(record) : null;
+  }
+  async listCheckpoints() {
+    return [...this.records.values()].map(toCheckpointSummary).sort((a, b) => b.savedAt.localeCompare(a.savedAt));
+  }
+  async deleteCheckpoint(conversationId) {
+    return this.records.delete(conversationId);
+  }
+};
+var SessionStorage = class extends InMemoryCheckpointStore {
+};
+function isCheckpointRecord(record) {
+  if (!record || typeof record !== "object") return false;
+  const candidate = record;
+  return typeof candidate.conversationId === "string" && Array.isArray(candidate.messages) && typeof candidate.savedAt === "string" && typeof candidate.messageCount === "number" && typeof candidate.lastMessagePreview === "string";
+}
+function cloneCheckpointRecord(record) {
+  return {
+    ...record,
+    messages: [...record.messages]
+  };
+}
+function toCheckpointSummary(record) {
+  return {
+    conversationId: record.conversationId,
+    savedAt: record.savedAt,
+    messageCount: record.messageCount,
+    lastMessagePreview: record.lastMessagePreview
+  };
+}
+
+// src/agent/tiddlerTemplateConverter.ts
+function tiddlerToAgentDefinition(tiddler, workspaceName) {
+  if (!tiddler || !tiddler.title || typeof tiddler.text !== "string") return null;
+  let agentFrameworkConfig;
+  try {
+    const parsed = JSON.parse(tiddler.text);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return null;
+    }
+    agentFrameworkConfig = parsed;
+  } catch {
+    return null;
+  }
+  const getString = (field, fallback = "") => typeof field === "string" ? field : field && typeof field === "object" ? JSON.stringify(field) : fallback;
+  const parseJSON = (field) => {
+    if (typeof field === "string") {
+      try {
+        const parsed = JSON.parse(field);
+        if (typeof parsed === "object" && parsed !== null) {
+          return parsed;
+        }
+      } catch {
+      }
+    }
+    return void 0;
+  };
+  const id = `wiki-template-${getString(tiddler.title).replace(/[^a-zA-Z0-9-_]/g, "-")}`;
+  const name = getString(tiddler.caption) || getString(tiddler.title);
+  const description = getString(tiddler.description) || `Agent template from ${workspaceName || "wiki"}`;
+  const modelConfigRaw = parseJSON(tiddler.ai_api_config);
+  const rawAsRecord = modelConfigRaw && typeof modelConfigRaw === "object" && !Array.isArray(modelConfigRaw) ? modelConfigRaw : void 0;
+  const modelConfig = rawAsRecord ? {
+    provider: typeof rawAsRecord.provider === "string" ? rawAsRecord.provider : "",
+    model: typeof rawAsRecord.model === "string" ? rawAsRecord.model : ""
+  } : void 0;
+  const toolsRaw = parseJSON(tiddler.agent_tools);
+  const toolNames = Array.isArray(toolsRaw) ? toolsRaw.filter((t) => typeof t?.toolId === "string").map((t) => String(t.toolId)) : [];
+  return {
+    id,
+    name,
+    description,
+    systemPrompt: "",
+    tools: toolNames,
+    modelConfig,
+    // Keep the original config as promptSchema for the UI editor
+    promptSchema: agentFrameworkConfig,
+    agentFrameworkConfig: {
+      prompts: Array.isArray(agentFrameworkConfig.prompts) ? agentFrameworkConfig.prompts : [],
+      plugins: Array.isArray(agentFrameworkConfig.plugins) ? agentFrameworkConfig.plugins : [],
+      response: Array.isArray(agentFrameworkConfig.response) ? agentFrameworkConfig.response : void 0
+    },
+    version: "1"
+  };
+}
+
+// src/agent-management/AgentSessionController.ts
+var AgentSessionController = class {
+  options;
+  listener = null;
+  snapshot = {
+    agent: null,
+    loading: false,
+    error: null,
+    messages: [],
+    orderedMessageIds: [],
+    streamingMessageIds: /* @__PURE__ */ new Set()
+  };
+  unsubAgentUpdates = null;
+  unsubMessages = null;
+  pollingTimer = null;
+  agentId = null;
+  constructor(options) {
+    this.options = {
+      pollInterval: 500,
+      ...options
+    };
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────
+  /**
+   * Start a session for the given agent ID.
+   * Fetches the agent, subscribes to live updates, and loads messages.
+   */
+  async start(agentId) {
+    this.agentId = agentId;
+    this.emitPartial({ loading: true, error: null });
+    try {
+      const [agent, rawMessages] = await Promise.all([
+        this.options.agentInstanceClient.fetchAgent(agentId),
+        this.options.conversationClient.getMessages(agentId)
+      ]);
+      const orderedMessageIds = rawMessages.map((m) => m.messageId);
+      const messagesMap = /* @__PURE__ */ new Map();
+      for (const m of rawMessages) messagesMap.set(m.messageId, m);
+      this.emitPartial({
+        agent,
+        loading: false,
+        messages: rawMessages,
+        orderedMessageIds,
+        streamingMessageIds: /* @__PURE__ */ new Set()
+      });
+      this.unsubAgentUpdates = this.options.agentInstanceClient.subscribeToUpdates(
+        agentId,
+        this.handleAgentUpdate
+      );
+      this.unsubMessages = this.options.conversationClient.subscribeToMessages(
+        agentId,
+        this.handleNewMessage
+      );
+      this.startPolling(agentId);
+    } catch (error_) {
+      this.emitPartial({
+        loading: false,
+        error: error_ instanceof Error ? error_ : new Error(String(error_))
+      });
+    }
+  }
+  /** Stop the session and clean up subscriptions. */
+  stop() {
+    this.stopPolling();
+    this.unsubAgentUpdates?.();
+    this.unsubAgentUpdates = null;
+    this.unsubMessages?.();
+    this.unsubMessages = null;
+    this.agentId = null;
+  }
+  // ── Actions ───────────────────────────────────────────────────
+  /** Send a user message. */
+  async sendMessage(content, file, wikiTiddlers) {
+    if (!this.agentId) return;
+    this.emitPartial({ error: null });
+    try {
+      await this.options.conversationClient.sendMessage(this.agentId, content, file, wikiTiddlers);
+    } catch (error_) {
+      this.emitPartial({
+        error: error_ instanceof Error ? error_ : new Error(String(error_))
+      });
+    }
+  }
+  /** Cancel the current agent operation. */
+  async cancel() {
+    if (!this.agentId) return;
+    try {
+      await this.options.agentInstanceClient.cancelAgent(this.agentId);
+    } catch (error_) {
+      this.emitPartial({
+        error: error_ instanceof Error ? error_ : new Error(String(error_))
+      });
+    }
+  }
+  /** Delete a turn starting at the given user message ID. */
+  async deleteTurn(userMessageId) {
+    return this.options.conversationClient.deleteTurn(userMessageId);
+  }
+  /** Retry a turn starting at the given user message ID. */
+  async retryTurn(userMessageId) {
+    return this.options.conversationClient.retryTurn(userMessageId);
+  }
+  // ── Subscription ──────────────────────────────────────────────
+  /** Subscribe to snapshot changes. Returns unsubscribe function. */
+  subscribe(listener) {
+    this.listener = listener;
+    listener({ ...this.snapshot, streamingMessageIds: new Set(this.snapshot.streamingMessageIds) });
+    return () => {
+      if (this.listener === listener) this.listener = null;
+    };
+  }
+  /** Get current snapshot without subscribing. */
+  getSnapshot() {
+    return this.snapshot;
+  }
+  // ── Private helpers ───────────────────────────────────────────
+  emitPartial(partial) {
+    this.snapshot = { ...this.snapshot, ...partial };
+    if (this.listener) {
+      this.listener({
+        ...this.snapshot,
+        streamingMessageIds: new Set(this.snapshot.streamingMessageIds)
+      });
+    }
+  }
+  handleAgentUpdate = (update) => {
+    if (this.snapshot.agent) {
+      this.emitPartial({ agent: { ...this.snapshot.agent, ...update } });
+    }
+  };
+  handleNewMessage = (message) => {
+    const messages = [...this.snapshot.messages.filter((m) => m.messageId !== message.messageId), message];
+    const orderedMessageIds = [.../* @__PURE__ */ new Set([...this.snapshot.orderedMessageIds, message.messageId])];
+    this.emitPartial({ messages, orderedMessageIds });
+  };
+  startPolling(agentId) {
+    this.stopPolling();
+    this.pollingTimer = setInterval(async () => {
+      try {
+        const agent = await this.options.agentInstanceClient.fetchAgent(agentId);
+        this.emitPartial({ agent });
+      } catch {
+      }
+    }, this.options.pollInterval);
+  }
+  stopPolling() {
+    if (this.pollingTimer !== null) {
+      clearInterval(this.pollingTimer);
+      this.pollingTimer = null;
+    }
+  }
+};
+
+// src/agent-management/AgentDefinitionEditorController.ts
+var AgentDefinitionEditorController = class {
+  options;
+  listener = null;
+  state = {
+    agentDefinition: null,
+    agentName: "",
+    previewAgentId: null,
+    isLoading: false,
+    isSaving: false,
+    promptSchema: null
+  };
+  autosaveTimer = null;
+  constructor(options) {
+    this.options = {
+      autosaveDebounceMs: 1e3,
+      ...options
+    };
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────
+  /** Load an agent definition and its prompt schema. */
+  async loadDefinition(definitionId) {
+    this.emit({ isLoading: true });
+    try {
+      const [definition, previewAgentId] = await Promise.all([
+        this.options.definitionRepository.getAgentDef(definitionId),
+        this.findOrCreatePreviewAgent(definitionId)
+      ]);
+      if (!definition) {
+        this.emit({ isLoading: false });
+        return;
+      }
+      let promptSchema = null;
+      if (definition.agentFrameworkID) {
+        try {
+          promptSchema = await this.options.agentInstanceClient.getFrameworkConfigSchema(
+            definition.agentFrameworkID
+          );
+        } catch {
+          promptSchema = null;
+        }
+      }
+      this.state = {
+        agentDefinition: definition,
+        agentName: definition.name ?? "",
+        previewAgentId,
+        isLoading: false,
+        isSaving: false,
+        promptSchema
+      };
+      this.emit(this.state);
+    } catch (_error) {
+      this.emit({ isLoading: false });
+    }
+  }
+  /** Update the agent definition field. Triggers debounced autosave. */
+  updateDefinition(change) {
+    if (!this.state.agentDefinition) return;
+    const updated = { ...this.state.agentDefinition, ...change };
+    this.state = { ...this.state, agentDefinition: updated, agentName: updated.name ?? "" };
+    this.emit({ agentDefinition: updated, agentName: this.state.agentName });
+    this.scheduleAutosave(updated);
+  }
+  /** Force an immediate save to the repository. */
+  async saveNow() {
+    if (!this.state.agentDefinition) return;
+    this.emit({ isSaving: true });
+    try {
+      await this.options.definitionRepository.updateAgentDef({
+        id: this.state.agentDefinition.id,
+        name: this.state.agentName,
+        description: this.state.agentDefinition.description,
+        agentFrameworkConfig: this.state.agentDefinition.agentFrameworkConfig,
+        aiApiConfig: this.state.agentDefinition.aiApiConfig,
+        agentTools: this.state.agentDefinition.agentTools,
+        heartbeat: this.state.agentDefinition.heartbeat
+      });
+    } catch (_error) {
+    } finally {
+      this.emit({ isSaving: false });
+    }
+  }
+  /** Reload the prompt schema for a framework ID. */
+  async reloadSchema(frameworkId) {
+    try {
+      const schema = await this.options.agentInstanceClient.getFrameworkConfigSchema(frameworkId);
+      this.emit({ promptSchema: schema });
+    } catch (_error) {
+      this.emit({ promptSchema: null });
+    }
+  }
+  // ── Preview agent lifecycle ───────────────────────────────────
+  /** Get or create a preview agent instance tied to this definition. */
+  async findOrCreatePreviewAgent(definitionId) {
+    try {
+      const result = await this.options.agentInstanceClient.createAgent(definitionId, {
+        preview: true
+      });
+      return result.id;
+    } catch (_error) {
+      return null;
+    }
+  }
+  // ── Scheduled tasks ───────────────────────────────────────────
+  async loadScheduledTasks() {
+    if (!this.state.previewAgentId) return [];
+    return this.options.scheduledTaskClient.listScheduledTasksForAgent(
+      this.state.previewAgentId
+    );
+  }
+  async saveScheduledTask(input) {
+    return this.options.scheduledTaskClient.createScheduledTask(input);
+  }
+  async deleteScheduledTask(taskId) {
+    return this.options.scheduledTaskClient.deleteScheduledTask(taskId);
+  }
+  // ── Subscription ──────────────────────────────────────────────
+  subscribe(listener) {
+    this.listener = listener;
+    listener(this.state);
+    return () => {
+      if (this.listener === listener) this.listener = null;
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  // ── Private ───────────────────────────────────────────────────
+  emit(change) {
+    this.listener?.(change);
+  }
+  scheduleAutosave(definition) {
+    if (this.autosaveTimer !== null) clearTimeout(this.autosaveTimer);
+    this.autosaveTimer = setTimeout(() => {
+      this.options.definitionRepository.updateAgentDef({
+        id: definition.id,
+        name: definition.name,
+        description: definition.description,
+        agentFrameworkConfig: definition.agentFrameworkConfig,
+        aiApiConfig: definition.aiApiConfig,
+        agentTools: definition.agentTools,
+        heartbeat: definition.heartbeat
+      }).catch(() => {
+      });
+    }, this.options.autosaveDebounceMs);
+  }
+};
+
+// src/agent-management/AgentCreationController.ts
+var AgentCreationController = class {
+  options;
+  listener = null;
+  state = {
+    currentStep: 0,
+    agentName: "",
+    selectedTemplate: null,
+    temporaryAgentDefinition: null,
+    previewAgentId: null,
+    isLoading: false,
+    promptSchema: null
+  };
+  constructor(options) {
+    this.options = {
+      defaultFrameworkId: "memeloopAgentToolLoop",
+      ...options
+    };
+  }
+  /** Initialize the creation wizard, optionally from a saved tab state. */
+  async start(definitionId, templateDefinitionId) {
+    this.emit({ isLoading: true });
+    try {
+      if (definitionId) {
+        const temporaryDefinition = await this.options.definitionRepository.getAgentDef(definitionId);
+        if (temporaryDefinition) {
+          this.state = {
+            ...this.state,
+            temporaryAgentDefinition: temporaryDefinition,
+            agentName: temporaryDefinition.name ?? "",
+            isLoading: false
+          };
+          this.emit(this.state);
+          if (templateDefinitionId) {
+            const template = await this.options.definitionRepository.getAgentDef(templateDefinitionId);
+            if (template) {
+              this.state = { ...this.state, selectedTemplate: template };
+              this.emit(this.state);
+            }
+          }
+          return;
+        }
+      }
+      this.emit({ isLoading: false });
+    } catch {
+      this.emit({ isLoading: false });
+    }
+  }
+  /** Select a template for the new agent. */
+  selectTemplate(template) {
+    this.state = { ...this.state, selectedTemplate: template };
+    this.emit(this.state);
+  }
+  /** Update the agent name. */
+  setAgentName(name) {
+    this.state = { ...this.state, agentName: name };
+    this.emit(this.state);
+  }
+  /** Advance to the next wizard step. */
+  nextStep() {
+    this.state = { ...this.state, currentStep: Math.min(this.state.currentStep + 1, 2) };
+    this.emit(this.state);
+  }
+  /** Go back to the previous wizard step. */
+  previousStep() {
+    this.state = { ...this.state, currentStep: Math.max(this.state.currentStep - 1, 0) };
+    this.emit(this.state);
+  }
+  /** Set the current wizard step directly. */
+  setStep(step) {
+    this.state = { ...this.state, currentStep: Math.max(0, Math.min(step, 2)) };
+    this.emit(this.state);
+  }
+  /** Update the temporary agent definition. */
+  updateTemporaryDefinition(change) {
+    const updated = this.state.temporaryAgentDefinition ? { ...this.state.temporaryAgentDefinition, ...change } : null;
+    this.state = { ...this.state, temporaryAgentDefinition: updated };
+    this.emit(this.state);
+  }
+  /** Set the prompt schema for the selected framework. */
+  setPromptSchema(schema) {
+    this.state = { ...this.state, promptSchema: schema };
+    this.emit(this.state);
+  }
+  /**
+   * Create a preview agent instance for the chat-preview step.
+   * Should be called when entering step 2 (or the chat preview step).
+   */
+  async createPreviewAgent(definitionId) {
+    this.emit({ isLoading: true });
+    try {
+      const result = await this.options.agentInstanceClient.createAgent(definitionId, {
+        preview: true
+      });
+      this.state = { ...this.state, previewAgentId: result.id, isLoading: false };
+      this.emit(this.state);
+    } catch {
+      this.emit({ isLoading: false });
+    }
+  }
+  /**
+   * Finalize creation: persist the temporary definition and create the actual
+   * agent instance. Returns the final agent instance ID, or null on failure.
+   */
+  async finalize() {
+    if (!this.state.temporaryAgentDefinition) return null;
+    try {
+      const definition = await this.options.definitionRepository.createAgentDef(
+        this.state.temporaryAgentDefinition
+      );
+      const instance = await this.options.agentInstanceClient.createAgent(definition.id);
+      return instance.id;
+    } catch {
+      return null;
+    }
+  }
+  /** Clean up temporary resources. */
+  async cleanup() {
+    if (this.state.previewAgentId) {
+      try {
+        await this.options.agentInstanceClient.deleteAgent(this.state.previewAgentId);
+      } catch {
+      }
+    }
+  }
+  // ── Subscription ──────────────────────────────────────────────
+  subscribe(listener) {
+    this.listener = listener;
+    listener({ ...this.state });
+    return () => {
+      if (this.listener === listener) this.listener = null;
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  // ── Private ───────────────────────────────────────────────────
+  emit(change) {
+    this.state = { ...this.state, ...change };
+    this.listener?.({ ...this.state });
+  }
+};
+
+// src/agent-management/PromptPreviewController.ts
+var PromptPreviewController = class {
+  options;
+  listener = null;
+  state = {
+    open: false,
+    baseMode: "preview",
+    activeTab: "tree",
+    loading: false,
+    progress: 0,
+    currentStep: "",
+    currentPlugin: null,
+    result: null,
+    lastUpdated: null,
+    formFieldsToScrollTo: []
+  };
+  constructor(options) {
+    this.options = options;
+  }
+  /** Open the dialog with an optional base mode. */
+  open(baseMode) {
+    this.state = {
+      ...this.state,
+      open: true,
+      baseMode: baseMode ?? "preview",
+      loading: false,
+      progress: 0,
+      currentStep: "Starting...",
+      currentPlugin: null,
+      result: null,
+      lastUpdated: null,
+      formFieldsToScrollTo: []
+    };
+    this.emit();
+  }
+  /** Close the dialog. */
+  close() {
+    this.state = {
+      ...this.state,
+      open: false,
+      baseMode: "preview",
+      lastUpdated: null,
+      formFieldsToScrollTo: []
+    };
+    this.emit();
+  }
+  /** Set the active tab in the dialog. */
+  setActiveTab(tab) {
+    this.state = { ...this.state, activeTab: tab };
+    this.emit();
+  }
+  /** Set form fields to scroll to (for edit mode navigation). */
+  setFormFieldsToScrollTo(fieldPaths) {
+    this.state = { ...this.state, formFieldsToScrollTo: fieldPaths };
+    this.emit();
+  }
+  /**
+   * Generate a preview of the prompt tree.
+   * @param agentFrameworkConfig  The agent's framework configuration
+   * @param messages              Current conversation messages
+   * @param inputText             Optional input text to include in the preview
+   */
+  async generate(agentFrameworkConfig, messages, inputText) {
+    this.state = {
+      ...this.state,
+      loading: true,
+      progress: 0,
+      currentStep: "Preparing..."
+    };
+    this.emit();
+    try {
+      const result = await this.options.previewClient.generatePreview(
+        agentFrameworkConfig,
+        messages,
+        inputText,
+        (progress) => {
+          this.state = {
+            ...this.state,
+            progress: progress.progress,
+            currentStep: progress.step,
+            currentPlugin: progress.currentPlugin ?? null
+          };
+          this.emit();
+        }
+      );
+      this.state = {
+        ...this.state,
+        loading: false,
+        progress: 1,
+        currentStep: "Complete",
+        currentPlugin: null,
+        result,
+        lastUpdated: /* @__PURE__ */ new Date()
+      };
+      this.emit();
+      return result;
+    } catch (_error) {
+      this.state = {
+        ...this.state,
+        loading: false,
+        progress: 0,
+        currentStep: "Error occurred",
+        currentPlugin: null,
+        result: null
+      };
+      this.emit();
+      return null;
+    }
+  }
+  // ── Subscription ──────────────────────────────────────────────
+  subscribe(listener) {
+    this.listener = listener;
+    listener({ ...this.state });
+    return () => {
+      if (this.listener === listener) this.listener = null;
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  // ── Private ───────────────────────────────────────────────────
+  emit() {
+    this.listener?.({ ...this.state });
+  }
+};
+
+// src/network/gitProxyUrlPolicy.ts
+function ipv4Parts(host) {
+  const m = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  if (!m) return null;
+  return m.slice(1, 5).map((x) => Number(x));
+}
+function isPrivateOrLoopbackIpv4(host) {
+  const p = ipv4Parts(host);
+  if (!p || p.some((n) => n > 255)) return false;
+  const [a, b] = p;
+  if (a === 127 || a === 0) return true;
+  if (a === 10) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 169 && b === 254) return true;
+  return false;
+}
+function gitProxyTargetBlockReason(url) {
+  if (url.username || url.password) {
+    return "credentials_in_url";
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return "unsupported_protocol";
+  }
+  const host = url.hostname.toLowerCase();
+  if (host === "localhost" || host.endsWith(".localhost") || host === "0.0.0.0" || host === "[::]" || host === "::") {
+    return "loopback_or_wildcard";
+  }
+  if (host.startsWith("127.")) {
+    return "loopback_ipv4";
+  }
+  if (isPrivateOrLoopbackIpv4(host)) {
+    return "private_ipv4";
+  }
+  if (host.includes(":") && !host.startsWith("[")) {
+    const lower = host.toLowerCase();
+    if (lower.startsWith("fe80:") || lower.startsWith("fc") || lower.startsWith("fd")) {
+      return "private_ipv6";
+    }
+    if (lower === "::1") {
+      return "loopback_ipv6";
+    }
+  }
+  if (host.startsWith("[") && host.endsWith("]")) {
+    const inner = host.slice(1, -1).toLowerCase();
+    if (inner === "::1" || inner.startsWith("fe80:") || inner.startsWith("fc") || inner.startsWith("fd")) {
+      return "blocked_ipv6_literal";
+    }
+  }
+  const h = host.replace(/^\[|\]$/g, "").toLowerCase();
+  if (h === "metadata.google.internal" || h.endsWith(".internal")) {
+    return "internal_hostname";
+  }
+  return null;
+}
+
+// src/network/uri.ts
+var PREFIX = "memeloop://node/";
+function buildMemeloopFileUri(nodeId, filePath) {
+  const normalized = filePath.replace(/^\/+/, "");
+  const segments = normalized.split("/").filter(Boolean).map(encodeURIComponent);
+  return `memeloop://node/${encodeURIComponent(nodeId)}/file/${segments.join("/")}`;
+}
+var buildMemeloopUri = buildMemeloopFileUri;
+function parseMemeloopUri(uri) {
+  const u = uri.trim();
+  if (!u.startsWith(PREFIX)) return null;
+  const rest = u.slice(PREFIX.length);
+  const slash = rest.indexOf("/");
+  if (slash <= 0) return null;
+  let nodeId;
+  try {
+    nodeId = decodeURIComponent(rest.slice(0, slash));
+  } catch {
+    return null;
+  }
+  const afterNode = rest.slice(slash + 1);
+  if (!afterNode.startsWith("file/")) return null;
+  const pathPart = afterNode.slice("file/".length);
+  if (pathPart.length === 0) {
+    return { scheme: "memeloop", kind: "file", nodeId, filePath: "" };
+  }
+  try {
+    const filePath = pathPart.split("/").map(decodeURIComponent).join("/");
+    return { scheme: "memeloop", kind: "file", nodeId, filePath };
+  } catch {
+    return null;
+  }
+}
+
+// src/device-network/agentRuntimeRpcHandler.ts
+function createAgentRuntimeDeviceRpcHandler(options) {
+  return async ({ method, parameters }) => {
+    switch (method) {
+      case "memeloop.agent.getDefinitions":
+        return { definitions: await options.getAgentDefinitions?.() ?? [] };
+      case "memeloop.agent.create": {
+        const rpcParameters = objectParameter(parameters);
+        return options.runtime.createAgent({
+          definitionId: stringParameter(rpcParameters, "definitionId"),
+          initialMessage: optionalStringParameter(rpcParameters, "initialMessage")
+        });
+      }
+      case "memeloop.agent.send": {
+        const rpcParameters = objectParameter(parameters);
+        await options.runtime.sendMessage({
+          conversationId: stringParameter(rpcParameters, "conversationId"),
+          message: stringParameter(rpcParameters, "message"),
+          definitionId: optionalStringParameter(rpcParameters, "definitionId"),
+          userMessage: chatMessageParameter(rpcParameters, "userMessage"),
+          resumeSession: chatMessageArrayParameter(rpcParameters, "resumeSession")
+        });
+        return { ok: true };
+      }
+      case "memeloop.agent.runTurn": {
+        const rpcParameters = objectParameter(parameters);
+        const conversationId = stringParameter(rpcParameters, "conversationId");
+        const definitionId = stringParameter(rpcParameters, "definitionId");
+        await upsertConversationForRemoteTurn({
+          storage: options.storage,
+          conversationId,
+          definitionId,
+          conversation: conversationMetaParameter(rpcParameters, "conversation"),
+          localNodeId: options.localNodeId
+        });
+        await options.runtime.sendMessage({
+          conversationId,
+          definitionId,
+          message: stringParameter(rpcParameters, "message"),
+          userMessage: chatMessageParameter(rpcParameters, "userMessage"),
+          resumeSession: chatMessageArrayParameter(rpcParameters, "resumeSession")
+        });
+        return { ok: true, conversationId };
+      }
+      case "memeloop.agent.cancel": {
+        const rpcParameters = objectParameter(parameters);
+        await options.runtime.cancelAgent(stringParameter(rpcParameters, "conversationId"));
+        return { ok: true };
+      }
+      case "memeloop.chat.pullAgentRunLog": {
+        const rpcParameters = objectParameter(parameters);
+        const conversationId = stringParameter(rpcParameters, "conversationId");
+        const known = new Set(stringArrayParameter(rpcParameters, "knownMessageIds"));
+        const messages = await options.storage.getMessages(conversationId, { mode: "full-content" });
+        return { messages: messages.filter((message) => !known.has(message.messageId)) };
+      }
+      default:
+        throw new Error(`rpc_method_not_found:${method}`);
+    }
+  };
+}
+async function upsertConversationForRemoteTurn(input) {
+  if (input.conversation) {
+    await input.storage.upsertConversationMetadata(input.conversation);
+    return;
+  }
+  const existing = await input.storage.getConversationMeta(input.conversationId).catch(() => null);
+  if (existing) return;
+  const now = Date.now();
+  await input.storage.upsertConversationMetadata({
+    conversationId: input.conversationId,
+    title: input.definitionId,
+    lastMessagePreview: "",
+    lastMessageTimestamp: now,
+    messageCount: 0,
+    originNodeId: input.localNodeId ?? "remote",
+    definitionId: input.definitionId,
+    isUserInitiated: true
+  });
+}
+function objectParameter(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid_rpc_params");
+  return value;
+}
+function stringParameter(parameters, key) {
+  const value = parameters[key];
+  if (typeof value !== "string" || value.length === 0) throw new Error("invalid_rpc_params");
+  return value;
+}
+function optionalStringParameter(parameters, key) {
+  const value = parameters[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") throw new Error("invalid_rpc_params");
+  return value;
+}
+function stringArrayParameter(parameters, key) {
+  const value = parameters[key];
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) throw new Error("invalid_rpc_params");
+  return value.filter((item) => typeof item === "string");
+}
+function chatMessageParameter(parameters, key) {
+  const value = parameters[key];
+  if (value === void 0) return void 0;
+  if (!isChatMessage(value)) throw new Error("invalid_rpc_params");
+  return value;
+}
+function chatMessageArrayParameter(parameters, key) {
+  const value = parameters[key];
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) throw new Error("invalid_rpc_params");
+  return value.filter(isChatMessage);
+}
+function conversationMetaParameter(parameters, key) {
+  const value = parameters[key];
+  if (value === void 0) return void 0;
+  if (!isConversationMetaLike(value)) throw new Error("invalid_rpc_params");
+  return value;
+}
+function isChatMessage(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.messageId === "string" && typeof record.conversationId === "string" && typeof record.originNodeId === "string" && typeof record.timestamp === "number" && typeof record.lamportClock === "number" && typeof record.role === "string" && typeof record.content === "string";
+}
+function isConversationMetaLike(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.conversationId === "string" && typeof record.title === "string" && typeof record.lastMessageTimestamp === "number" && typeof record.messageCount === "number" && typeof record.originNodeId === "string" && typeof record.definitionId === "string" && typeof record.isUserInitiated === "boolean";
+}
+
+// src/device-network/libp2pDeviceNetworkService.ts
+import { noise } from "@chainsafe/libp2p-noise";
+import { yamux } from "@chainsafe/libp2p-yamux";
+import { bootstrap } from "@libp2p/bootstrap";
+import { circuitRelayTransport } from "@libp2p/circuit-relay-v2";
+import { identify } from "@libp2p/identify";
+import { mdns } from "@libp2p/mdns";
+import { peerIdFromPrivateKey, peerIdFromPublicKey, peerIdFromString } from "@libp2p/peer-id";
+import { ping } from "@libp2p/ping";
+import { tcp } from "@libp2p/tcp";
+import { webSockets } from "@libp2p/websockets";
+import { multiaddr } from "@multiformats/multiaddr";
+import { createLibp2p } from "libp2p";
+
+// src/device-network/libp2pSyncProtocol.ts
+var LIBP2P_SYNC_REQUEST_TYPE = "memeloop-sync-request-v1";
+var LIBP2P_SYNC_RESPONSE_TYPE = "memeloop-sync-response-v1";
+var syncMethods = /* @__PURE__ */ new Set([
+  "exchangeVersionVector",
+  "pullMissingMetadata",
+  "pullMissingMessages",
+  "pullAttachmentBlob"
+]);
+function isLibp2pSyncRequest(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record.type === LIBP2P_SYNC_REQUEST_TYPE && typeof record.id === "string" && typeof record.method === "string" && syncMethods.has(record.method);
+}
+function isLibp2pSyncResponse(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  if (record.type !== LIBP2P_SYNC_RESPONSE_TYPE || typeof record.id !== "string" || typeof record.ok !== "boolean") return false;
+  if (record.ok) return "result" in record;
+  return typeof record.error === "string";
+}
+function isAttachmentBlobWire(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.dataBase64Url === "string" && typeof record.filename === "string" && typeof record.mimeType === "string" && typeof record.size === "number";
+}
+async function attachmentBlobFromWire(value) {
+  if (value === null) return null;
+  if (!isAttachmentBlobWire(value)) throw new Error("invalid_sync_response");
+  const { fromString } = await import("uint8arrays");
+  return {
+    data: fromString(value.dataBase64Url, "base64url"),
+    filename: value.filename,
+    mimeType: value.mimeType,
+    size: value.size
+  };
+}
+
+// src/device-network/libp2pDeviceSyncTransport.ts
+var Libp2pDeviceSyncTransport = class {
+  nodeId;
+  deviceNetwork;
+  grantProvider;
+  constructor(options) {
+    this.nodeId = options.nodeId;
+    this.deviceNetwork = options.deviceNetwork;
+    this.grantProvider = options.grantProvider;
+  }
+  listPeers() {
+    return this.deviceNetwork.listDevices();
+  }
+  exchangeVersionVector(peerId, localVersion) {
+    return this.request(peerId, "exchangeVersionVector", { localVersion });
+  }
+  pullMissingMetadata(peerId, sinceVersion) {
+    return this.request(peerId, "pullMissingMetadata", { sinceVersion });
+  }
+  pullMissingMessages(peerId, conversationId, knownMessageIds) {
+    return this.request(peerId, "pullMissingMessages", { conversationId, knownMessageIds });
+  }
+  async pullAttachmentBlob(peerId, contentHash) {
+    const result = await this.request(peerId, "pullAttachmentBlob", { contentHash });
+    return attachmentBlobFromWire(result);
+  }
+  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 request = {
+      type: LIBP2P_SYNC_REQUEST_TYPE,
+      id: crypto.randomUUID(),
+      method,
+      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;
+  }
+};
+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";
+function isLibp2pRpcRequest(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record.type === LIBP2P_RPC_REQUEST_TYPE && typeof record.id === "string" && typeof record.method === "string";
+}
+function isLibp2pRpcResponse(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  if (record.type !== LIBP2P_RPC_RESPONSE_TYPE || typeof record.id !== "string" || typeof record.ok !== "boolean") return false;
+  if (record.ok) return "result" in record;
+  return typeof record.error === "string";
+}
+
+// src/device-network/localTrustDeviceAuthorizer.ts
+var PAIRING_PROTOCOL = "/memeloop/pairing/1.0.0";
+var LocalTrustDeviceAuthorizer = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.allowPairingProtocol = options.allowPairingProtocol ?? true;
+    for (const record of options.trustedDevices ?? []) {
+      this.trustedDevices.set(record.peerId, record);
+    }
+  }
+  trustedDevices = /* @__PURE__ */ new Map();
+  allowPairingProtocol;
+  setTrustedDevice(record) {
+    this.trustedDevices.set(record.peerId, record);
+  }
+  removeTrustedDevice(peerId) {
+    this.trustedDevices.delete(peerId);
+  }
+  async canOpenProtocol(input) {
+    const record = this.options.getTrustedDevice?.(input.remotePeerId) ?? this.trustedDevices.get(input.remotePeerId);
+    if (record?.revokedAt) return false;
+    if (input.protocol === PAIRING_PROTOCOL) return this.allowPairingProtocol;
+    return record !== void 0;
+  }
+};
+
+// src/device-network/libp2pDeviceNetworkService.ts
+var emptyCapabilities = {
+  tools: [],
+  mcpServers: [],
+  hasWiki: false,
+  agentLoop: false,
+  imChannels: [],
+  wikis: []
+};
+var defaultListen = {
+  addresses: ["/ip4/0.0.0.0/tcp/0", "/ip4/0.0.0.0/tcp/0/ws"]
+};
+var PAIRING_PROTOCOL2 = "/memeloop/pairing/1.0.0";
+var RPC_PROTOCOL = "/memeloop/rpc/1.0.0";
+var SYNC_PROTOCOL = "/memeloop/sync/1.0.0";
+var RELAY_ADMISSION_PROTOCOL = "/memeloop/relay-admission/1.0.0";
+var PAIRING_SESSION_TTL_MS = 5 * 6e4;
+var PAIRING_MESSAGE_MAX_BYTES = 64 * 1024;
+var RPC_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
+var SYNC_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
+var RELAY_ADMISSION_MESSAGE_MAX_BYTES = 64 * 1024;
+var RELAY_ADMISSION_REQUEST_TYPE = "memeloop-relay-admission-request-v1";
+var RELAY_ADMISSION_RESPONSE_TYPE = "memeloop-relay-admission-response-v1";
+var Libp2pDeviceNetworkService = class {
+  constructor(options) {
+    this.options = options;
+    this.capabilities = options.capabilities ?? emptyCapabilities;
+    for (const record of options.trustedDevices ?? []) {
+      this.trustedDevices.set(record.peerId, record);
+    }
+    for (const address of options.bootstrapMultiaddrs ?? []) {
+      const trimmed = address.trim();
+      if (trimmed) this.bootstrapMultiaddrs.add(trimmed);
+    }
+    this.authorizer = options.authorizer ?? new LocalTrustDeviceAuthorizer({
+      getTrustedDevice: (peerId) => this.trustedDevices.get(peerId)
+    });
+  }
+  libp2p;
+  capabilities;
+  discoveredDevices = /* @__PURE__ */ new Map();
+  trustedDevices = /* @__PURE__ */ new Map();
+  bootstrapMultiaddrs = /* @__PURE__ */ new Set();
+  authorizer;
+  pairingSessions = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  pairingListeners = /* @__PURE__ */ new Set();
+  async start() {
+    if (this.libp2p) return;
+    await this.loadTrustedDevicesFromStore();
+    this.libp2p = await this.createNode();
+    this.registerDiscoveryListeners(this.libp2p);
+    await this.registerProtocolHandlers(this.libp2p);
+    await this.libp2p.start();
+    this.emitDevices();
+  }
+  async stop() {
+    if (!this.libp2p) return;
+    await this.libp2p.stop();
+    this.libp2p = void 0;
+    this.discoveredDevices.clear();
+    this.emitDevices();
+  }
+  async getLocalDevice() {
+    const node = this.requireNode();
+    return {
+      peerId: node.peerId.toString(),
+      displayName: this.options.identity.deviceName,
+      platform: this.options.identity.platform,
+      trustMode: "local-pairing",
+      reachability: {
+        state: node.status === "started" ? "online" : "offline",
+        paths: node.status === "started" ? ["lan"] : []
+      },
+      capabilities: this.capabilities,
+      multiaddrs: this.getMultiaddrs(),
+      lastSeen: Date.now()
+    };
+  }
+  async listDevices() {
+    return this.toVisibleDevices();
+  }
+  observeDevices(listener) {
+    this.listeners.add(listener);
+    void this.listDevices().then(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async listPairingSessions() {
+    this.refreshPairingSessionExpiry();
+    return [...this.pairingSessions.values()];
+  }
+  observePairingSessions(listener) {
+    this.pairingListeners.add(listener);
+    void this.listPairingSessions().then(listener);
+    return () => {
+      this.pairingListeners.delete(listener);
+    };
+  }
+  async requestLocalPairing(peerId, options = {}) {
+    const requestNonce = randomPairingNonce();
+    const createdAt = Date.now();
+    const expiresAt = createdAt + PAIRING_SESSION_TTL_MS;
+    const request = {
+      type: "memeloop-local-pairing-request-v1",
+      sessionId: `pairing-${this.options.identity.peerId}-${peerId}-${createdAt}-${requestNonce}`,
+      requestNonce,
+      createdAt,
+      expiresAt,
+      device: this.localPairingDevice()
+    };
+    const stream = await this.requireNode().dialProtocol(this.pairingDialTarget(peerId, options), PAIRING_PROTOCOL2);
+    try {
+      await writeJsonMessage(stream, request);
+      const response = await readJsonMessage(stream);
+      await stream.close();
+      const session = await this.sessionFromPairingResponse(peerId, request, response);
+      this.pairingSessions.set(session.sessionId, session);
+      this.upsertDiscoveredDeviceFromPairing(session.remotePeerId, response.device);
+      this.emitPairingSessions();
+      this.emitDevices();
+      return session;
+    } catch (error2) {
+      stream.abort(error2 instanceof Error ? error2 : new Error("pairing_request_failed"));
+      throw error2;
+    }
+  }
+  async acceptPairing(sessionId) {
+    const session = this.requirePairingSession(sessionId);
+    if (session.expiresAt < Date.now()) {
+      session.status = "expired";
+      this.emitPairingSessions();
+      throw new Error("pairing_session_expired");
+    }
+    if (session.status !== "pending") throw new Error("pairing_session_not_pending");
+    const trustedDevice = {
+      peerId: session.remotePeerId,
+      publicKeyMultibase: session.remotePublicKeyMultibase,
+      deviceName: session.remoteDeviceName,
+      platform: session.remotePlatform,
+      trustMode: "local-pairing",
+      createdAt: Date.now(),
+      lastSeen: Date.now()
+    };
+    this.trustedDevices.set(session.remotePeerId, trustedDevice);
+    await this.options.trustStore?.saveTrustedDevice(trustedDevice);
+    session.status = "accepted";
+    this.updateDeviceTrust(session.remotePeerId, "local-pairing", true);
+    this.emitPairingSessions();
+    this.emitDevices();
+  }
+  async rejectPairing(sessionId) {
+    const session = this.pairingSessions.get(sessionId);
+    if (!session) return;
+    session.status = "rejected";
+    this.emitPairingSessions();
+  }
+  async removeTrustedDevice(peerId) {
+    this.trustedDevices.delete(peerId);
+    await this.options.trustStore?.removeTrustedDevice(peerId);
+    this.updateDeviceTrust(peerId, "local-pairing", false);
+    this.emitDevices();
+  }
+  async openStream(peerId, protocol, presentedGrant) {
+    const authorized = await this.authorizer.canOpenProtocol({
+      remotePeerId: peerId,
+      protocol,
+      direction: "outbound",
+      presentedGrant
+    });
+    if (!authorized) throw new Error("device_not_trusted");
+    const addresses = this.discoveredDevices.get(peerId)?.multiaddrs ?? [];
+    const dialTarget = addresses.length > 0 ? addresses.map((address) => multiaddr(address)) : peerIdFromString(peerId);
+    const stream = await this.requireNode().dialProtocol(dialTarget, protocol, {
+      runOnLimitedConnection: true
+    });
+    return this.wrapStream(stream);
+  }
+  async sendRpc(peerId, method, parameters, presentedGrant) {
+    const stream = await this.openStream(peerId, RPC_PROTOCOL, presentedGrant);
+    const request = {
+      type: LIBP2P_RPC_REQUEST_TYPE,
+      id: crypto.randomUUID(),
+      method,
+      params: parameters,
+      grant: presentedGrant
+    };
+    await writeStreamJson(stream, request);
+    const response = await readStreamJson(stream);
+    await stream.close();
+    if (!isLibp2pRpcResponse(response)) throw new Error("invalid_rpc_response");
+    if (response.id !== request.id) throw new Error("rpc_response_id_mismatch");
+    if (!response.ok) throw new Error(response.error);
+    return response.result;
+  }
+  async syncWithDevice(peerId, presentedGrant) {
+    const authorized = await this.authorizer.canOpenProtocol({
+      remotePeerId: peerId,
+      protocol: "/memeloop/sync/1.0.0",
+      direction: "outbound",
+      presentedGrant
+    });
+    if (!authorized) throw new Error("device_not_trusted");
+    if (this.options.syncStorage) {
+      const transport = new Libp2pDeviceSyncTransport({
+        nodeId: this.options.identity.peerId,
+        deviceNetwork: this,
+        grantProvider: async (remotePeerId) => remotePeerId === peerId ? presentedGrant : void 0
+      });
+      const peer = new PeerNodeSyncAdapter(peerId, transport);
+      const engine = new ChatSyncEngine({
+        nodeId: this.options.identity.peerId,
+        storage: this.options.syncStorage,
+        peers: () => [peer]
+      });
+      await engine.syncOnce();
+    }
+    return { ok: true, peerId, syncedAt: Date.now() };
+  }
+  getTrustedDevice(peerId) {
+    return this.trustedDevices.get(peerId);
+  }
+  upsertTrustedDevice(record) {
+    this.trustedDevices.set(record.peerId, record);
+    this.updateDeviceTrust(record.peerId, record.trustMode, true);
+    this.emitDevices();
+  }
+  upsertDiscoveredDevice(device) {
+    const trustedRecord = this.trustedDevices.get(device.peerId);
+    this.discoveredDevices.set(device.peerId, {
+      ...device,
+      displayName: trustedRecord?.deviceName ?? device.displayName,
+      platform: trustedRecord?.platform ?? device.platform,
+      trustMode: trustedRecord?.trustMode ?? device.trustMode,
+      trusted: device.trusted ?? trustedRecord !== void 0,
+      lastSeen: device.lastSeen ?? trustedRecord?.lastSeen
+    });
+    this.emitDevices();
+  }
+  async configureRelayReservation(token) {
+    for (const address of [...token.bootstrapMultiaddrs, ...token.relayMultiaddrs]) {
+      const trimmed = address.trim();
+      if (trimmed) this.bootstrapMultiaddrs.add(trimmed);
+    }
+    if (!this.libp2p) return;
+    await this.admitRelayReservation(token);
+    await this.reserveRelayListeners(token.relayMultiaddrs);
+    await this.dialBootstrapPeers([...this.bootstrapMultiaddrs]);
+  }
+  getMultiaddrs() {
+    return this.libp2p?.getMultiaddrs().map((address) => address.toString()) ?? [];
+  }
+  async createNode() {
+    const privateKey = await privateKeyFromIdentity(this.options.identity);
+    const listen = this.options.listen ?? defaultListen;
+    const peerDiscovery = [
+      ...this.createBootstrapDiscovery(),
+      ...this.options.enableMdns === false ? [] : [mdns({ serviceTag: "memeloop" })]
+    ];
+    const transports = this.options.enableCircuitRelay === false ? [tcp(), webSockets()] : [tcp(), webSockets(), circuitRelayTransport()];
+    return createLibp2p({
+      privateKey,
+      addresses: {
+        listen: this.options.enableCircuitRelay === false ? listen.addresses : addRelayListenAddress(listen.addresses),
+        announce: listen.announce
+      },
+      transports,
+      connectionEncrypters: [noise()],
+      streamMuxers: [yamux()],
+      peerDiscovery,
+      services: {
+        identify: identify(),
+        ping: ping()
+      },
+      start: false
+    });
+  }
+  createBootstrapDiscovery() {
+    const list = [...this.bootstrapMultiaddrs];
+    if (list.length === 0) return [];
+    return [bootstrap({ list, tagName: "memeloop-bootstrap", tagTTL: Infinity })];
+  }
+  async dialBootstrapPeers(addresses) {
+    const node = this.requireNode();
+    for (const address of addresses) {
+      await node.dial(multiaddr(address)).catch(() => void 0);
+    }
+  }
+  async admitRelayReservation(token) {
+    const relayAddresses = token.relayMultiaddrs.map((address) => address.trim()).filter((address) => address.length > 0);
+    if (relayAddresses.length === 0) return;
+    const node = this.requireNode();
+    const errors = [];
+    for (const address of relayAddresses) {
+      let stream;
+      try {
+        stream = await node.dialProtocol(multiaddr(address), RELAY_ADMISSION_PROTOCOL);
+        const request = {
+          type: RELAY_ADMISSION_REQUEST_TYPE,
+          token
+        };
+        await writeJsonMessage(stream, request, RELAY_ADMISSION_MESSAGE_MAX_BYTES);
+        const response = await readJsonMessage(stream, RELAY_ADMISSION_MESSAGE_MAX_BYTES);
+        await stream.close();
+        if (isRelayAdmissionResponse(response) && response.ok) return;
+        const reason = isRelayAdmissionResponse(response) ? response.reason : "invalid_relay_admission_response";
+        errors.push(`${address}: ${reason}`);
+      } catch (error2) {
+        stream?.abort(error2 instanceof Error ? error2 : new Error("relay_admission_failed"));
+        errors.push(`${address}: ${error2 instanceof Error ? error2.message : "relay_admission_failed"}`);
+      }
+    }
+    throw new Error(`relay_admission_failed${errors.length > 0 ? `: ${errors.join("; ")}` : ""}`);
+  }
+  async reserveRelayListeners(relayMultiaddrs) {
+    const relayAddresses = relayMultiaddrs.map((address) => address.trim()).filter((address) => address.length > 0);
+    if (relayAddresses.length === 0) return;
+    const transportManager = this.requireNode().components?.transportManager;
+    if (!transportManager) throw new Error("relay_transport_manager_unavailable");
+    const errors = [];
+    for (const address of relayAddresses) {
+      try {
+        await transportManager.listen([relayCircuitMultiaddr(address)]);
+        return;
+      } catch (error2) {
+        errors.push(`${address}: ${error2 instanceof Error ? error2.message : "relay_reservation_failed"}`);
+      }
+    }
+    throw new Error(`relay_reservation_failed${errors.length > 0 ? `: ${errors.join("; ")}` : ""}`);
+  }
+  async loadTrustedDevicesFromStore() {
+    const records = await this.options.trustStore?.loadTrustedDevices();
+    for (const record of records ?? []) {
+      this.trustedDevices.set(record.peerId, record);
+    }
+  }
+  registerDiscoveryListeners(node) {
+    node.addEventListener("peer:discovery", (event) => {
+      const detail = event.detail;
+      const peerId = detail.id.toString();
+      const trustedRecord = this.trustedDevices.get(peerId);
+      this.discoveredDevices.set(peerId, {
+        peerId,
+        displayName: trustedRecord?.deviceName ?? peerId,
+        platform: trustedRecord?.platform ?? "cli",
+        trustMode: trustedRecord?.trustMode ?? "local-pairing",
+        trusted: trustedRecord !== void 0,
+        reachability: {
+          state: "nearby",
+          paths: ["lan"]
+        },
+        capabilities: emptyCapabilities,
+        multiaddrs: detail.multiaddrs.map((address) => address.toString()),
+        lastSeen: Date.now()
+      });
+      this.emitDevices();
+      if (this.options.autoDialDiscoveredPeers === true && detail.multiaddrs.length > 0) {
+        void node.dial(detail.multiaddrs).catch(() => void 0);
+      }
+    });
+    node.addEventListener("peer:connect", (event) => {
+      this.markPeerOnline(event.detail);
+    });
+    node.addEventListener("peer:disconnect", (event) => {
+      this.markPeerOffline(event.detail);
+    });
+  }
+  async registerProtocolHandlers(node) {
+    const protocols = [
+      "/memeloop/pairing/1.0.0",
+      "/memeloop/rpc/1.0.0",
+      "/memeloop/sync/1.0.0",
+      "/memeloop/agent/1.0.0"
+    ];
+    await node.handle(protocols, async (stream, connection) => {
+      const remotePeerId = connection.remotePeer.toString();
+      if (stream.protocol === PAIRING_PROTOCOL2) {
+        if (!await this.authorizer.canOpenProtocol({ remotePeerId, protocol: PAIRING_PROTOCOL2, direction: "inbound" })) {
+          stream.abort(new Error("device_not_trusted"));
+          return;
+        }
+        await this.handlePairingStream(stream, remotePeerId).catch((error2) => {
+          stream.abort(error2 instanceof Error ? error2 : new Error("pairing_handler_failed"));
+        });
+        return;
+      }
+      if (stream.protocol === SYNC_PROTOCOL) {
+        await this.handleSyncStream(stream, remotePeerId);
+        return;
+      }
+      if (stream.protocol === RPC_PROTOCOL) {
+        await this.handleRpcStream(stream, remotePeerId);
+        return;
+      }
+      if (!await this.authorizer.canOpenProtocol({ remotePeerId, protocol: stream.protocol, direction: "inbound" })) {
+        stream.abort(new Error("device_not_trusted"));
+        return;
+      }
+      stream.abort(new Error("protocol_handler_not_registered"));
+    }, {
+      runOnLimitedConnection: true
+    });
+  }
+  async handleRpcStream(stream, remotePeerId) {
+    let requestId = "unknown";
+    try {
+      const request = await readJsonMessage(stream, RPC_MESSAGE_MAX_BYTES);
+      if (!isLibp2pRpcRequest(request)) throw new Error("invalid_rpc_request");
+      requestId = request.id;
+      const authorized = await this.authorizer.canOpenProtocol({
+        remotePeerId,
+        protocol: RPC_PROTOCOL,
+        direction: "inbound",
+        presentedGrant: request.grant
+      });
+      if (!authorized) throw new Error("device_not_trusted");
+      if (!this.options.rpcHandler) throw new Error("rpc_handler_not_configured");
+      const result = await this.options.rpcHandler({
+        remotePeerId,
+        method: request.method,
+        parameters: request.params,
+        presentedGrant: request.grant
+      });
+      await writeJsonMessage(stream, {
+        type: LIBP2P_RPC_RESPONSE_TYPE,
+        id: request.id,
+        ok: true,
+        result
+      }, RPC_MESSAGE_MAX_BYTES);
+    } catch (error2) {
+      await writeJsonMessage(stream, {
+        type: LIBP2P_RPC_RESPONSE_TYPE,
+        id: requestId,
+        ok: false,
+        error: error2 instanceof Error ? error2.message : "rpc_handler_failed"
+      }, RPC_MESSAGE_MAX_BYTES).catch(() => void 0);
+    } finally {
+      await stream.close().catch(() => void 0);
+    }
+  }
+  async handleSyncStream(stream, remotePeerId) {
+    let requestId = "unknown";
+    try {
+      const request = await readJsonMessage(stream, SYNC_MESSAGE_MAX_BYTES);
+      if (!isLibp2pSyncRequest(request)) throw new Error("invalid_sync_request");
+      requestId = request.id;
+      const authorized = await this.authorizer.canOpenProtocol({
+        remotePeerId,
+        protocol: SYNC_PROTOCOL,
+        direction: "inbound",
+        presentedGrant: request.grant
+      });
+      if (!authorized) throw new Error("device_not_trusted");
+      const result = await this.handleSyncRequest(request);
+      await writeJsonMessage(stream, {
+        type: LIBP2P_SYNC_RESPONSE_TYPE,
+        id: request.id,
+        ok: true,
+        result
+      }, SYNC_MESSAGE_MAX_BYTES);
+    } catch (error2) {
+      await writeJsonMessage(stream, {
+        type: LIBP2P_SYNC_RESPONSE_TYPE,
+        id: requestId,
+        ok: false,
+        error: error2 instanceof Error ? error2.message : "sync_handler_failed"
+      }, SYNC_MESSAGE_MAX_BYTES).catch(() => void 0);
+    } finally {
+      await stream.close().catch(() => void 0);
+    }
+  }
+  async handleSyncRequest(request) {
+    const storage = this.options.syncStorage;
+    if (!storage) throw new Error("sync_storage_not_configured");
+    switch (request.method) {
+      case "exchangeVersionVector":
+        return {
+          remoteVersion: this.options.syncVersionVector?.() ?? {},
+          missingForRemote: []
+        };
+      case "pullMissingMetadata": {
+        const sinceVersion = versionVectorParameter(request.params, "sinceVersion");
+        const conversations = await storage.listConversations({ limit: 500 });
+        return conversations.filter((conversation) => shouldSendConversation(conversation, sinceVersion));
+      }
+      case "pullMissingMessages": {
+        const parameters = objectParameter2(request.params);
+        const conversationId = stringParameter2(parameters, "conversationId");
+        const knownMessageIds = stringArrayParameter2(parameters, "knownMessageIds");
+        const messages = await storage.getMessages(conversationId, { mode: "full-content" });
+        const known = new Set(knownMessageIds);
+        return messages.filter((message) => !known.has(message.messageId));
+      }
+      case "pullAttachmentBlob": {
+        const parameters = objectParameter2(request.params);
+        const contentHash = stringParameter2(parameters, "contentHash");
+        return this.readAttachmentBlob(contentHash);
+      }
+    }
+  }
+  async readAttachmentBlob(contentHash) {
+    const storage = this.options.syncStorage;
+    if (!storage?.readAttachmentData) return null;
+    const reference = await storage.getAttachment(contentHash);
+    if (!reference) return null;
+    const data = await storage.readAttachmentData(contentHash);
+    if (!data) return null;
+    const { toString } = await loadUint8arrays();
+    return {
+      dataBase64Url: toString(data, "base64url"),
+      filename: reference.filename,
+      mimeType: reference.mimeType,
+      size: reference.size
+    };
+  }
+  pairingDialTarget(peerId, options) {
+    const addresses = options.multiaddrs ?? this.discoveredDevices.get(peerId)?.multiaddrs ?? [];
+    if (addresses.length === 0) return peerIdFromString(peerId);
+    return addresses.map((address) => multiaddr(address));
+  }
+  localPairingDevice() {
+    return {
+      peerId: this.options.identity.peerId,
+      publicKeyMultibase: this.options.identity.publicKeyMultibase,
+      deviceName: this.options.identity.deviceName,
+      platform: this.options.identity.platform,
+      capabilities: this.capabilities,
+      multiaddrs: this.getMultiaddrs()
+    };
+  }
+  async handlePairingStream(stream, remotePeerId) {
+    const request = await readJsonMessage(stream);
+    if (!isPairingRequest(request)) throw new Error("invalid_pairing_request");
+    if (request.device.peerId !== remotePeerId) throw new Error("pairing_peer_id_mismatch");
+    if (request.expiresAt <= Date.now()) throw new Error("pairing_request_expired");
+    await assertPairingDeviceIdentity(request.device);
+    const responseNonce = randomPairingNonce();
+    const localDevice = this.localPairingDevice();
+    const expiresAt = Math.min(request.expiresAt, Date.now() + PAIRING_SESSION_TTL_MS);
+    const session = {
+      sessionId: request.sessionId,
+      localPeerId: this.options.identity.peerId,
+      remotePeerId: request.device.peerId,
+      remotePublicKeyMultibase: request.device.publicKeyMultibase,
+      remoteDeviceName: request.device.deviceName,
+      remotePlatform: request.device.platform,
+      remoteCapabilities: request.device.capabilities,
+      remoteMultiaddrs: request.device.multiaddrs,
+      direction: "inbound",
+      status: "pending",
+      confirmCode: await buildPairingConfirmCode({
+        initiator: request.device,
+        responder: localDevice,
+        requestNonce: request.requestNonce,
+        responseNonce
+      }),
+      createdAt: Date.now(),
+      expiresAt
+    };
+    this.pairingSessions.set(session.sessionId, session);
+    this.upsertDiscoveredDeviceFromPairing(session.remotePeerId, request.device);
+    await writeJsonMessage(stream, {
+      type: "memeloop-local-pairing-response-v1",
+      sessionId: request.sessionId,
+      requestNonce: request.requestNonce,
+      responseNonce,
+      accepted: true,
+      expiresAt,
+      device: localDevice
+    });
+    await stream.close();
+    this.emitPairingSessions();
+    this.emitDevices();
+  }
+  async sessionFromPairingResponse(peerId, request, response) {
+    if (!isPairingResponse(response)) throw new Error("invalid_pairing_response");
+    if (response.sessionId !== request.sessionId) throw new Error("pairing_session_mismatch");
+    if (response.requestNonce !== request.requestNonce) throw new Error("pairing_nonce_mismatch");
+    if (response.device.peerId !== peerId) throw new Error("pairing_peer_id_mismatch");
+    if (response.expiresAt <= Date.now()) throw new Error("pairing_response_expired");
+    await assertPairingDeviceIdentity(response.device);
+    return {
+      sessionId: request.sessionId,
+      localPeerId: this.options.identity.peerId,
+      remotePeerId: response.device.peerId,
+      remotePublicKeyMultibase: response.device.publicKeyMultibase,
+      remoteDeviceName: response.device.deviceName,
+      remotePlatform: response.device.platform,
+      remoteCapabilities: response.device.capabilities,
+      remoteMultiaddrs: response.device.multiaddrs,
+      direction: "outbound",
+      status: "pending",
+      confirmCode: await buildPairingConfirmCode({
+        initiator: request.device,
+        responder: response.device,
+        requestNonce: request.requestNonce,
+        responseNonce: response.responseNonce
+      }),
+      createdAt: request.createdAt,
+      expiresAt: Math.min(request.expiresAt, response.expiresAt)
+    };
+  }
+  requirePairingSession(sessionId) {
+    const session = this.pairingSessions.get(sessionId);
+    if (!session) throw new Error("pairing_session_not_found");
+    return session;
+  }
+  refreshPairingSessionExpiry() {
+    const now = Date.now();
+    let changed = false;
+    for (const session of this.pairingSessions.values()) {
+      if (session.status === "pending" && session.expiresAt <= now) {
+        session.status = "expired";
+        changed = true;
+      }
+    }
+    if (changed) this.emitPairingSessions();
+  }
+  upsertDiscoveredDeviceFromPairing(peerId, device) {
+    const current = this.discoveredDevices.get(peerId);
+    this.discoveredDevices.set(peerId, {
+      peerId,
+      displayName: device.deviceName,
+      platform: device.platform,
+      trustMode: current?.trustMode ?? "local-pairing",
+      trusted: current?.trusted ?? this.trustedDevices.has(peerId),
+      reachability: current?.reachability ?? {
+        state: "nearby",
+        paths: device.multiaddrs.length > 0 ? ["lan"] : []
+      },
+      capabilities: device.capabilities,
+      multiaddrs: device.multiaddrs,
+      lastSeen: Date.now()
+    });
+  }
+  wrapStream(stream) {
+    return {
+      source: this.streamSource(stream),
+      async sink(source) {
+        for await (const chunk of source) {
+          stream.send(chunk);
+        }
+        await stream.close();
+      },
+      close: async () => {
+        await stream.close();
+      }
+    };
+  }
+  async *streamSource(stream) {
+    for await (const chunk of stream) {
+      if (chunk instanceof Uint8Array) {
+        yield chunk;
+      } else {
+        yield chunk.subarray();
+      }
+    }
+  }
+  markPeerOnline(peerId) {
+    const id = peerId.toString();
+    const current = this.discoveredDevices.get(id);
+    if (current) {
+      current.reachability = { state: "online", paths: current.reachability.paths };
+      current.lastSeen = Date.now();
+      this.emitDevices();
+    }
+  }
+  markPeerOffline(peerId) {
+    const id = peerId.toString();
+    const current = this.discoveredDevices.get(id);
+    if (current) {
+      current.reachability = { state: "offline", paths: [] };
+      current.lastSeen = Date.now();
+      this.emitDevices();
+    }
+  }
+  updateDeviceTrust(peerId, trustMode, trusted) {
+    const current = this.discoveredDevices.get(peerId);
+    if (current) {
+      this.discoveredDevices.set(peerId, {
+        ...current,
+        trustMode,
+        trusted
+      });
+    }
+  }
+  toVisibleDevices() {
+    const visible = new Map(this.discoveredDevices);
+    for (const record of this.trustedDevices.values()) {
+      const current = visible.get(record.peerId);
+      if (current) {
+        visible.set(record.peerId, {
+          ...current,
+          displayName: record.deviceName,
+          platform: record.platform,
+          trustMode: record.trustMode,
+          trusted: !record.revokedAt,
+          lastSeen: current.lastSeen ?? record.lastSeen
+        });
+        continue;
+      }
+      if (record.revokedAt) continue;
+      visible.set(record.peerId, {
+        peerId: record.peerId,
+        displayName: record.deviceName,
+        platform: record.platform,
+        trustMode: record.trustMode,
+        trusted: true,
+        reachability: {
+          state: "offline",
+          paths: []
+        },
+        capabilities: emptyCapabilities,
+        lastSeen: record.lastSeen
+      });
+    }
+    return [...visible.values()];
+  }
+  emitDevices() {
+    const devices = this.toVisibleDevices();
+    for (const listener of this.listeners) listener(devices);
+  }
+  emitPairingSessions() {
+    const sessions = [...this.pairingSessions.values()];
+    for (const listener of this.pairingListeners) listener(sessions);
+  }
+  requireNode() {
+    if (!this.libp2p) throw new Error("device_network_not_started");
+    return this.libp2p;
+  }
+};
+var PUBLIC_KEY_MULTIBASE_PREFIX = "libp2p-pub:";
+async function loadCryptoKeys() {
+  return import("@libp2p/crypto/keys");
+}
+async function loadUint8arrays() {
+  return import("uint8arrays");
+}
+function randomPairingNonce() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function writeJsonMessage(stream, message, maxBytes = PAIRING_MESSAGE_MAX_BYTES) {
+  const payload = new TextEncoder().encode(JSON.stringify(message));
+  if (payload.byteLength > maxBytes) throw new Error("json_message_too_large");
+  stream.send(payload);
+}
+async function readJsonMessage(stream, maxBytes = PAIRING_MESSAGE_MAX_BYTES) {
+  const reader = stream[Symbol.asyncIterator]();
+  const result = await reader.next();
+  if (result.done || !result.value) throw new Error("pairing_message_missing");
+  const chunk = result.value instanceof Uint8Array ? result.value : result.value.subarray();
+  if (chunk.byteLength > maxBytes) throw new Error("json_message_too_large");
+  return JSON.parse(new TextDecoder().decode(chunk));
+}
+async function writeStreamJson(stream, message) {
+  const payload = new TextEncoder().encode(JSON.stringify(message));
+  await stream.sink((async function* () {
+    yield payload;
+  })());
+}
+async function readStreamJson(stream) {
+  const reader = stream.source[Symbol.asyncIterator]();
+  const result = await reader.next();
+  if (result.done || !result.value) throw new Error("rpc_response_missing");
+  return JSON.parse(new TextDecoder().decode(result.value));
+}
+function isRelayAdmissionResponse(value) {
+  if (value === null || typeof value !== "object") return false;
+  const record = value;
+  return record.type === RELAY_ADMISSION_RESPONSE_TYPE && typeof record.ok === "boolean";
+}
+function relayCircuitMultiaddr(address) {
+  const parsed = multiaddr(address);
+  return address.includes("/p2p-circuit") ? parsed : parsed.encapsulate("/p2p-circuit");
+}
+function objectParameter2(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid_sync_params");
+  return value;
+}
+function stringParameter2(parameters, key) {
+  const value = parameters[key];
+  if (typeof value !== "string" || value.length === 0) throw new Error("invalid_sync_params");
+  return value;
+}
+function stringArrayParameter2(parameters, key) {
+  const value = parameters[key];
+  if (!Array.isArray(value)) throw new Error("invalid_sync_params");
+  return value.filter((item) => typeof item === "string");
+}
+function versionVectorParameter(parameters, key) {
+  const raw = objectParameter2(parameters)[key];
+  if (raw === void 0) return {};
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error("invalid_sync_params");
+  const version = {};
+  for (const [nodeId, clock] of Object.entries(raw)) {
+    if (typeof clock === "number" && Number.isFinite(clock) && clock >= 0) version[nodeId] = clock;
+  }
+  return version;
+}
+function shouldSendConversation(conversation, sinceVersion) {
+  const clock = Math.max(1, conversation.messageCount);
+  return (sinceVersion[conversation.originNodeId] ?? 0) < clock;
+}
+function isDevicePlatform(value) {
+  return value === "desktop" || value === "mobile" || value === "cli";
+}
+function normalizePairingCapabilities(value) {
+  const raw = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  return {
+    tools: Array.isArray(raw.tools) ? raw.tools.filter((item) => typeof item === "string") : [],
+    mcpServers: Array.isArray(raw.mcpServers) ? raw.mcpServers.filter((item) => typeof item === "string") : [],
+    hasWiki: raw.hasWiki === true,
+    agentLoop: raw.agentLoop === true,
+    imChannels: Array.isArray(raw.imChannels) ? raw.imChannels.filter((item) => typeof item === "string") : [],
+    wikis: Array.isArray(raw.wikis) ? raw.wikis.filter((item) => item !== null && typeof item === "object") : []
+  };
+}
+function normalizePairingDevice(value) {
+  const raw = value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+  if (!raw) return void 0;
+  const peerId = typeof raw.peerId === "string" ? raw.peerId.trim() : "";
+  const publicKeyMultibase = typeof raw.publicKeyMultibase === "string" ? raw.publicKeyMultibase.trim() : "";
+  const deviceName = typeof raw.deviceName === "string" ? raw.deviceName.trim() : "";
+  if (!peerId || !publicKeyMultibase || !deviceName || !isDevicePlatform(raw.platform)) return void 0;
+  return {
+    peerId,
+    publicKeyMultibase,
+    deviceName,
+    platform: raw.platform,
+    capabilities: normalizePairingCapabilities(raw.capabilities),
+    multiaddrs: Array.isArray(raw.multiaddrs) ? raw.multiaddrs.filter((item) => typeof item === "string") : []
+  };
+}
+function isPairingRequest(value) {
+  const raw = value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+  if (!raw || raw.type !== "memeloop-local-pairing-request-v1") return false;
+  return typeof raw.sessionId === "string" && typeof raw.requestNonce === "string" && typeof raw.createdAt === "number" && typeof raw.expiresAt === "number" && normalizePairingDevice(raw.device) !== void 0;
+}
+function isPairingResponse(value) {
+  const raw = value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+  if (!raw || raw.type !== "memeloop-local-pairing-response-v1") return false;
+  return typeof raw.sessionId === "string" && typeof raw.requestNonce === "string" && typeof raw.responseNonce === "string" && raw.accepted === true && typeof raw.expiresAt === "number" && normalizePairingDevice(raw.device) !== void 0;
+}
+async function assertPairingDeviceIdentity(device) {
+  const publicKey = await decodePublicKeyMultibase(device.publicKeyMultibase);
+  if (peerIdFromPublicKey(publicKey).toString() !== device.peerId) throw new Error("pairing_public_key_peer_id_mismatch");
+}
+async function buildPairingConfirmCode(input) {
+  const text = [
+    "memeloop-local-pairing-confirm-v1",
+    `initiatorPeerId=${input.initiator.peerId}`,
+    `initiatorPublicKey=${input.initiator.publicKeyMultibase}`,
+    `responderPeerId=${input.responder.peerId}`,
+    `responderPublicKey=${input.responder.publicKeyMultibase}`,
+    `requestNonce=${input.requestNonce}`,
+    `responseNonce=${input.responseNonce}`
+  ].join("\n");
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  const bytes = new Uint8Array(digest);
+  const value = (bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3]) >>> 0;
+  return (value % 1e6).toString().padStart(6, "0");
+}
+async function encodePublicKeyMultibase(publicKey) {
+  const { publicKeyToProtobuf } = await loadCryptoKeys();
+  const { toString } = await loadUint8arrays();
+  const protobuf = publicKeyToProtobuf(publicKey);
+  return `${PUBLIC_KEY_MULTIBASE_PREFIX}${toString(protobuf, "base64url")}`;
+}
+async function decodePublicKeyMultibase(multibase) {
+  if (!multibase.startsWith(PUBLIC_KEY_MULTIBASE_PREFIX)) {
+    throw new Error("unsupported_public_key_multibase_prefix");
+  }
+  const { publicKeyFromProtobuf } = await loadCryptoKeys();
+  const { fromString } = await loadUint8arrays();
+  const encoded = multibase.slice(PUBLIC_KEY_MULTIBASE_PREFIX.length);
+  const protobuf = fromString(encoded, "base64url");
+  return publicKeyFromProtobuf(protobuf);
+}
+async function createDeviceIdentity(platform, deviceName) {
+  const { generateKeyPair } = await loadCryptoKeys();
+  const { toString } = await loadUint8arrays();
+  const privateKey = await generateKeyPair("Ed25519");
+  const publicKey = privateKey.publicKey;
+  return {
+    peerId: peerIdFromPrivateKey(privateKey).toString(),
+    publicKeyMultibase: await encodePublicKeyMultibase(publicKey),
+    privateKeyRef: "libp2p-raw-seed",
+    privateKeyRawSeedBase64Url: toString(privateKey.raw, "base64url"),
+    createdAt: Date.now(),
+    deviceName,
+    platform
+  };
+}
+async function privateKeyFromIdentity(identity) {
+  if (identity.privateKeyRawSeedBase64Url) {
+    const { privateKeyFromRaw } = await loadCryptoKeys();
+    const { fromString } = await loadUint8arrays();
+    const raw = fromString(identity.privateKeyRawSeedBase64Url, "base64url");
+    return privateKeyFromRaw(raw);
+  }
+  throw new Error("unsupported_private_key_format");
+}
+function buildDeviceBindingMessage(input) {
+  const message = [
+    "memeloop-device-binding-v1",
+    `accountId=${input.accountId}`,
+    `peerId=${input.peerId}`,
+    `publicKey=${input.publicKeyMultibase}`,
+    `nonce=${input.nonce}`
+  ].join("\n");
+  return new TextEncoder().encode(message);
+}
+function buildDeviceConnectionGrantMessage(grant) {
+  const message = [
+    "memeloop-device-connection-grant-v1",
+    `issuer=${grant.issuer}`,
+    `accountId=${grant.accountId}`,
+    `subjectPeerId=${grant.subjectPeerId}`,
+    `allowedPeerIds=${grant.allowedPeerIds.join(",")}`,
+    `issuedAt=${grant.issuedAt}`,
+    `expiresAt=${grant.expiresAt}`
+  ].join("\n");
+  return new TextEncoder().encode(message);
+}
+function buildDeviceRelayReservationTokenMessage(token) {
+  const message = [
+    "memeloop-device-relay-admission-v1",
+    `issuer=${token.issuer}`,
+    `accountId=${token.accountId}`,
+    `peerId=${token.peerId}`,
+    `relayMultiaddrs=${token.relayMultiaddrs.join(",")}`,
+    `bootstrapMultiaddrs=${token.bootstrapMultiaddrs.join(",")}`,
+    `issuedAt=${token.issuedAt}`,
+    `expiresAt=${token.expiresAt}`
+  ].join("\n");
+  return new TextEncoder().encode(message);
+}
+async function signDeviceBinding(input) {
+  const { toString } = await loadUint8arrays();
+  const privateKey = await privateKeyFromIdentity(input.identity);
+  const publicKey = privateKey.publicKey;
+  if (await encodePublicKeyMultibase(publicKey) !== input.identity.publicKeyMultibase) {
+    throw new Error("device_identity_public_key_mismatch");
+  }
+  if (peerIdFromPrivateKey(privateKey).toString() !== input.identity.peerId) {
+    throw new Error("device_identity_peer_id_mismatch");
+  }
+  const message = buildDeviceBindingMessage({
+    accountId: input.accountId,
+    peerId: input.identity.peerId,
+    publicKeyMultibase: input.identity.publicKeyMultibase,
+    nonce: input.nonce
+  });
+  const signature = await privateKey.sign(message);
+  return toString(signature, "base64url");
+}
+async function verifyDeviceBinding(input) {
+  try {
+    const { fromString } = await loadUint8arrays();
+    const publicKey = await decodePublicKeyMultibase(input.publicKeyMultibase);
+    if (peerIdFromPublicKey(publicKey).toString() !== input.peerId) {
+      return false;
+    }
+    const message = buildDeviceBindingMessage({
+      accountId: input.accountId,
+      peerId: input.peerId,
+      publicKeyMultibase: input.publicKeyMultibase,
+      nonce: input.cloudNonce
+    });
+    const signature = fromString(input.signature, "base64url");
+    return await publicKey.verify(message, signature);
+  } catch {
+    return false;
+  }
+}
+async function verifyDeviceConnectionGrant(input) {
+  try {
+    const now = input.now ?? Date.now();
+    const { grant } = input;
+    if (grant.issuer !== "memeloop-cloud") return false;
+    if (grant.issuedAt > grant.expiresAt) return false;
+    if (grant.expiresAt <= now) return false;
+    if (input.subjectPeerId && grant.subjectPeerId !== input.subjectPeerId) return false;
+    if (input.allowedPeerId && !grant.allowedPeerIds.includes(input.allowedPeerId)) return false;
+    const { fromString } = await loadUint8arrays();
+    const publicKey = await decodePublicKeyMultibase(input.verificationPublicKeyMultibase);
+    const message = buildDeviceConnectionGrantMessage({
+      issuer: grant.issuer,
+      accountId: grant.accountId,
+      subjectPeerId: grant.subjectPeerId,
+      allowedPeerIds: grant.allowedPeerIds,
+      issuedAt: grant.issuedAt,
+      expiresAt: grant.expiresAt
+    });
+    const signature = fromString(grant.signature, "base64url");
+    return await publicKey.verify(message, signature);
+  } catch {
+    return false;
+  }
+}
+async function verifyDeviceRelayReservationToken(input) {
+  try {
+    const now = input.now ?? Date.now();
+    const { token } = input;
+    if (token.issuer !== "memeloop-cloud") return false;
+    if (token.issuedAt > token.expiresAt) return false;
+    if (token.expiresAt <= now) return false;
+    if (input.peerId && token.peerId !== input.peerId) return false;
+    const { fromString } = await loadUint8arrays();
+    const publicKey = await decodePublicKeyMultibase(input.verificationPublicKeyMultibase);
+    const message = buildDeviceRelayReservationTokenMessage({
+      issuer: token.issuer,
+      accountId: token.accountId,
+      peerId: token.peerId,
+      relayMultiaddrs: token.relayMultiaddrs,
+      bootstrapMultiaddrs: token.bootstrapMultiaddrs,
+      issuedAt: token.issuedAt,
+      expiresAt: token.expiresAt
+    });
+    const signature = fromString(token.signature, "base64url");
+    return await publicKey.verify(message, signature);
+  } catch {
+    return false;
+  }
+}
+function addRelayListenAddress(addresses) {
+  return addresses.includes("/p2p-circuit") ? addresses : [...addresses, "/p2p-circuit"];
+}
+
+// src/device-network/cloudDeviceAuthorizer.ts
+var PAIRING_PROTOCOL3 = "/memeloop/pairing/1.0.0";
+var CloudDeviceAuthorizer = class {
+  constructor(options) {
+    this.options = options;
+    this.allowPairingProtocol = options.allowPairingProtocol ?? true;
+  }
+  allowPairingProtocol;
+  async canOpenProtocol(input) {
+    const record = this.options.getTrustedDevice?.(input.remotePeerId);
+    if (record?.revokedAt) return false;
+    if (input.protocol === PAIRING_PROTOCOL3) return this.allowPairingProtocol;
+    if (record) return true;
+    if (!input.presentedGrant) return false;
+    const direction = input.direction ?? "inbound";
+    return verifyDeviceConnectionGrant({
+      grant: input.presentedGrant,
+      verificationPublicKeyMultibase: this.options.grantVerificationPublicKeyMultibase,
+      subjectPeerId: direction === "outbound" ? this.options.localPeerId : input.remotePeerId,
+      allowedPeerId: direction === "outbound" ? input.remotePeerId : this.options.localPeerId,
+      now: this.options.now?.()
+    });
+  }
+};
+
+// src/device-network/memoryDeviceNetworkService.ts
+var emptyCapabilities2 = {
+  tools: [],
+  mcpServers: [],
+  hasWiki: false,
+  agentLoop: false,
+  imChannels: [],
+  wikis: []
+};
+function toDevice(record, capabilities) {
+  return {
+    peerId: record.peerId,
+    displayName: record.deviceName,
+    platform: record.platform,
+    trustMode: record.trustMode,
+    trusted: !record.revokedAt,
+    reachability: {
+      state: record.revokedAt ? "offline" : "nearby",
+      paths: record.revokedAt ? [] : ["lan"]
+    },
+    capabilities,
+    lastSeen: record.lastSeen
+  };
+}
+var MemoryDeviceNetworkService = class {
+  constructor(options) {
+    this.options = options;
+    this.capabilities = options.capabilities ?? emptyCapabilities2;
+    for (const record of options.trustedDevices ?? []) {
+      this.trustedDevices.set(record.peerId, record);
+    }
+  }
+  started = false;
+  capabilities;
+  trustedDevices = /* @__PURE__ */ new Map();
+  pairingSessions = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  pairingListeners = /* @__PURE__ */ new Set();
+  async start() {
+    this.started = true;
+    this.emitDevices();
+  }
+  async stop() {
+    this.started = false;
+    this.emitDevices();
+  }
+  async getLocalDevice() {
+    return {
+      peerId: this.options.identity.peerId,
+      displayName: this.options.identity.deviceName,
+      platform: this.options.identity.platform,
+      trustMode: "local-pairing",
+      reachability: {
+        state: this.started ? "online" : "offline",
+        paths: this.started ? ["lan"] : []
+      },
+      capabilities: this.capabilities,
+      lastSeen: Date.now()
+    };
+  }
+  async listDevices() {
+    return [...this.trustedDevices.values()].map((record) => toDevice(record, emptyCapabilities2));
+  }
+  observeDevices(listener) {
+    this.listeners.add(listener);
+    void this.listDevices().then(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async listPairingSessions() {
+    return [...this.pairingSessions.values()];
+  }
+  observePairingSessions(listener) {
+    this.pairingListeners.add(listener);
+    void this.listPairingSessions().then(listener);
+    return () => {
+      this.pairingListeners.delete(listener);
+    };
+  }
+  async requestLocalPairing(peerId, _options = {}) {
+    const createdAt = Date.now();
+    const session = {
+      sessionId: `pairing-${this.options.identity.peerId}-${peerId}-${createdAt}`,
+      localPeerId: this.options.identity.peerId,
+      remotePeerId: peerId,
+      remotePublicKeyMultibase: "",
+      remoteDeviceName: peerId,
+      remotePlatform: "cli",
+      remoteCapabilities: emptyCapabilities2,
+      remoteMultiaddrs: [],
+      direction: "outbound",
+      status: "pending",
+      confirmCode: this.confirmCode(peerId),
+      createdAt,
+      expiresAt: createdAt + 5 * 6e4
+    };
+    this.pairingSessions.set(session.sessionId, session);
+    this.emitPairingSessions();
+    return session;
+  }
+  async acceptPairing(sessionId) {
+    const session = this.pairingSessions.get(sessionId);
+    if (!session) throw new Error("pairing_session_not_found");
+    if (session.expiresAt < Date.now()) throw new Error("pairing_session_expired");
+    if (session.status !== "pending") throw new Error("pairing_session_not_pending");
+    this.trustedDevices.set(session.remotePeerId, {
+      peerId: session.remotePeerId,
+      publicKeyMultibase: session.remotePublicKeyMultibase,
+      deviceName: session.remoteDeviceName,
+      platform: session.remotePlatform,
+      trustMode: "local-pairing",
+      createdAt: Date.now(),
+      lastSeen: Date.now()
+    });
+    session.status = "accepted";
+    this.emitPairingSessions();
+    this.emitDevices();
+  }
+  async rejectPairing(sessionId) {
+    const session = this.pairingSessions.get(sessionId);
+    if (!session) return;
+    session.status = "rejected";
+    this.emitPairingSessions();
+  }
+  async removeTrustedDevice(peerId) {
+    this.trustedDevices.delete(peerId);
+    this.emitDevices();
+  }
+  async openStream(peerId, _protocol, _presentedGrant) {
+    if (!this.trustedDevices.has(peerId)) throw new Error("device_not_trusted");
+    return {
+      source: (async function* emptySource() {
+      })(),
+      async sink() {
+      },
+      async close() {
+      }
+    };
+  }
+  async sendRpc(peerId, _method, _parameters, _presentedGrant) {
+    if (!this.trustedDevices.has(peerId)) throw new Error("device_not_trusted");
+    throw new Error("rpc_handler_not_registered");
+  }
+  async syncWithDevice(peerId, _presentedGrant) {
+    if (!this.trustedDevices.has(peerId)) throw new Error("device_not_trusted");
+    return { ok: true, peerId, syncedAt: Date.now() };
+  }
+  confirmCode(peerId) {
+    const input = `${this.options.identity.peerId}:${peerId}`;
+    let hash = 0;
+    for (let index = 0; index < input.length; index += 1) {
+      hash = hash * 31 + input.charCodeAt(index) >>> 0;
+    }
+    return (hash % 1e6).toString().padStart(6, "0");
+  }
+  emitDevices() {
+    void this.listDevices().then((devices) => {
+      for (const listener of this.listeners) listener(devices);
+    });
+  }
+  emitPairingSessions() {
+    void this.listPairingSessions().then((sessions) => {
+      for (const listener of this.pairingListeners) listener(sessions);
+    });
+  }
+};
+
+// 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 existing = existingByPeerId.get(cloudDevice.peerId);
+    const record = {
+      peerId: cloudDevice.peerId,
+      publicKeyMultibase: cloudDevice.publicKeyMultibase,
+      deviceName: cloudDevice.deviceName,
+      platform: cloudDevice.platform,
+      trustMode: "cloud-account",
+      accountId: cloudDevice.accountId,
+      createdAt: existing?.createdAt ?? Date.now(),
+      lastSeen: cloudDevice.lastSeen,
+      revokedAt: cloudDevice.revokedAt
+    };
+    if (existing) {
+      existing.lastSeen = cloudDevice.lastSeen;
+      existing.revokedAt = cloudDevice.revokedAt;
+      if (existing.publicKeyMultibase !== record.publicKeyMultibase || existing.deviceName !== record.deviceName || existing.platform !== record.platform) {
+        await input.trustStore.saveTrustedDevice(record);
+      }
+    } else {
+      await input.trustStore.saveTrustedDevice(record);
+    }
+  }
+  return cloudDevices;
+}
+
+// src/im/channelManager.ts
+var IMChannelManager = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  bindings = /* @__PURE__ */ new Map();
+  key(channelId, imUserId) {
+    return `${channelId}::${imUserId}`;
+  }
+  async getBinding(channelId, imUserId) {
+    const k = this.key(channelId, imUserId);
+    if (this.storage?.getImBinding) {
+      const row = await this.storage.getImBinding(channelId, imUserId);
+      if (row) {
+        this.bindings.set(k, row);
+        return row;
+      }
+    }
+    return this.bindings.get(k);
+  }
+  async setBinding(record) {
+    this.bindings.set(this.key(record.channelId, record.imUserId), record);
+    if (this.storage?.setImBinding) {
+      await this.storage.setImBinding(record);
+    }
+  }
+  /**
+   * 处理入站文本：无 binding 时创建会话并发送首条用户消息。
+   */
+  async dispatchInbound(message, driver, options) {
+    const existing = await this.getBinding(message.channelId, message.imUserId);
+    if (existing) {
+      await driver.sendMessage({
+        conversationId: existing.activeConversationId,
+        message: message.text
+      });
+      return { conversationId: existing.activeConversationId };
+    }
+    const definitionId = options.defaultDefinitionId;
+    const { conversationId } = await driver.createAgent({
+      definitionId,
+      initialMessage: message.text
+    });
+    await this.setBinding({
+      channelId: message.channelId,
+      imUserId: message.imUserId,
+      activeConversationId: conversationId,
+      createdAt: Date.now(),
+      defaultDefinitionId: definitionId
+    });
+    return { conversationId };
+  }
+  async switchConversation(channelId, imUserId, conversationId) {
+    const current = await this.getBinding(channelId, imUserId);
+    if (current) {
+      await this.setBinding({ ...current, activeConversationId: conversationId });
+    } else {
+      await this.setBinding({
+        channelId,
+        imUserId,
+        activeConversationId: conversationId,
+        createdAt: Date.now()
+      });
+    }
+  }
+};
+function pickAdapter(adapters, platform) {
+  return adapters.find((a) => a.platform === platform);
+}
+
+// src/im/imPlatformLimits.ts
+function imPlatformMaxMessageChars(platform) {
+  switch (platform) {
+    case "telegram":
+      return 4096;
+    case "discord":
+      return 2e3;
+    case "lark":
+      return 4096;
+    case "wecom":
+      return 2048;
+    case "slack":
+      return 4e3;
+    case "qq":
+      return 4500;
+    default:
+      return 3500;
+  }
+}
+
+// src/im/slashCommands.ts
+async function tryHandleImSlashCommand(context) {
+  const t = context.rawText.trim();
+  if (!t.startsWith("/") || t.startsWith("//") || t.length < 2) {
+    return { handled: false, messages: [] };
+  }
+  const parts = t.slice(1).split(/\s+/).filter(Boolean);
+  const cmd = (parts[0] ?? "").toLowerCase();
+  const rest = parts.slice(1).join(" ").trim();
+  const binding = await context.manager.getBinding(context.channelId, context.imUserId);
+  const ok = (lines) => ({ handled: true, messages: lines });
+  if (cmd === "list") {
+    const list = await context.storage.listConversations({ limit: 50 });
+    if (list.length === 0) return ok(["\uFF08\u6682\u65E0\u4F1A\u8BDD\uFF09"]);
+    const body = list.map(
+      (c, index) => `${index + 1}. ${c.title || c.conversationId} \u2014 ${c.conversationId.slice(0, 14)}\u2026`
+    );
+    return ok(["\u53EF\u5207\u6362\u4F1A\u8BDD\uFF1A", ...body.map((l) => `\u2022 ${l}`)]);
+  }
+  if (cmd === "switch") {
+    if (!binding) return ok(["\u5F53\u524D\u65E0\u7ED1\u5B9A\u4F1A\u8BDD\uFF0C\u5148\u7528 /new \u521B\u5EFA\u3002"]);
+    const list = await context.storage.listConversations({ limit: 50 });
+    const argument = rest.trim();
+    if (!argument) return ok(["\u7528\u6CD5\uFF1A/switch <\u7F16\u53F7\u6216 conversationId>"]);
+    const n = parseInt(argument, 10);
+    let targetId;
+    if (!Number.isNaN(n) && n >= 1 && n <= list.length) {
+      targetId = list[n - 1]?.conversationId;
+    } else {
+      targetId = list.find(
+        (c) => c.conversationId === argument || c.conversationId.includes(argument)
+      )?.conversationId;
+    }
+    if (!targetId) return ok([`\u672A\u627E\u5230\u4F1A\u8BDD\uFF1A${argument}`]);
+    await context.manager.switchConversation(context.channelId, context.imUserId, targetId);
+    return ok([`\u5DF2\u5207\u6362\u5230\uFF1A${targetId}`]);
+  }
+  if (cmd === "new" || cmd === "agent") {
+    const definitionId = rest || context.defaultDefinitionId;
+    const { conversationId } = await context.driver.createAgent({ definitionId });
+    await context.manager.setBinding({
+      channelId: context.channelId,
+      imUserId: context.imUserId,
+      activeConversationId: conversationId,
+      createdAt: Date.now(),
+      defaultDefinitionId: definitionId
+    });
+    return ok([`\u5DF2\u65B0\u5EFA\u5E76\u7ED1\u5B9A\u4F1A\u8BDD\u3002
+ID\uFF1A\`${conversationId}\`
+\u53D1\u9001\u6D88\u606F\u5373\u53EF\u5F00\u59CB\u3002`]);
+  }
+  if (cmd === "status") {
+    if (!binding) return ok(["\u65E0\u6D3B\u8DC3 IM \u7ED1\u5B9A\u3002"]);
+    const meta = await context.storage.getConversationMeta(binding.activeConversationId);
+    return ok([
+      `\u4F1A\u8BDD\uFF1A${binding.activeConversationId}`,
+      `\u5B9A\u4E49\uFF1A${meta?.definitionId ?? "?"}`,
+      `\u6D88\u606F\u6570\uFF1A${meta?.messageCount ?? "?"}`
+    ]);
+  }
+  if (cmd === "cancel") {
+    if (!binding) return ok(["\u65E0\u4F1A\u8BDD\u53EF\u53D6\u6D88\u3002"]);
+    await context.runtime.cancelAgent(binding.activeConversationId);
+    return ok(["\u5DF2\u8BF7\u6C42\u53D6\u6D88\u5F53\u524D\u4EFB\u52A1\u3002"]);
+  }
+  return { handled: false, messages: [] };
+}
+
+// src/im/streamAgentReplyToIm.ts
+function stringifyImValue(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[unserializable value]";
+  }
+}
+async function streamRuntimeAgentReplyToIm(options) {
+  const max = imPlatformMaxMessageChars(options.platform);
+  let buf = "";
+  const sendSlice = async (force) => {
+    if (buf.length === 0) return;
+    if (force) {
+      while (buf.length > 0) {
+        const take = Math.min(max, buf.length);
+        const chunk = buf.slice(0, take);
+        buf = buf.slice(take);
+        if (chunk.trim().length > 0) await options.flush(chunk);
+      }
+      return;
+    }
+    while (buf.length >= max) {
+      const chunk = buf.slice(0, max);
+      buf = buf.slice(max);
+      await options.flush(chunk);
+    }
+  };
+  await new Promise((resolve, reject) => {
+    const off = options.runtime.subscribeToUpdates(options.conversationId, (u) => {
+      const o = u;
+      if (o.type === "agent-done") {
+        void sendSlice(true).then(() => {
+          off();
+          resolve();
+        }).catch(reject);
+        return;
+      }
+      if (o.type === "agent-error") {
+        off();
+        reject(new Error(o.error ?? "agent-error"));
+        return;
+      }
+      if (o.type === "agent-step" && o.step?.type === "message") {
+        const stepData = o.step.data;
+        let piece = "";
+        if (typeof stepData === "string") piece = stepData;
+        else if (stepData != null && typeof stepData === "object" && "content" in stepData) {
+          const content = stepData.content;
+          piece = stringifyImValue(content);
+        } else piece = stringifyImValue(stepData);
+        buf += piece;
+        void sendSlice(false);
+      }
+      if (o.type === "agent-step" && o.step?.type === "tool") {
+        const td = o.step.data;
+        const id = td.toolId;
+        if (!id) return;
+        if (id === "ask-question") {
+          const p = td.parameters;
+          const q = typeof p?.question === "string" ? p.question : "";
+          const optLabels = p?.options?.map((o2) => o2.label).filter((x) => typeof x === "string");
+          const askText = options.renderer.renderAskQuestion(q, optLabels);
+          buf += (buf && !buf.endsWith("\n") ? "\n" : "") + askText + "\n";
+          void sendSlice(true);
+          return;
+        }
+        if (td.isError) {
+          buf += (buf && !buf.endsWith("\n") ? "\n" : "") + options.renderer.renderError(stringifyImValue(td.result) || "tool error") + "\n";
+          void sendSlice(false);
+          return;
+        }
+        const callLine = options.renderer.renderToolCallSummary(id, td.parameters ?? {});
+        const resultLine = options.renderer.renderToolResultSummary(id, td.result ?? null);
+        buf += (buf && !buf.endsWith("\n") ? "\n" : "") + callLine + (resultLine ? `
+${resultLine}` : "") + "\n";
+        void sendSlice(false);
+      }
+    });
+  });
+}
+
+// src/im/textRenderer.ts
+var TextMessageRenderer = class {
+  renderPlainText(content) {
+    return content.trim();
+  }
+  renderToolCallSummary(toolName, arguments_) {
+    const s = (() => {
+      try {
+        const index = JSON.stringify(arguments_);
+        if (!index || index === "{}") return "";
+        return index.length > 120 ? `${index.slice(0, 117)}\u2026` : index;
+      } catch {
+        return "";
+      }
+    })();
+    return s ? `\u{1F527} ${toolName}: ${s}` : `\u{1F527} ${toolName}`;
+  }
+  renderToolResultSummary(toolName, result) {
+    if (result == null) return `\u2705 ${toolName}: done`;
+    if (typeof result === "string") {
+      const t = result.trim();
+      if (!t) return `\u2705 ${toolName}: done`;
+      return `\u2705 ${toolName}: ${t.length > 120 ? `${t.slice(0, 117)}\u2026` : t}`;
+    }
+    if (typeof result === "object") {
+      const keys = Object.keys(result);
+      if (keys.length === 0) return `\u2705 ${toolName}: done`;
+      return `\u2705 ${toolName}: {${keys.slice(0, 6).join(", ")}${keys.length > 6 ? ", \u2026" : ""}}`;
+    }
+    if (typeof result === "symbol") return `\u2705 ${toolName}: ${result.toString()}`;
+    if (typeof result === "function") return `\u2705 ${toolName}: [function]`;
+    if (typeof result === "number" || typeof result === "boolean" || typeof result === "bigint") {
+      return `\u2705 ${toolName}: ${String(result)}`;
+    }
+    return `\u2705 ${toolName}: done`;
+  }
+  renderToolApproval(toolName, arguments_) {
+    return `\u23F8 \u9700\u8981\u5BA1\u6279\u6267\u884C\u5DE5\u5177\uFF1A${toolName}
+\u53C2\u6570\uFF1A
+\`\`\`json
+${JSON.stringify(arguments_, null, 2)}
+\`\`\`
+\u56DE\u590D Y \u540C\u610F / N \u62D2\u7EDD`;
+  }
+  renderAskQuestion(question, options) {
+    const lines = options?.length ? [`\u2753 ${question}`, ...options.map((o, index) => `${index + 1}. ${o}`)] : [`\u2753 ${question}`];
+    return lines.join("\n");
+  }
+  renderThinking(_content) {
+    return null;
+  }
+  renderError(error2) {
+    return `\u26A0\uFE0F \u9519\u8BEF\uFF1A${error2}`;
+  }
+  renderTodoList(todos) {
+    return ["\u{1F4CB} Todo", ...todos.map((t) => `${t.done ? "[x]" : "[ ]"} ${t.text}`)].join("\n");
+  }
+};
+
+// src/im/tools.ts
+var imToolDefinitions = [
+  {
+    name: "im.listConversations",
+    description: "\u5217\u51FA\u53EF\u5207\u6362\u7684\u4F1A\u8BDD\uFF08\u7531 memeloop-cli registerImSessionTools \u6CE8\u518C\uFF0C\u4EC5 IM \u6765\u6E90\u4F1A\u8BDD\u53EF\u7528\uFF09\u3002"
+  },
+  {
+    name: "im.switchConversation",
+    description: "\u5207\u6362\u5F53\u524D IM \u7528\u6237\u7ED1\u5B9A\u7684\u6D3B\u8DC3\u4F1A\u8BDD\u3002\u53C2\u6570\uFF1A{ conversationId: string }"
+  },
+  {
+    name: "im.newConversation",
+    description: "\u521B\u5EFA\u65B0\u4F1A\u8BDD\u5E76\u5207\u6362\u7ED1\u5B9A\u3002\u53C2\u6570\uFF1A{ definitionId?: string }"
+  },
+  {
+    name: "im.summarizeHistory",
+    description: "\u8FD4\u56DE\u5F53\u524D\u4F1A\u8BDD\u6700\u8FD1\u6D88\u606F\u7684\u7EAF\u6587\u672C\u6458\u8981\uFF08\u89C4\u5219\u62FC\u63A5\uFF0C\u975E LLM\uFF09\u3002\u53C2\u6570\uFF1A{ maxMessages?: number }"
+  }
+];
+async function imSwitchConversation(rt, conversationId) {
+  await rt.manager.switchConversation(rt.channelId, rt.imUserId, conversationId);
+}
+
+// src/sync/protocol.ts
+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";
+}
+
+// src/tools/builtins/imBuiltinTools.ts
+import { z } from "zod";
+var IM_SESSION_TOOL_IDS = [
+  "im.listConversations",
+  "im.switchConversation",
+  "im.newConversation",
+  "im.summarizeHistory"
+];
+var listSchema = z.object({});
+var switchSchema = z.object({
+  conversationId: z.string().min(1)
+});
+var newSchema = z.object({
+  definitionId: z.string().min(1).optional()
+});
+var summarizeSchema = z.object({
+  maxMessages: z.number().int().positive().max(200).optional()
+});
+function error(message) {
+  return { error: message };
+}
+async function requireImSource(context, conversationId) {
+  const meta = await context.storage.getConversationMeta(conversationId);
+  const sc = meta?.sourceChannel;
+  if (!sc) {
+    return { error: "im_tools_only_in_im_session" };
+  }
+  return { channelId: sc.channelId, imUserId: sc.imUserId, platform: sc.platform };
+}
+async function imListConversationsImpl(arguments_, context, _reg) {
+  const parsed = listSchema.safeParse(arguments_);
+  if (!parsed.success) return error("invalid_args");
+  const cid = context.activeToolConversationId;
+  if (!cid) return error("no_active_conversation");
+  const source = await requireImSource(context, cid);
+  if ("error" in source) return source;
+  const all = await context.storage.listConversations({});
+  if (all.length === 0) return { result: "\uFF08\u6682\u65E0\u4F1A\u8BDD\uFF09" };
+  const sorted = [...all].sort((a, b) => b.lastMessageTimestamp - a.lastMessageTimestamp);
+  const lines = sorted.map((m, index) => {
+    const title = m.title || m.conversationId;
+    const t = new Date(m.lastMessageTimestamp).toISOString();
+    return `${index + 1}. ${title}
+   id: ${m.conversationId}
+   def: ${m.definitionId} | ${t}`;
+  });
+  return { result: `\u53EF\u5207\u6362\u7684\u4F1A\u8BDD\uFF1A
+${lines.join("\n")}` };
+}
+async function imSwitchConversationImpl(arguments_, context, reg) {
+  const parsed = switchSchema.safeParse(arguments_);
+  if (!parsed.success) return error("invalid_args");
+  const cid = context.activeToolConversationId;
+  if (!cid) return error("no_active_conversation");
+  const source = await requireImSource(context, cid);
+  if ("error" in source) return source;
+  await reg.imChannelManager.switchConversation(
+    source.channelId,
+    source.imUserId,
+    parsed.data.conversationId
+  );
+  return { result: `\u5DF2\u5207\u6362\u5230\u4F1A\u8BDD\uFF1A${parsed.data.conversationId}` };
+}
+async function imNewConversationImpl(arguments_, context, reg) {
+  const parsed = newSchema.safeParse(arguments_);
+  if (!parsed.success) return error("invalid_args");
+  const cid = context.activeToolConversationId;
+  if (!cid) return error("no_active_conversation");
+  const source = await requireImSource(context, cid);
+  if ("error" in source) return source;
+  const current = await reg.imChannelManager.getBinding(source.channelId, source.imUserId);
+  const definitionId = parsed.data.definitionId?.trim() || current?.defaultDefinitionId || "memeloop:general-assistant";
+  const rt = reg.getMemeLoopRuntime();
+  const { conversationId } = await rt.createAgent({ definitionId, initialMessage: "" });
+  await reg.imChannelManager.setBinding({
+    channelId: source.channelId,
+    imUserId: source.imUserId,
+    activeConversationId: conversationId,
+    createdAt: Date.now(),
+    defaultDefinitionId: definitionId
+  });
+  const meta = await context.storage.getConversationMeta(conversationId);
+  if (meta) {
+    await context.storage.upsertConversationMetadata({
+      ...meta,
+      sourceChannel: {
+        channelId: source.channelId,
+        platform: source.platform,
+        imUserId: source.imUserId
+      }
+    });
+  }
+  return {
+    result: `\u5DF2\u65B0\u5EFA\u5E76\u5207\u6362\u5230\u4F1A\u8BDD\uFF1A${conversationId}
+definition: ${definitionId}
+\u8BF7\u8BA9\u7528\u6237\u53D1\u9001\u4E0B\u4E00\u6761\u6D88\u606F\u4EE5\u5F00\u59CB\u5BF9\u8BDD\u3002`
+  };
+}
+async function imSummarizeHistoryImpl(arguments_, context, _reg) {
+  const parsed = summarizeSchema.safeParse(arguments_);
+  if (!parsed.success) return error("invalid_args");
+  const cid = context.activeToolConversationId;
+  if (!cid) return error("no_active_conversation");
+  const source = await requireImSource(context, cid);
+  if ("error" in source) return source;
+  void source;
+  const max = parsed.data.maxMessages ?? 40;
+  const msgs = await context.storage.getMessages(cid, { mode: "full-content" });
+  const tail = msgs.slice(-max);
+  if (tail.length === 0) return { result: "\uFF08\u5F53\u524D\u4F1A\u8BDD\u5C1A\u65E0\u6D88\u606F\uFF09" };
+  const lines = tail.map(
+    (m) => `[${m.role}] ${m.content.slice(0, 2e3)}${m.content.length > 2e3 ? "\u2026" : ""}`
+  );
+  return {
+    result: `\u6700\u8FD1 ${tail.length} \u6761\u6D88\u606F\u6458\u8981\uFF08\u4F9B IM \u4E0A\u4E0B\u6587\uFF09\uFF1A
+${lines.join("\n---\n")}`
+  };
+}
+function registerImSessionBuiltinTools(registry, context, reg) {
+  const bound = (function_) => (arguments_) => function_(arguments_, context, reg);
+  registry.registerTool("im.listConversations", bound(imListConversationsImpl));
+  registry.registerTool("im.switchConversation", bound(imSwitchConversationImpl));
+  registry.registerTool("im.newConversation", bound(imNewConversationImpl));
+  registry.registerTool("im.summarizeHistory", bound(imSummarizeHistoryImpl));
+  registerToolParameterSchema("im.listConversations", listSchema, {
+    displayName: "IM: list conversations",
+    description: "List conversations the user can switch to (IM sessions only)."
+  });
+  registerToolParameterSchema("im.switchConversation", switchSchema, {
+    displayName: "IM: switch conversation",
+    description: "Switch this IM user binding to another conversationId."
+  });
+  registerToolParameterSchema("im.newConversation", newSchema, {
+    displayName: "IM: new conversation",
+    description: "Create a new agent conversation and bind this IM user to it."
+  });
+  registerToolParameterSchema("im.summarizeHistory", summarizeSchema, {
+    displayName: "IM: summarize history",
+    description: "Return a plain-text digest of recent messages in the current conversation."
+  });
+}
+
+// src/tools/builtins/index.ts
+function registerBuiltinTools(registry, context) {
+  const promptDestination = registry.getPromptPlugins?.();
+  if (promptDestination) {
+    for (const [id, tool] of pluginRegistry) {
+      promptDestination.set(id, tool);
+    }
+    registerBuiltinPromptPlugins(promptDestination);
+  } else {
+    registerBuiltinPromptPlugins();
+  }
+  registerBuiltinToolPlugins();
+  getLoopRegistry().installPluginsForLoop("*", { ...context, toolRegistry: registry }, [
+    ...BUILTIN_TOOL_PLUGIN_IDS
+  ]);
+}
+
+// src/tools/parallelExecution.ts
+var DEFAULT_TOOL_TIMEOUT_MS = 3e4;
+var DEFAULT_BATCH_TIMEOUT_MS = 12e4;
+async function executeWithTimeout(entry) {
+  const timeoutMs = entry.timeoutMs ?? DEFAULT_TOOL_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let settled = false;
+    const timer = timeoutMs > 0 ? setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        resolve({
+          call: entry.call,
+          status: "timeout",
+          error: `Tool "${entry.call.toolId}" timed out after ${timeoutMs}ms`
+        });
+      }
+    }, timeoutMs) : void 0;
+    entry.executor(entry.call.parameters ?? {}).then((result) => {
+      if (!settled) {
+        settled = true;
+        if (timer) clearTimeout(timer);
+        resolve({ call: entry.call, status: "fulfilled", result });
+      }
+    }).catch((error2) => {
+      if (!settled) {
+        settled = true;
+        if (timer) clearTimeout(timer);
+        resolve({
+          call: entry.call,
+          status: "rejected",
+          result: {
+            success: false,
+            error: error2 instanceof Error ? error2.message : String(error2)
+          },
+          error: error2 instanceof Error ? error2.message : String(error2)
+        });
+      }
+    });
+  });
+}
+async function executeToolCallsParallel(entries, batchTimeoutMs = DEFAULT_BATCH_TIMEOUT_MS) {
+  if (entries.length === 0) return [];
+  if (entries.length === 1) {
+    return [await executeWithTimeout(entries[0])];
+  }
+  const promises = entries.map((entry) => executeWithTimeout(entry));
+  if (batchTimeoutMs > 0) {
+    const batchTimer = new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(
+          entries.map((entry) => ({
+            call: entry.call,
+            status: "timeout",
+            error: `Batch timeout: ${batchTimeoutMs}ms exceeded`
+          }))
+        );
+      }, batchTimeoutMs);
+    });
+    return Promise.race([Promise.all(promises), batchTimer]);
+  }
+  return Promise.all(promises);
+}
+async function executeToolCallsSequential(entries) {
+  const results = [];
+  for (const entry of entries) {
+    results.push(await executeWithTimeout(entry));
+  }
+  return results;
+}
+
+// src/tools/schemaToToolContent.ts
+function schemaToToolContent(schema) {
+  const jsonSchema = schema.toJSONSchema?.() ?? {};
+  const meta = Array.isArray(schema.meta) ? schema.meta?.[0] : void 0;
+  const title = meta?.title || jsonSchema.title || "tool";
+  const description = meta?.description || jsonSchema.description || "";
+  const examples = meta?.examples || jsonSchema.examples || [];
+  const props = jsonSchema.properties;
+  const requiredArray = Array.isArray(jsonSchema.required) ? jsonSchema.required : [];
+  let parameterLines = "";
+  if (props) {
+    parameterLines = Object.entries(props).map(([key, value]) => {
+      const p = value;
+      const type = p?.type || "string";
+      const desc = p?.description || p?.title || "";
+      const required = requiredArray.includes(key) ? "required" : "optional";
+      return `- ${key} (${type}, ${required}): ${desc}`;
+    }).join("\n");
+  }
+  const exampleSection = examples.map((example) => `- <tool_use name="${title}">${JSON.stringify(example)}</tool_use>`).join("\n");
+  return `
+## ${title}
+**Description**: ${description}
+**Parameters**:
+${parameterLines}
+
+**Examples**:
+${exampleSection}
+`;
+}
+
+// src/tools/defineTool.ts
+var MAX_TOOL_RESULT_CHARS = 32e3;
+var logger = {
+  debug: (..._a) => {
+  },
+  warn: (...a) => {
+    console.warn("[memeloop.defineTool]", ...a);
+  },
+  error: (...a) => {
+    console.error("[memeloop.defineTool]", ...a);
+  }
+};
+function defineTool(definition) {
+  const {
+    toolId,
+    configSchema,
+    llmToolSchemas,
+    onProcessPrompts,
+    onResponseComplete,
+    onPostProcess
+  } = definition;
+  const parameterKey = `${toolId}Param`;
+  const tool = (hooks) => {
+    if (onProcessPrompts) {
+      hooks.processPrompts.tapAsync(`${toolId}-processPrompts`, async (context, callback) => {
+        try {
+          const { toolConfig, prompts, messages, agentFrameworkContext } = context;
+          if (toolConfig.toolId !== toolId) {
+            callback();
+            return;
+          }
+          if (toolConfig.enabled === false) {
+            callback();
+            return;
+          }
+          const rawConfig = toolConfig[parameterKey];
+          if (!rawConfig) {
+            callback();
+            return;
+          }
+          const config = configSchema.parse(rawConfig);
+          const handlerContext = {
+            config,
+            toolConfig,
+            prompts,
+            messages,
+            agentFrameworkContext,
+            findPrompt: (id) => findPromptById(prompts, id),
+            injectToolList: (options) => {
+              const target = findPromptById(prompts, options.targetId);
+              if (!target) {
+                logger.warn(`Target prompt not found for tool list injection`, {
+                  targetId: options.targetId,
+                  toolId
+                });
+                return;
+              }
+              const schemas = options.toolSchemas ?? (llmToolSchemas ? Object.values(llmToolSchemas) : []);
+              const toolContent = schemas.map((schema) => schemaToToolContent(schema)).join("\n\n");
+              const pluginIndex = context.pluginIndex;
+              const source = pluginIndex !== void 0 ? ["plugins", toolConfig.id] : void 0;
+              const toolPrompt = {
+                id: `${toolId}-tool-list-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+                text: toolContent,
+                caption: options.caption ?? `${definition.displayName} Tools`,
+                enabled: true,
+                source
+              };
+              if (options.position === "child") {
+                if (!target.prompt.children) {
+                  target.prompt.children = [];
+                }
+                target.prompt.children.push(toolPrompt);
+              } else if (options.position === "before") {
+                target.parent.splice(target.index, 0, toolPrompt);
+              } else {
+                target.parent.splice(target.index + 1, 0, toolPrompt);
+              }
+            },
+            injectContent: (options) => {
+              const target = findPromptById(prompts, options.targetId);
+              if (!target) {
+                logger.warn(`Target prompt not found for content injection`, {
+                  targetId: options.targetId,
+                  toolId
+                });
+                return;
+              }
+              const pluginIndex = context.pluginIndex;
+              const source = pluginIndex !== void 0 ? ["plugins", toolConfig.id] : void 0;
+              const contentPrompt = {
+                id: options.id ?? `${toolId}-content-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+                text: options.content,
+                caption: options.caption ?? "Injected Content",
+                enabled: true,
+                source
+              };
+              if (options.position === "child") {
+                if (!target.prompt.children) {
+                  target.prompt.children = [];
+                }
+                target.prompt.children.push(contentPrompt);
+              } else if (options.position === "before") {
+                target.parent.splice(target.index, 0, contentPrompt);
+              } else {
+                target.parent.splice(target.index + 1, 0, contentPrompt);
+              }
+            }
+          };
+          await onProcessPrompts(handlerContext);
+          callback();
+        } catch (error2) {
+          logger.error(`Error in ${toolId} processPrompts handler`, error2);
+          callback();
+        }
+      });
+    }
+    if (onResponseComplete) {
+      hooks.responseComplete.tapAsync(`${toolId}-responseComplete`, async (context, callback) => {
+        try {
+          const {
+            agentFrameworkContext,
+            response,
+            agentFrameworkConfig,
+            requestId,
+            toolConfig: directToolConfig
+          } = context;
+          const configuredToolConfig = agentFrameworkConfig?.plugins?.find(
+            (p) => p.toolId === toolId
+          );
+          const ourToolConfig = configuredToolConfig ?? (directToolConfig?.toolId === toolId ? directToolConfig : void 0);
+          if (!ourToolConfig) {
+            callback();
+            return;
+          }
+          if (ourToolConfig.enabled === false) {
+            callback();
+            return;
+          }
+          if (response.status !== "done" || !response.content) {
+            callback();
+            return;
+          }
+          const { calls: allCalls, parallel: isParallel } = matchAllToolCallings(response.content);
+          const toolCall = allCalls.length > 0 ? allCalls[0] : null;
+          const rawConfig = ourToolConfig[parameterKey];
+          let config;
+          if (rawConfig) {
+            try {
+              config = configSchema.parse(rawConfig);
+            } catch (parseError) {
+              logger.warn(`Failed to parse config for ${toolId}`, parseError);
+            }
+          }
+          const persist = agentFrameworkContext.persistAgentMessage;
+          const handlerContext = {
+            config,
+            toolConfig: ourToolConfig,
+            messages: agentFrameworkContext.agent.messages,
+            agentFrameworkContext,
+            response,
+            toolCall,
+            allToolCalls: allCalls,
+            isParallel,
+            agentFrameworkConfig,
+            hooks,
+            requestId,
+            findPrompt: () => void 0,
+            injectToolList: () => {
+              logger.warn("injectToolList is not available in response phase");
+            },
+            injectContent: () => {
+              logger.warn("injectContent is not available in response phase");
+            },
+            executeToolCall: async (toolName, executor) => {
+              const toolNameString = String(toolName);
+              if (!toolCall || toolCall.toolId !== toolNameString) {
+                return false;
+              }
+              const toolSchema = llmToolSchemas?.[toolName];
+              if (!toolSchema) {
+                logger.error(`No schema found for tool: ${toolNameString}`);
+                return false;
+              }
+              try {
+                const validatedParameters = toolSchema.parse(toolCall.parameters);
+                const approvalConfig = ourToolConfig.approval;
+                const decision = evaluateApproval(
+                  approvalConfig,
+                  toolNameString,
+                  validatedParameters
+                );
+                if (decision === "deny") {
+                  handlerContext.addToolResult({
+                    toolName: toolNameString,
+                    parameters: validatedParameters,
+                    result: "Tool execution denied by approval policy.",
+                    isError: true,
+                    duration: 2
+                  });
+                  handlerContext.yieldToSelf();
+                  return true;
+                }
+                if (decision === "pending") {
+                  const approvalId = `approval-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+                  const userDecision = await requestApproval({
+                    approvalId,
+                    agentId: agentFrameworkContext.agent.id,
+                    toolName: toolNameString,
+                    parameters: validatedParameters,
+                    originalText: toolCall.originalText,
+                    created: /* @__PURE__ */ new Date()
+                  });
+                  if (userDecision === "deny") {
+                    handlerContext.addToolResult({
+                      toolName: toolNameString,
+                      parameters: validatedParameters,
+                      result: "Tool execution denied by user.",
+                      isError: true,
+                      duration: 2
+                    });
+                    handlerContext.yieldToSelf();
+                    return true;
+                  }
+                }
+                const result = await executor(validatedParameters);
+                const toolResultDuration = config?.toolResultDuration ?? 1;
+                handlerContext.addToolResult({
+                  toolName: toolNameString,
+                  parameters: validatedParameters,
+                  result: result.success ? result.data ?? "Success" : result.error ?? "Unknown error",
+                  isError: !result.success,
+                  duration: toolResultDuration
+                });
+                handlerContext.yieldToSelf();
+                await hooks.toolExecuted.promise({
+                  agentFrameworkContext,
+                  toolResult: result,
+                  toolInfo: {
+                    toolId: toolNameString,
+                    parameters: validatedParameters,
+                    originalText: toolCall.originalText
+                  },
+                  requestId
+                });
+                return true;
+              } catch (error2) {
+                logger.error(`Tool execution failed: ${toolNameString}`, error2);
+                handlerContext.addToolResult({
+                  toolName: toolNameString,
+                  parameters: toolCall.parameters,
+                  result: error2 instanceof Error ? error2.message : String(error2),
+                  isError: true,
+                  duration: 2
+                });
+                handlerContext.yieldToSelf();
+                await hooks.toolExecuted.promise({
+                  agentFrameworkContext,
+                  toolResult: {
+                    success: false,
+                    error: error2 instanceof Error ? error2.message : String(error2)
+                  },
+                  toolInfo: {
+                    toolId: toolNameString,
+                    parameters: toolCall.parameters || {}
+                  }
+                });
+                return true;
+              }
+            },
+            addToolResult: (options) => {
+              const now = /* @__PURE__ */ new Date();
+              let resultContent = options.result;
+              if (resultContent.length > MAX_TOOL_RESULT_CHARS) {
+                const truncated = resultContent.slice(0, MAX_TOOL_RESULT_CHARS);
+                resultContent = `${truncated}
+
+[... truncated \u2014 result was ${options.result.length} chars, showing first ${MAX_TOOL_RESULT_CHARS}]`;
+              }
+              const toolResultText = `<functions_result>
+Tool: ${options.toolName}
+Parameters: ${JSON.stringify(options.parameters)}
+${options.isError ? "Error" : "Result"}: ${resultContent}
+</functions_result>`;
+              const toolResultMessage = {
+                messageId: `tool-result-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+                conversationId: agentFrameworkContext.agent.id,
+                originNodeId: "local",
+                timestamp: now.getTime(),
+                lamportClock: 0,
+                role: "tool",
+                content: toolResultText,
+                duration: options.duration ?? 1,
+                metadata: {
+                  isToolResult: true,
+                  isError: options.isError ?? false,
+                  toolId: options.toolName,
+                  toolParameters: options.parameters,
+                  isPersisted: false,
+                  isComplete: true
+                }
+              };
+              agentFrameworkContext.agent.messages.push(toolResultMessage);
+              const aiMessages = agentFrameworkContext.agent.messages.filter(
+                (m) => m.role === "assistant"
+              );
+              if (aiMessages.length > 0) {
+                const latestAiMessage = aiMessages[aiMessages.length - 1];
+                if (latestAiMessage.content === response.content && !latestAiMessage.metadata?.containsToolCall) {
+                  latestAiMessage.duration = 1;
+                  latestAiMessage.metadata = {
+                    ...latestAiMessage.metadata,
+                    containsToolCall: true,
+                    toolId: options.toolName,
+                    isPersisted: true
+                  };
+                  if (persist) {
+                    void (async () => {
+                      try {
+                        await persist(latestAiMessage);
+                      } catch (error2) {
+                        logger.warn("Failed to persist AI message with tool call", {
+                          error: error2,
+                          messageId: latestAiMessage.messageId
+                        });
+                      }
+                    })();
+                  }
+                }
+              }
+              if (persist) {
+                void (async () => {
+                  try {
+                    await persist(toolResultMessage);
+                    toolResultMessage.metadata = {
+                      ...toolResultMessage.metadata,
+                      isPersisted: true
+                    };
+                  } catch (error2) {
+                    logger.warn("Failed to persist tool result", {
+                      error: error2,
+                      messageId: toolResultMessage.messageId
+                    });
+                  }
+                })();
+              }
+            },
+            yieldToSelf: () => {
+              const context_ = context;
+              if (!context_.actions) {
+                context_.actions = {};
+              }
+              context_.actions.yieldNextRoundTo = "self";
+            },
+            yieldToHuman: () => {
+              const context_ = context;
+              if (!context_.actions) {
+                context_.actions = {};
+              }
+              context_.actions.yieldNextRoundTo = "human";
+            },
+            executeAllMatchingToolCalls: async (toolName, executor, options) => {
+              const toolNameString = String(toolName);
+              const matchingCalls = allCalls.filter((call) => call.toolId === toolNameString);
+              if (matchingCalls.length === 0) return 0;
+              const toolSchema = llmToolSchemas?.[toolName];
+              if (!toolSchema) {
+                logger.error(`No schema found for tool: ${toolNameString}`);
+                return 0;
+              }
+              const toolResultDuration = config?.toolResultDuration ?? 1;
+              const entries = [];
+              const approvalConfig = ourToolConfig.approval;
+              const batchDecision = evaluateApproval(
+                approvalConfig,
+                toolNameString,
+                matchingCalls[0]?.parameters ?? {}
+              );
+              if (batchDecision === "deny") {
+                for (const call of matchingCalls) {
+                  handlerContext.addToolResult({
+                    toolName: toolNameString,
+                    parameters: call.parameters,
+                    result: "Tool execution denied by approval policy.",
+                    isError: true,
+                    duration: toolResultDuration
+                  });
+                }
+                handlerContext.yieldToSelf();
+                return matchingCalls.length;
+              }
+              if (batchDecision === "pending") {
+                const approvalId = `approval-batch-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+                const userDecision = await requestApproval({
+                  approvalId,
+                  agentId: agentFrameworkContext.agent.id,
+                  toolName: toolNameString,
+                  parameters: {
+                    _batchSize: matchingCalls.length,
+                    _firstCallParams: matchingCalls[0]?.parameters
+                  },
+                  created: /* @__PURE__ */ new Date()
+                });
+                if (userDecision === "deny") {
+                  for (const call of matchingCalls) {
+                    handlerContext.addToolResult({
+                      toolName: toolNameString,
+                      parameters: call.parameters,
+                      result: "Tool execution denied by user.",
+                      isError: true,
+                      duration: toolResultDuration
+                    });
+                  }
+                  handlerContext.yieldToSelf();
+                  return matchingCalls.length;
+                }
+              }
+              for (const call of matchingCalls) {
+                try {
+                  const validatedParameters = toolSchema.parse(call.parameters);
+                  entries.push({
+                    call,
+                    executor: async () => executor(validatedParameters),
+                    timeoutMs: options?.timeoutMs
+                  });
+                } catch (validationError) {
+                  handlerContext.addToolResult({
+                    toolName: toolNameString,
+                    parameters: call.parameters,
+                    result: `Parameter validation failed: ${validationError instanceof Error ? validationError.message : String(validationError)}`,
+                    isError: true,
+                    duration: toolResultDuration
+                  });
+                }
+              }
+              if (entries.length === 0) return matchingCalls.length;
+              let results;
+              if (isParallel) {
+                results = await executeToolCallsParallel(entries);
+              } else {
+                results = await executeToolCallsSequential(entries);
+              }
+              for (const result of results) {
+                const isError = result.status !== "fulfilled" || result.result !== void 0 && !result.result.success;
+                const resultText = result.status === "timeout" ? result.error ?? "Tool execution timed out" : result.status === "rejected" ? result.error ?? "Tool execution failed" : result.result?.success ? result.result.data ?? "Success" : result.result?.error ?? "Unknown error";
+                handlerContext.addToolResult({
+                  toolName: toolNameString,
+                  parameters: result.call.parameters,
+                  result: resultText,
+                  isError,
+                  duration: toolResultDuration
+                });
+                await hooks.toolExecuted.promise({
+                  agentFrameworkContext,
+                  toolResult: result.result ?? { success: false, error: resultText },
+                  toolInfo: {
+                    toolId: toolNameString,
+                    parameters: result.call.parameters ?? {},
+                    originalText: result.call.originalText
+                  },
+                  requestId
+                });
+              }
+              handlerContext.yieldToSelf();
+              return matchingCalls.length;
+            }
+          };
+          await onResponseComplete(handlerContext);
+          callback();
+        } catch (error2) {
+          logger.error(`Error in ${toolId} responseComplete handler`, error2);
+          callback();
+        }
+      });
+    }
+    if (onPostProcess) {
+      hooks.postProcess.tapAsync(
+        `${toolId}-postProcess`,
+        async (context, callback) => {
+          try {
+            const { toolConfig, prompts, messages, agentFrameworkContext, llmResponse, responses } = context;
+            if (toolConfig.toolId !== toolId) {
+              callback();
+              return;
+            }
+            if (toolConfig.enabled === false) {
+              callback();
+              return;
+            }
+            const rawConfig = toolConfig[parameterKey];
+            if (!rawConfig) {
+              callback();
+              return;
+            }
+            const config = configSchema.parse(rawConfig);
+            const handlerContext = {
+              config,
+              toolConfig,
+              prompts,
+              messages,
+              agentFrameworkContext,
+              llmResponse,
+              responses,
+              findPrompt: (id) => findPromptById(prompts, id),
+              injectToolList: () => {
+                logger.warn("injectToolList is not recommended in postProcess phase");
+              },
+              injectContent: () => {
+                logger.warn("injectContent is not recommended in postProcess phase");
+              }
+            };
+            await onPostProcess(handlerContext);
+            callback();
+          } catch (error2) {
+            logger.error(`Error in ${toolId} postProcess handler`, error2);
+            callback();
+          }
+        }
+      );
+    }
+  };
+  getActivePluginRegistry().set(toolId, tool);
+  return {
+    tool,
+    toolId,
+    configSchema,
+    llmToolSchemas,
+    displayName: definition.displayName,
+    description: definition.description
+  };
+}
+
+// src/tools/hostAgentTools.ts
+function isPluginConfig(value) {
+  return typeof value === "object" && value !== null;
+}
+function mergeAgentToolsIntoFrameworkConfig(frameworkConfig, agentTools) {
+  const baseConfig = { ...frameworkConfig ?? {} };
+  const rawPlugins = Array.isArray(baseConfig.plugins) ? baseConfig.plugins : [];
+  const pluginByToolId = /* @__PURE__ */ new Map();
+  const pluginWithoutToolId = [];
+  for (const plugin of rawPlugins) {
+    if (isPluginConfig(plugin) && typeof plugin.toolId === "string" && plugin.toolId.length > 0) {
+      pluginByToolId.set(plugin.toolId, plugin);
+    } else {
+      pluginWithoutToolId.push(plugin);
+    }
+  }
+  for (const tool of agentTools ?? []) {
+    if (!tool.toolId) continue;
+    pluginByToolId.set(tool.toolId, {
+      id: `${tool.toolId}-agent-tool`,
+      toolId: tool.toolId,
+      enabled: tool.enabled ?? true,
+      ...tool.parameters ?? {}
+    });
+  }
+  return {
+    ...baseConfig,
+    prompts: Array.isArray(baseConfig.prompts) ? baseConfig.prompts : [],
+    response: Array.isArray(baseConfig.response) ? baseConfig.response : void 0,
+    plugins: [...pluginWithoutToolId, ...pluginByToolId.values()]
+  };
+}
+
+// src/tools/toolRegistry.ts
+var ToolDefinitionRegistry = class {
+  registry = /* @__PURE__ */ new Map();
+  registerToolDefinition(definition) {
+    const toolDefinition = defineTool(definition);
+    registerToolParameterSchema(toolDefinition.toolId, toolDefinition.configSchema, {
+      displayName: toolDefinition.displayName,
+      description: toolDefinition.description
+    });
+    this.registry.set(toolDefinition.toolId, toolDefinition);
+    return toolDefinition;
+  }
+  getAllToolDefinitions() {
+    return this.registry;
+  }
+  getToolDefinition(toolId) {
+    return this.registry.get(toolId);
+  }
+};
+var defaultToolDefinitionRegistry = new ToolDefinitionRegistry();
+function getDefaultToolDefinitionRegistry() {
+  return defaultToolDefinitionRegistry;
+}
+function registerToolDefinition(definition) {
+  return defaultToolDefinitionRegistry.registerToolDefinition(definition);
+}
+function getAllToolDefinitions() {
+  return defaultToolDefinitionRegistry.getAllToolDefinitions();
+}
+function getToolDefinition(toolId) {
+  return defaultToolDefinitionRegistry.getToolDefinition(toolId);
+}
+export {
+  AGENT_AGENT_LOOP_ID,
+  AGENT_TOOL_LOOP_ID,
+  ALL_CATEGORIES,
+  ASK_QUESTION_TOOL_ID,
+  ASK_USER_QUESTION_TOOL_ID,
+  AgentCreationController,
+  AgentDefinitionEditorController,
+  AgentProfileRegistry,
+  AgentSessionController,
+  BUILTIN_AGENT_AGENT_LOOP_QUALITY_GATE_SCRIPT_ID,
+  BUILTIN_AGENT_PROFILES,
+  BUILTIN_AGENT_TOOL_LOOP_DEFAULT_SCRIPT_ID,
+  BUILTIN_TOOL_PLUGIN_IDS,
+  ChatSyncEngine,
+  CloudDeviceAuthorizer,
+  HookRegistry,
+  IMChannelManager,
+  IM_SESSION_TOOL_IDS,
+  LIBP2P_RPC_REQUEST_TYPE,
+  LIBP2P_RPC_RESPONSE_TYPE,
+  LIBP2P_SYNC_REQUEST_TYPE,
+  LIBP2P_SYNC_RESPONSE_TYPE,
+  Libp2pDeviceNetworkService,
+  Libp2pDeviceSyncTransport,
+  LocalTrustDeviceAuthorizer,
+  MEMELOOP_STRUCTURED_TOOL_KEY,
+  MemoryDeviceNetworkService,
+  PERMISSIONS_TABLE_DDL,
+  PLUGIN_ASK_QUESTION,
+  PLUGIN_ASK_USER_QUESTION,
+  PLUGIN_MCP_CLIENT,
+  PLUGIN_MCP_FORWARD,
+  PLUGIN_REMOTE_AGENT,
+  PLUGIN_SPAWN_AGENT,
+  PLUGIN_TASK,
+  PLUGIN_TODO_WRITE,
+  PeerNodeSyncAdapter,
+  PromptPreviewController,
+  ProviderRegistry,
+  SessionStorage,
+  TODO_WRITE_TOOL_ID,
+  TextMessageRenderer,
+  TokenTracker,
+  ToolDefinitionRegistry,
+  __clearTodoStore,
+  askQuestionConfigSchema,
+  askQuestionImpl,
+  askUserQuestionConfigSchema,
+  askUserQuestionImpl,
+  attachmentBlobFromWire,
+  autoCompact,
+  buildAgent,
+  buildDeviceBindingMessage,
+  buildDeviceConnectionGrantMessage,
+  buildDeviceRelayReservationTokenMessage,
+  buildMemeloopFileUri,
+  buildMemeloopUri,
+  builtinAgentAgentLoopSources,
+  builtinAgentToolLoopSources,
+  cancelPendingApprovals,
+  checkPermission,
+  clearHooks,
+  clearPluginRegistrations,
+  compactMessages,
+  createAgentAgentLoopDefinition,
+  createAgentFrameworkHooks,
+  createAgentInstanceFromDefinition,
+  createAgentLoopRunner,
+  createAgentRuntimeDeviceRpcHandler,
+  createAgentToolLoopDefinition,
+  createAgentToolLoopRunner,
+  createChatMessage,
+  createCheckpointRecord,
+  createDeviceIdentity,
+  createFetchLLMProvider,
+  createHooksWithPlugins,
+  createInstanceDeltaFromDefinition,
+  createMemeLoopRuntime,
+  createPluginAPI,
+  decodeAttachmentBlobRpc,
+  decodePublicKeyMultibase,
+  defineTool,
+  encodePublicKeyMultibase,
+  evaluateApproval,
+  executeHooks,
+  executeToolCallsParallel,
+  executeToolCallsSequential,
+  exploreAgent,
+  extractMemeloopStructuredToolPayload,
+  findPromptById,
+  flattenPrompts,
+  getActivePluginRegistry,
+  getAgentAgentLoopId,
+  getAgentProfileRegistry,
+  getAllToolDefinitions,
+  getBuiltinAgentAgentLoopSource,
+  getBuiltinAgentToolLoopSource,
+  getBuiltinLoopProfile,
+  getBuiltinLoopProfiles,
+  getBuiltinToolPlugins,
+  getCategoryConfig,
+  getDefaultHookRegistry,
+  getDefaultToolDefinitionRegistry,
+  getHookCount,
+  getLoadedPlugin,
+  getLoopRegistry,
+  getMcpClientToolId,
+  getMcpForwardToolId,
+  getPendingApprovals,
+  getPluginRegistrations,
+  getRemoteAgentToolId,
+  getSpawnAgentToolId,
+  getTaskToolId,
+  getToolDefinition,
+  getToolMetadata,
+  getToolParameterSchema,
+  gitProxyTargetBlockReason,
+  hasHooks,
+  imPlatformMaxMessageChars,
+  imSwitchConversation,
+  imToolDefinitions,
+  isConversationMeta,
+  isLibp2pRpcRequest,
+  isLibp2pRpcResponse,
+  isLibp2pSyncRequest,
+  isLibp2pSyncResponse,
+  isPluginLoaded,
+  isTaskCategory,
+  isUserInitiatedConversation,
+  librarianAgent,
+  listPlugins,
+  listRegisteredHookTypes,
+  loadAgentAgentLoopScript,
+  loadAgentToolLoopScript,
+  loadPluginModule,
+  loadPluginModules,
+  loadUserPermissions,
+  matchAllToolCallings,
+  matchPattern,
+  matchToolCalling,
+  mcpClientConfigSchema,
+  mcpClientImpl,
+  mcpForwardConfigSchema,
+  mcpForwardImpl,
+  mergeAgentToolsIntoFrameworkConfig,
+  mergePermissionSets,
+  onApprovalRequest,
+  oracleAgent,
+  parseCheckpointRecord,
+  parseMemeloopUri,
+  pickAdapter,
+  planAgent,
+  pluginRegistry,
+  promptConcatStream,
+  registerBuiltinLoops,
+  registerBuiltinPromptPlugins,
+  registerBuiltinToolPlugins,
+  registerBuiltinTools,
+  registerHook,
+  registerImSessionBuiltinTools,
+  registerPluginHooks,
+  registerPluginTools,
+  registerToolDefinition,
+  registerToolParameterSchema,
+  remoteAgentConfigSchema,
+  remoteAgentImpl,
+  remoteAgentListImpl,
+  requestApproval,
+  resetAgentProfileRegistry,
+  resetLoopRegistry,
+  resolveAgentToolLoopTerminalState,
+  resolveApproval,
+  resolveCategory,
+  resolvePromptPluginMap,
+  resolveQuestionAnswer,
+  runAgentToolLoopTurn,
+  runPostProcessHooks,
+  runProcessPromptsHooks,
+  runResponseCompleteHooks,
+  runToolExecutedHooks,
+  runWithPluginRegistry,
+  saveUserPermissions,
+  schemaToToolContent,
+  serializeCheckpointRecord,
+  shouldCompact,
+  signDeviceBinding,
+  spawnAgentConfigSchema,
+  spawnAgentImpl,
+  streamRuntimeAgentReplyToIm,
+  syncCloudDevices,
+  taskToolConfigSchema,
+  taskToolImpl,
+  tiddlerToAgentDefinition,
+  todoWriteConfigSchema,
+  todoWriteImpl,
+  truncateToolSummary,
+  tryHandleImSlashCommand,
+  unloadAllPlugins,
+  unloadPlugin,
+  unregisterHook,
+  validatePluginManifest,
+  verifyDeviceBinding,
+  verifyDeviceConnectionGrant,
+  verifyDeviceRelayReservationToken
+};
+//# sourceMappingURL=index.js.map