@axiom-lattice/gateway 2.1.111 → 2.1.113

package/dist/index.js

@@ -94,7 +94,7 @@ __export(mcp_configs_exports, {
   testMcpServerTools: () => testMcpServerTools,
   updateMcpServerConfig: () => updateMcpServerConfig
 });
-function getTenantId12(request) {
+function getTenantId13(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -102,9 +102,9 @@ function getTenantId12(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getMcpServerConfigList(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const configs = await store2.getAllConfigs(tenantId);
     return {
@@ -128,10 +128,10 @@ async function getMcpServerConfigList(request, reply) {
   }
 }
 async function getMcpServerConfig(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -154,10 +154,10 @@ async function getMcpServerConfig(request, reply) {
   }
 }
 async function createMcpServerConfig(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -167,7 +167,7 @@ async function createMcpServerConfig(request, reply) {
         message: "MCP server configuration with this key already exists"
       };
     }
-    const id = body.id || (0, import_crypto6.randomUUID)();
+    const id = body.id || (0, import_crypto7.randomUUID)();
     const config = await store2.createConfig(tenantId, id, body);
     try {
       await connectAndRegisterTools(config);
@@ -193,11 +193,11 @@ async function createMcpServerConfig(request, reply) {
   }
 }
 async function updateMcpServerConfig(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -217,8 +217,8 @@ async function updateMcpServerConfig(request, reply) {
     }
     if (shouldReconnect) {
       try {
-        await import_core28.mcpManager.reconnectServer(key);
-        await import_core28.mcpManager.registerToolsToToolLattice(key, updated.selectedTools);
+        await import_core30.mcpManager.reconnectServer(key);
+        await import_core30.mcpManager.registerToolsToToolLattice(key, updated.selectedTools);
         await store2.updateConfig(tenantId, existing.id, { status: "connected" });
         updated.status = "connected";
       } catch (error) {
@@ -241,10 +241,10 @@ async function updateMcpServerConfig(request, reply) {
   }
 }
 async function deleteMcpServerConfig(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     let config = await store2.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
@@ -262,8 +262,8 @@ async function deleteMcpServerConfig(request, reply) {
       };
     }
     try {
-      if (import_core28.mcpManager.hasServer(configKey)) {
-        await import_core28.mcpManager.removeServer(configKey);
+      if (import_core30.mcpManager.hasServer(configKey)) {
+        await import_core30.mcpManager.removeServer(configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MCP manager:", error);
@@ -288,10 +288,10 @@ async function deleteMcpServerConfig(request, reply) {
   }
 }
 async function testMcpServerConnection(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -304,7 +304,7 @@ async function testMcpServerConnection(request, reply) {
     try {
       const testKey = `__test_${key}_${Date.now()}`;
       const connection = convertToConnection(config.config);
-      const { latency } = await import_core28.McpLatticeManager.testConnection(testKey, connection);
+      const { latency } = await import_core30.McpLatticeManager.testConnection(testKey, connection);
       return {
         success: true,
         message: "Connection test successful",
@@ -336,10 +336,10 @@ async function testMcpServerConnection(request, reply) {
   }
 }
 async function listMcpServerTools(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -349,10 +349,10 @@ async function listMcpServerTools(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (!import_core28.mcpManager.hasServer(key)) {
+    if (!import_core30.mcpManager.hasServer(key)) {
       await connectAndRegisterTools(config);
     }
-    const tools = await import_core28.mcpManager.getServerTools(key);
+    const tools = await import_core30.mcpManager.getServerTools(key);
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -369,10 +369,10 @@ async function listMcpServerTools(request, reply) {
   }
 }
 async function connectMcpServer(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -393,7 +393,7 @@ async function connectMcpServer(request, reply) {
     };
   } catch (error) {
     console.error("Failed to connect MCP server:", error);
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (config) {
@@ -406,10 +406,10 @@ async function connectMcpServer(request, reply) {
   }
 }
 async function disconnectMcpServer(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -419,8 +419,8 @@ async function disconnectMcpServer(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (import_core28.mcpManager.hasServer(key)) {
-      await import_core28.mcpManager.removeServer(key);
+    if (import_core30.mcpManager.hasServer(key)) {
+      await import_core30.mcpManager.removeServer(key);
     }
     const updated = await store2.updateConfig(tenantId, config.id, {
       status: "disconnected"
@@ -450,7 +450,7 @@ async function testMcpServerTools(request, reply) {
     }
     const testKey = `__test_${Date.now()}`;
     const connection = convertToConnection(body.config);
-    const { tools } = await import_core28.McpLatticeManager.testConnection(testKey, connection);
+    const { tools } = await import_core30.McpLatticeManager.testConnection(testKey, connection);
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -487,9 +487,9 @@ function convertToConnection(config) {
 }
 async function connectAndRegisterTools(config) {
   const connection = convertToConnection(config.config);
-  import_core28.mcpManager.addServer(config.key, connection);
-  await import_core28.mcpManager.connect();
-  await import_core28.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
+  import_core30.mcpManager.addServer(config.key, connection);
+  await import_core30.mcpManager.connect();
+  await import_core30.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
 }
 function registerMcpServerConfigRoutes(app2) {
   app2.get("/api/mcp-servers", getMcpServerConfigList);
@@ -503,12 +503,12 @@ function registerMcpServerConfigRoutes(app2) {
   app2.post("/api/mcp-servers/:key/disconnect", disconnectMcpServer);
   app2.post("/api/mcp-servers/test-tools", testMcpServerTools);
 }
-var import_core28, import_crypto6;
+var import_core30, import_crypto7;
 var init_mcp_configs = __esm({
   "src/controllers/mcp-configs.ts"() {
     "use strict";
-    import_core28 = require("@axiom-lattice/core");
-    import_crypto6 = require("crypto");
+    import_core30 = require("@axiom-lattice/core");
+    import_crypto7 = require("crypto");
   }
 });
 
@@ -1290,7 +1290,7 @@ async function handleTasksSend(request, reply) {
   taskStore.set(taskId, record);
   let agent;
   try {
-    agent = import_core38.agentInstanceManager.getAgent({
+    agent = import_core54.agentInstanceManager.getAgent({
       assistant_id: assistantId,
       thread_id: threadId,
       tenant_id: tenantId,
@@ -1382,7 +1382,7 @@ async function handleTasksCancel(request, reply) {
     return;
   }
   try {
-    const agent = import_core38.agentInstanceManager.getAgent({
+    const agent = import_core54.agentInstanceManager.getAgent({
       assistant_id: record.assistantId,
       thread_id: record.threadId,
       tenant_id: record.tenantId,
@@ -1419,7 +1419,7 @@ async function handleTasksStream(request, reply) {
   }
   let agent;
   try {
-    agent = import_core38.agentInstanceManager.getAgent({
+    agent = import_core54.agentInstanceManager.getAgent({
       assistant_id: record.assistantId,
       thread_id: record.threadId,
       tenant_id: record.tenantId,
@@ -1614,12 +1614,12 @@ function registerA2ARoutes(app2) {
     handleApiKeyRotate
   );
 }
-var import_uuid10, import_core38, import_protocols4, taskStore, _a2aKeyStore, _storeKeyMap;
+var import_uuid10, import_core54, import_protocols4, taskStore, _a2aKeyStore, _storeKeyMap;
 var init_a2a = __esm({
   "src/routes/a2a.ts"() {
     "use strict";
     import_uuid10 = require("uuid");
-    import_core38 = require("@axiom-lattice/core");
+    import_core54 = require("@axiom-lattice/core");
     import_protocols4 = require("@axiom-lattice/protocols");
     taskStore = /* @__PURE__ */ new Map();
     _a2aKeyStore = null;
@@ -1632,12 +1632,12 @@ var resources_exports = {};
 __export(resources_exports, {
   ResourceController: () => ResourceController
 });
-var import_bcryptjs, import_core39, ResourceController;
+var import_bcryptjs, import_core55, ResourceController;
 var init_resources = __esm({
   "src/controllers/resources.ts"() {
     "use strict";
     import_bcryptjs = __toESM(require("bcryptjs"));
-    import_core39 = require("@axiom-lattice/core");
+    import_core55 = require("@axiom-lattice/core");
     init_mime();
     ResourceController = class {
       constructor(deps) {
@@ -1652,14 +1652,14 @@ var init_resources = __esm({
         if (!workspaceId || !projectId) {
           return reply.status(400).send({ error: "x-workspace-id and x-project-id headers required" });
         }
-        const payload = (0, import_core39.createSharePayload)(
+        const payload = (0, import_core55.createSharePayload)(
           tenantId,
           workspaceId,
           projectId,
           userId,
           body
         );
-        const token = (0, import_core39.generateToken)();
+        const token = (0, import_core55.generateToken)();
         try {
           await this.deps.store.create({ ...payload, token });
           this.deps.logger.info(
@@ -1811,7 +1811,7 @@ var init_resources = __esm({
             resourcePath: subPath
           }, subPath, ext, request, reply);
         }
-        const volume = (0, import_core39.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
+        const volume = (0, import_core55.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
         return this._resolveAndServe(
           volume,
           subPath,
@@ -2261,6 +2261,20 @@ var createRun = async (request, reply) => {
       project_id,
       custom_run_config: mergedConfig
     });
+    if (background) {
+      const messageInput = message_id ? { ...input, id: message_id } : input;
+      const result = await agent.addMessage({
+        input: messageInput,
+        command,
+        custom_run_config: mergedConfig
+      }, mode);
+      reply.status(202).send({
+        success: true,
+        messageId: result.messageId,
+        queued: true
+      });
+      return;
+    }
     if (streaming) {
       reply.hijack();
       reply.raw.writeHead(200, {
@@ -2346,8 +2360,13 @@ var resumeStream = async (request, reply) => {
         workspace_id,
         project_id
       });
-      const stream = agent.chunkStream(message_id, [import_protocols.MessageChunkTypes.THREAD_IDLE]);
+      const stream = agent.chunkStream(message_id, []);
+      let closed = false;
+      request.raw.on("close", () => {
+        closed = true;
+      });
       for await (const chunk of stream) {
+        if (closed || reply.raw.destroyed) break;
         reply.raw.write(`data: ${JSON.stringify(chunk)}
 
 `);
@@ -4332,6 +4351,8 @@ async function getAllWorkflowRuns(request, reply) {
     });
   }
 }
+var INBOX_DEFAULT_PAGE_SIZE = 20;
+var INBOX_MAX_PAGE_SIZE = 100;
 async function getInboxItems(request, reply) {
   const tenantId = getTenantId7(request);
   try {
@@ -4349,10 +4370,30 @@ async function getInboxItems(request, reply) {
       }
     } catch {
     }
-    const runs = await store2.getWorkflowRunsByTenantId(tenantId);
-    const pendingRuns = runs.filter((r) => r.status === "interrupted");
+    const { page: pageParam, pageSize: pageSizeParam } = request.query;
+    const paged = pageParam !== void 0 || pageSizeParam !== void 0;
+    const page = Math.max(1, parseInt(pageParam ?? "", 10) || 1);
+    const pageSize = Math.min(INBOX_MAX_PAGE_SIZE, Math.max(1, parseInt(pageSizeParam ?? "", 10) || INBOX_DEFAULT_PAGE_SIZE));
+    let pendingRuns;
+    let total;
+    if (paged) {
+      const result = await store2.queryWorkflowRuns(tenantId, {
+        status: "interrupted",
+        limit: pageSize,
+        offset: (page - 1) * pageSize
+      });
+      pendingRuns = result.records;
+      total = result.total;
+    } else {
+      const result = await store2.queryWorkflowRuns(tenantId, { status: "interrupted" });
+      pendingRuns = result.records;
+    }
     if (pendingRuns.length === 0) {
-      return { success: true, message: "No pending workflows", data: { records: [] } };
+      return {
+        success: true,
+        message: "No pending workflows",
+        data: paged ? { records: [], total, page, pageSize } : { records: [] }
+      };
     }
     const checkPromises = pendingRuns.map(async (r) => {
       try {
@@ -4409,13 +4450,10 @@ async function getInboxItems(request, reply) {
     });
     const results = await Promise.all(checkPromises);
     const inboxItems = results.flat();
-    inboxItems.sort(
-      (a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime()
-    );
     return {
       success: true,
       message: "Successfully retrieved inbox items",
-      data: { records: inboxItems }
+      data: paged ? { records: inboxItems, total, page, pageSize } : { records: inboxItems }
     };
   } catch (error) {
     request.log.error(error, "Failed to get inbox items");
@@ -4648,6 +4686,54 @@ async function replyInboxTask(request, reply) {
     });
   }
 }
+async function abortWorkflowRun(request, reply) {
+  try {
+    const { runId } = request.params;
+    const tenantId = getTenantId7(request);
+    const store2 = getTrackingStore();
+    if (!store2) {
+      return reply.status(404).send({
+        success: false,
+        message: "No workflow tracking store configured"
+      });
+    }
+    const run = await store2.getWorkflowRun(runId);
+    if (!run) {
+      return reply.status(404).send({
+        success: false,
+        message: "Workflow run not found"
+      });
+    }
+    await store2.updateWorkflowRun(runId, {
+      status: "cancelled",
+      errorMessage: "Aborted by user",
+      completedAt: /* @__PURE__ */ new Date()
+    }).catch(() => {
+    });
+    const workspace_id = request.headers["x-workspace-id"];
+    const project_id = request.headers["x-project-id"];
+    const agent = import_core15.agentInstanceManager.getAgent({
+      assistant_id: run.assistantId,
+      thread_id: run.threadId,
+      tenant_id: tenantId,
+      workspace_id,
+      project_id
+    });
+    await agent.abort();
+    (0, import_core15.abortWorkflowRun)(runId);
+    return reply.status(200).send({
+      success: true,
+      message: "Workflow aborted",
+      data: { runId, assistantId: run.assistantId, threadId: run.threadId }
+    });
+  } catch (error) {
+    request.log.error(error, "Failed to abort workflow run");
+    return reply.status(500).send({
+      success: false,
+      message: `Abort failed: ${error.message}`
+    });
+  }
+}
 
 // src/controllers/personal-assistant.ts
 var import_core16 = require("@axiom-lattice/core");
@@ -4911,11 +4997,339 @@ async function completeTask(request, reply) {
   }
 }
 
-// src/controllers/middleware-types.ts
+// src/services/ExportImportService.ts
 var import_core18 = require("@axiom-lattice/core");
+var import_crypto4 = require("crypto");
+var exportJobs = /* @__PURE__ */ new Map();
+var JOB_TTL_MS = 60 * 60 * 1e3;
+function cleanExpiredJobs() {
+  const now = Date.now();
+  for (const [id, entry] of exportJobs) {
+    if (now - entry.createdAt > JOB_TTL_MS) {
+      exportJobs.delete(id);
+    }
+  }
+}
+var ExportImportService = class {
+  constructor() {
+    this.registry = import_core18.ExportableEntityRegistry.getInstance();
+  }
+  /**
+   * Preview an export: check which types would be auto-included, which dependencies are missing.
+   */
+  async exportPreview(tenantId, selectedTypes) {
+    const allDefs = this.registry.getAll();
+    const expanded = import_core18.DependencyResolver.expandCascade(allDefs, selectedTypes);
+    const cascadeAdditions = expanded.filter((t) => !selectedTypes.includes(t));
+    const deps = import_core18.DependencyResolver.computeDependencies(allDefs, expanded);
+    const registeredTypes = new Set(allDefs.map((d) => d.entityType));
+    const missingDependencies = deps.missing.filter((t) => registeredTypes.has(t));
+    return { missingDependencies, cascadeAdditions };
+  }
+  /**
+   * Generate a full ExportBundle for the given tenant and entity types.
+   * Stores the bundle in-memory and returns a jobId for download.
+   */
+  async export(tenantId, entityTypes, entityIds) {
+    const allDefs = this.registry.getAll();
+    const expanded = import_core18.DependencyResolver.expandCascade(allDefs, entityTypes);
+    const finalTypes = [.../* @__PURE__ */ new Set([...expanded, ...entityTypes])];
+    const dependencyOrder = import_core18.DependencyResolver.resolveOrder(
+      finalTypes.map((t) => this.registry.get(t))
+    );
+    const entities = {};
+    let exportCounter = 0;
+    for (const type of dependencyOrder) {
+      const def = this.registry.get(type);
+      let raw = await def.listForExport(tenantId);
+      if (entityIds && entityIds[type] && entityIds[type].length > 0) {
+        const idSet = new Set(entityIds[type]);
+        raw = raw.filter((e) => idSet.has(e.data.id));
+      }
+      entities[type] = raw.map((e) => ({
+        ...e,
+        _exportId: `exp-${type}-${String(++exportCounter).padStart(3, "0")}`,
+        data: this.sanitizeEntityData(e.data)
+      }));
+    }
+    const rawIdToExportId = /* @__PURE__ */ new Map();
+    for (const [, entityList] of Object.entries(entities)) {
+      for (const entity of entityList) {
+        const rawId = entity.data.id;
+        if (rawId) {
+          rawIdToExportId.set(rawId, entity._exportId);
+        }
+      }
+    }
+    for (const [type, entityList] of Object.entries(entities)) {
+      const def = this.registry.get(type);
+      const refFields = def.referenceFields || {};
+      for (const entity of entityList) {
+        for (const [fieldName, refEntityType] of Object.entries(refFields)) {
+          const rawValue = entity.data[fieldName];
+          if (typeof rawValue === "string" && rawValue) {
+            const exportId = rawIdToExportId.get(rawValue);
+            if (exportId) {
+              entity.data[fieldName] = `@${refEntityType}/${exportId}`;
+            }
+          }
+        }
+      }
+    }
+    const bundle = {
+      version: 1,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceTenantId: tenantId,
+      entities,
+      dependencyOrder,
+      _warning: "This file contains plaintext secrets (passwords, API keys, tokens). Store it securely and delete after import."
+    };
+    const jobId = (0, import_crypto4.randomUUID)();
+    exportJobs.set(jobId, { bundle, tenantId, createdAt: Date.now() });
+    return { jobId, bundle };
+  }
+  /**
+   * Retrieve a previously generated export bundle by jobId with tenant validation.
+   */
+  getExportJob(jobId, tenantId) {
+    cleanExpiredJobs();
+    const entry = exportJobs.get(jobId);
+    if (!entry || entry.tenantId !== tenantId) return void 0;
+    return entry.bundle;
+  }
+  /**
+   * Preview import: validate bundle and detect conflicts.
+   */
+  async previewImport(tenantId, bundle) {
+    this.validateBundle(bundle);
+    const allConflicts = [];
+    const allInsertions = [];
+    const allErrors = [];
+    for (const [entityType, entities] of Object.entries(bundle.entities)) {
+      if (entities.length === 0) continue;
+      try {
+        const def = this.registry.get(entityType);
+        const result = await def.previewImport(tenantId, entities);
+        allConflicts.push(...result.conflicts);
+        allInsertions.push(...result.insertions);
+        allErrors.push(...result.errors);
+      } catch (err) {
+        for (const entity of entities) {
+          allErrors.push({
+            _exportId: entity._exportId,
+            entityType,
+            error: `Preview failed: ${err.message}`
+          });
+        }
+      }
+    }
+    return { conflicts: allConflicts, insertions: allInsertions, errors: allErrors };
+  }
+  /**
+   * Apply import: create entities in dependency order with ID remapping.
+   */
+  async applyImport(tenantId, bundle, resolutions) {
+    this.validateBundle(bundle);
+    const results = [];
+    const idMap = {};
+    const skillIdRemap = {};
+    for (const entityType of bundle.dependencyOrder) {
+      const entities = bundle.entities[entityType];
+      if (!entities || entities.length === 0) continue;
+      const def = this.registry.get(entityType);
+      const remapper = new import_core18.IdRemapper(idMap);
+      for (const entity of entities) {
+        const resolution = resolutions[entity._exportId];
+        if (resolution?.action === "skip") {
+          results.push({ _exportId: entity._exportId, entityType, status: "skipped" });
+          continue;
+        }
+        try {
+          const remappedData = remapper.remapReferences(entity.data);
+          if (entityType === "agent" && Object.keys(skillIdRemap).length > 0) {
+            const skillRemapper = new import_core18.IdRemapper({});
+            remappedData.graphDefinition = skillRemapper.remapSkillIds(
+              remappedData.graphDefinition || {},
+              skillIdRemap
+            );
+          }
+          if (resolution?.action === "rename" && resolution.newId) {
+            remappedData.id = resolution.newId;
+          }
+          const entityWithRemappedData = { ...entity, data: remappedData };
+          const { newId } = await def.applyImport(
+            tenantId,
+            entityWithRemappedData,
+            resolution ?? { _exportId: entity._exportId, action: "overwrite" }
+          );
+          if (newId) {
+            idMap[entity._exportId] = newId;
+            if (entityType === "skill" && newId) {
+              const oldSkillId = remappedData.id;
+              if (oldSkillId !== newId) {
+                skillIdRemap[oldSkillId] = newId;
+              }
+            }
+            results.push({
+              _exportId: entity._exportId,
+              entityType,
+              status: resolution?.action === "overwrite" ? "updated" : "created",
+              newId
+            });
+          }
+        } catch (err) {
+          results.push({
+            _exportId: entity._exportId,
+            entityType,
+            status: "failed",
+            error: err.message
+          });
+        }
+      }
+    }
+    return { results, idMap };
+  }
+  /**
+   * List all registered exportable types (for frontend).
+   */
+  listExportableTypes() {
+    return this.registry.listTypes();
+  }
+  validateBundle(bundle) {
+    if (bundle.version !== 1) {
+      throw new Error(`Unsupported bundle version: ${bundle.version}. Expected: 1`);
+    }
+    if (!bundle.entities || typeof bundle.entities !== "object") {
+      throw new Error("Invalid bundle: missing entities");
+    }
+    if (!Array.isArray(bundle.dependencyOrder)) {
+      throw new Error("Invalid bundle: missing dependencyOrder");
+    }
+  }
+  sanitizeEntityData(data) {
+    const sanitized = { ...data };
+    delete sanitized.tenantId;
+    delete sanitized.createdAt;
+    delete sanitized.updatedAt;
+    return sanitized;
+  }
+};
+
+// src/controllers/export-import.ts
+var import_core19 = require("@axiom-lattice/core");
+var service = new ExportImportService();
+function getTenantId10(request) {
+  return request.user?.tenantId || request.headers["x-tenant-id"] || "default";
+}
+async function getExportableTypes(_request, reply) {
+  const types = service.listExportableTypes();
+  return reply.send({ success: true, data: types });
+}
+async function exportConfig(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  const { entityTypes, entityIds } = request.body;
+  if (!Array.isArray(entityTypes) || entityTypes.length === 0) {
+    return reply.status(400).send({ success: false, message: "entityTypes must be a non-empty array" });
+  }
+  const preview = await service.exportPreview(tenantId, entityTypes);
+  if (preview.missingDependencies.length > 0 || preview.cascadeAdditions.length > 0) {
+    return reply.send({
+      success: true,
+      data: {
+        needsConfirmation: true,
+        missingDependencies: preview.missingDependencies,
+        cascadeAdditions: preview.cascadeAdditions
+      }
+    });
+  }
+  const { jobId, bundle } = await service.export(tenantId, entityTypes, entityIds);
+  return reply.send({
+    success: true,
+    data: {
+      jobId,
+      summary: Object.fromEntries(
+        Object.entries(bundle.entities).map(([type, entities]) => [type, entities.length])
+      )
+    }
+  });
+}
+async function exportConfigConfirm(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  const { entityTypes, entityIds } = request.body;
+  const { jobId, bundle } = await service.export(tenantId, entityTypes, entityIds);
+  return reply.send({
+    success: true,
+    data: {
+      jobId,
+      summary: Object.fromEntries(
+        Object.entries(bundle.entities).map(([type, entities]) => [type, entities.length])
+      )
+    }
+  });
+}
+async function previewEntities(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  const { entityTypes } = request.body;
+  try {
+    const registry = import_core19.ExportableEntityRegistry.getInstance();
+    const result = {};
+    for (const type of entityTypes) {
+      const def = registry.get(type);
+      const entities = await def.listForExport(tenantId);
+      result[type] = entities.map((e) => ({
+        id: e.data.id,
+        name: e.data.name || e.data.id,
+        description: e.data.description
+      }));
+    }
+    return reply.send({ success: true, data: result });
+  } catch (err) {
+    return reply.status(400).send({ success: false, message: err.message });
+  }
+}
+async function downloadExport(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  const bundle = service.getExportJob(request.params.jobId, tenantId);
+  if (!bundle) {
+    return reply.status(404).send({ success: false, message: "Export job not found or expired" });
+  }
+  return reply.header("Content-Type", "application/json").header("Content-Disposition", `attachment; filename="tenant-export-${bundle.sourceTenantId}.json"`).send({ success: true, data: bundle });
+}
+async function importPreview(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  const { bundle } = request.body;
+  if (!bundle) {
+    return reply.status(400).send({ success: false, message: "No bundle provided in request body" });
+  }
+  try {
+    const preview = await service.previewImport(tenantId, bundle);
+    return reply.send({ success: true, data: preview });
+  } catch (err) {
+    return reply.status(400).send({
+      success: false,
+      message: `Invalid export file: ${err.message}`
+    });
+  }
+}
+async function importApply(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  try {
+    const { bundle, resolutions } = request.body;
+    const result = await service.applyImport(tenantId, bundle, resolutions);
+    return reply.send({ success: true, data: result });
+  } catch (err) {
+    return reply.status(400).send({
+      success: false,
+      message: `Import failed: ${err.message}`
+    });
+  }
+}
+
+// src/controllers/middleware-types.ts
+var import_core20 = require("@axiom-lattice/core");
 function middlewareTypesRoutes(fastify2) {
   fastify2.get("/api/middleware-types", async (_request, reply) => {
-    const metas = import_core18.PluginRegistry.listMeta();
+    const metas = import_core20.PluginRegistry.listMeta();
     return reply.send(metas);
   });
 }
@@ -5261,7 +5675,7 @@ var getHealthSchema = {
 };
 
 // src/controllers/thread_status.ts
-var import_core19 = require("@axiom-lattice/core");
+var import_core21 = require("@axiom-lattice/core");
 async function removePendingMessageHandler(request, reply) {
   try {
     const { assistant_id, thread_id, message_id } = request.params;
@@ -5274,7 +5688,7 @@ async function removePendingMessageHandler(request, reply) {
     if (!assistant_id) {
       return reply.code(400).send({ error: "Missing assistant_id parameter" });
     }
-    const agent = import_core19.agentInstanceManager.getAgent({
+    const agent = import_core21.agentInstanceManager.getAgent({
       assistant_id,
       thread_id,
       tenant_id,
@@ -5308,7 +5722,7 @@ async function removePendingMessageHandler(request, reply) {
 }
 
 // src/services/sandbox_service.ts
-var import_core20 = require("@axiom-lattice/core");
+var import_core22 = require("@axiom-lattice/core");
 var ERROR_HTML = `<!DOCTYPE html>
 <html lang="zh-CN">
 <head>
@@ -5420,7 +5834,7 @@ var ERROR_HTML = `<!DOCTYPE html>
 </html>`;
 var SandboxService = class {
   getFilesystemVmIsolation(tenantId, assistantId) {
-    const agentLattice = import_core20.agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
+    const agentLattice = import_core22.agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
     if (!agentLattice) {
       return null;
     }
@@ -5434,9 +5848,9 @@ var SandboxService = class {
   computeSandboxName(assistantId, threadId, vmIsolation, tenantId, workspaceId, projectId) {
     switch (vmIsolation) {
       case "agent":
-        return (0, import_core20.normalizeSandboxName)(`${tenantId ?? "default"}-${assistantId}`);
+        return (0, import_core22.normalizeSandboxName)(`${tenantId ?? "default"}-${assistantId}`);
       case "project":
-        return (0, import_core20.normalizeSandboxName)(
+        return (0, import_core22.normalizeSandboxName)(
           `${tenantId ?? "default"}-${workspaceId ?? "default"}-${projectId ?? "default"}`
         );
       case "global":
@@ -5492,7 +5906,7 @@ var SandboxService = class {
 var sandboxService = new SandboxService();
 
 // src/controllers/sandbox.ts
-var import_core21 = require("@axiom-lattice/core");
+var import_core23 = require("@axiom-lattice/core");
 init_mime();
 function registerSandboxProxyRoutes(app2) {
   app2.post(
@@ -5507,7 +5921,7 @@ function registerSandboxProxyRoutes(app2) {
       }
       const workspaceId = request.headers["x-workspace-id"];
       const projectId = request.headers["x-project-id"];
-      const sandboxManager = (0, import_core21.getSandBoxManager)();
+      const sandboxManager = (0, import_core23.getSandBoxManager)();
       const sandbox = await sandboxManager.getSandboxFromConfig({
         assistant_id: assistantId,
         thread_id: threadId,
@@ -5555,7 +5969,7 @@ function registerSandboxProxyRoutes(app2) {
       }
       const workspaceId = request.headers["x-workspace-id"];
       const projectId = request.headers["x-project-id"];
-      const sandboxManager = (0, import_core21.getSandBoxManager)();
+      const sandboxManager = (0, import_core23.getSandBoxManager)();
       const sandbox = await sandboxManager.getSandboxFromConfig({
         assistant_id: assistantId,
         thread_id: threadId,
@@ -5588,15 +6002,15 @@ function registerSandboxProxyRoutes(app2) {
 // src/controllers/workspace.ts
 var fs = __toESM(require("fs/promises"));
 var path = __toESM(require("path"));
-var import_core22 = require("@axiom-lattice/core");
-var import_core23 = require("@axiom-lattice/core");
 var import_core24 = require("@axiom-lattice/core");
+var import_core25 = require("@axiom-lattice/core");
+var import_core26 = require("@axiom-lattice/core");
 var import_uuid3 = require("uuid");
 init_mime();
 var WorkspaceController = class {
   constructor() {
-    this.workspaceStore = (0, import_core22.getStoreLattice)("default", "workspace").store;
-    this.projectStore = (0, import_core22.getStoreLattice)("default", "project").store;
+    this.workspaceStore = (0, import_core24.getStoreLattice)("default", "workspace").store;
+    this.projectStore = (0, import_core24.getStoreLattice)("default", "project").store;
   }
   getTenantId(request) {
     const userTenantId = request.user?.tenantId;
@@ -5730,7 +6144,7 @@ var WorkspaceController = class {
     }
     console.log(`[getBackend] storageType=${workspace.storageType} filePath=${filePath}`);
     if (workspace.storageType === "sandbox") {
-      const sandboxManager = (0, import_core24.getSandBoxManager)();
+      const sandboxManager = (0, import_core26.getSandBoxManager)();
       const volumeConfig = {
         assistant_id: assistantId || "",
         thread_id: "",
@@ -5748,7 +6162,7 @@ var WorkspaceController = class {
       const sandbox = await sandboxManager.getSandboxFromConfig(volumeConfig);
       console.log(`[getBackend] sandbox acquired, name=${sandbox.name || "unknown"}`);
       return {
-        backend: new import_core23.SandboxFilesystem({
+        backend: new import_core25.SandboxFilesystem({
           sandboxInstance: sandbox
         }),
         workspace
@@ -5756,7 +6170,7 @@ var WorkspaceController = class {
     } else {
       console.log(`[getBackend] using FilesystemBackend rootDir=/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`);
       return {
-        backend: new import_core23.FilesystemBackend({
+        backend: new import_core25.FilesystemBackend({
           rootDir: `/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`,
           virtualMode: true
         }),
@@ -5808,7 +6222,7 @@ var WorkspaceController = class {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId, assistantId);
       const resolvedPath = filePath;
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core24.getSandBoxManager)();
+        const sandboxManager = (0, import_core26.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -5862,7 +6276,7 @@ var WorkspaceController = class {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId, assistantId);
       const resolvedPath = filePath;
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core24.getSandBoxManager)();
+        const sandboxManager = (0, import_core26.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -6003,7 +6417,7 @@ var WorkspaceController = class {
         return reply.status(400).send({ success: false, error: "Invalid path parameter" });
       }
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core24.getSandBoxManager)();
+        const sandboxManager = (0, import_core26.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -6111,9 +6525,9 @@ function registerWorkspaceRoutes(app2) {
 }
 
 // src/controllers/database-configs.ts
-var import_core25 = require("@axiom-lattice/core");
-var import_crypto4 = require("crypto");
-function getTenantId10(request) {
+var import_core27 = require("@axiom-lattice/core");
+var import_crypto5 = require("crypto");
+function getTenantId11(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -6121,9 +6535,9 @@ function getTenantId10(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getDatabaseConfigList(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     const configs = await store2.getAllConfigs(tenantId);
     console.log("Backend: getAllConfigs returned:", configs);
@@ -6151,10 +6565,10 @@ async function getDatabaseConfigList(request, reply) {
   }
 }
 async function getDatabaseConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6177,10 +6591,10 @@ async function getDatabaseConfig(request, reply) {
   }
 }
 async function createDatabaseConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -6190,10 +6604,10 @@ async function createDatabaseConfig(request, reply) {
         message: "Database configuration with this key already exists"
       };
     }
-    const id = body.id || (0, import_crypto4.randomUUID)();
+    const id = body.id || (0, import_crypto5.randomUUID)();
     const config = await store2.createConfig(tenantId, id, body);
     try {
-      import_core25.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
+      import_core27.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register database:", error);
     }
@@ -6212,11 +6626,11 @@ async function createDatabaseConfig(request, reply) {
   }
 }
 async function updateDatabaseConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -6235,7 +6649,7 @@ async function updateDatabaseConfig(request, reply) {
     }
     if (updates.config) {
       try {
-        import_core25.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
+        import_core27.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register database:", error);
       }
@@ -6254,10 +6668,10 @@ async function updateDatabaseConfig(request, reply) {
   }
 }
 async function deleteDatabaseConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     console.log("Delete request - keyOrId:", keyOrId);
     let config = await store2.getConfigByKey(tenantId, keyOrId);
@@ -6284,8 +6698,8 @@ async function deleteDatabaseConfig(request, reply) {
       };
     }
     try {
-      if (import_core25.sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
-        await import_core25.sqlDatabaseManager.removeDatabase(tenantId, configKey);
+      if (import_core27.sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
+        await import_core27.sqlDatabaseManager.removeDatabase(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from SqlDatabaseManager:", error);
@@ -6303,10 +6717,10 @@ async function deleteDatabaseConfig(request, reply) {
   }
 }
 async function testDatabaseConnection(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6317,16 +6731,16 @@ async function testDatabaseConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core25.sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
+    import_core27.sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
     const startTime = Date.now();
-    const db = await import_core25.sqlDatabaseManager.getDatabase(tenantId, testKey);
+    const db = await import_core27.sqlDatabaseManager.getDatabase(tenantId, testKey);
     try {
       await db.connect();
       await db.listTables();
       const latency = Date.now() - startTime;
       await new Promise((resolve) => setTimeout(resolve, 100));
       await db.disconnect();
-      await import_core25.sqlDatabaseManager.removeDatabase(tenantId, testKey);
+      await import_core27.sqlDatabaseManager.removeDatabase(tenantId, testKey);
       return {
         success: true,
         message: "Connection test successful",
@@ -6338,7 +6752,7 @@ async function testDatabaseConnection(request, reply) {
     } catch (error) {
       try {
         await db.disconnect();
-        await import_core25.sqlDatabaseManager.removeDatabase(tenantId, testKey);
+        await import_core27.sqlDatabaseManager.removeDatabase(tenantId, testKey);
       } catch {
       }
       return {
@@ -6390,9 +6804,9 @@ function registerDatabaseConfigRoutes(app2) {
 }
 
 // src/controllers/metrics-configs.ts
-var import_core26 = require("@axiom-lattice/core");
-var import_crypto5 = require("crypto");
-function getTenantId11(request) {
+var import_core28 = require("@axiom-lattice/core");
+var import_crypto6 = require("crypto");
+function getTenantId12(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -6400,9 +6814,9 @@ function getTenantId11(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getMetricsServerConfigList(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const configs = await store2.getAllConfigs(tenantId);
     return {
@@ -6426,10 +6840,10 @@ async function getMetricsServerConfigList(request, reply) {
   }
 }
 async function getMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6452,10 +6866,10 @@ async function getMetricsServerConfig(request, reply) {
   }
 }
 async function createMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -6472,7 +6886,7 @@ async function createMetricsServerConfig(request, reply) {
         message: "selectedDataSources is required for semantic metrics servers"
       };
     }
-    const id = body.id || (0, import_crypto5.randomUUID)();
+    const id = body.id || (0, import_crypto6.randomUUID)();
     const configData = {
       key: body.key,
       name: body.name,
@@ -6484,7 +6898,7 @@ async function createMetricsServerConfig(request, reply) {
     };
     const config = await store2.createConfig(tenantId, id, configData);
     try {
-      import_core26.metricsServerManager.registerServer(tenantId, config.key, config.config);
+      import_core28.metricsServerManager.registerServer(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register metrics server:", error);
     }
@@ -6503,11 +6917,11 @@ async function createMetricsServerConfig(request, reply) {
   }
 }
 async function updateMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -6535,7 +6949,7 @@ async function updateMetricsServerConfig(request, reply) {
     }
     if (updates.config) {
       try {
-        import_core26.metricsServerManager.registerServer(tenantId, updated.key, updated.config);
+        import_core28.metricsServerManager.registerServer(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register metrics server:", error);
       }
@@ -6554,10 +6968,10 @@ async function updateMetricsServerConfig(request, reply) {
   }
 }
 async function deleteMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     let config = await store2.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
@@ -6582,8 +6996,8 @@ async function deleteMetricsServerConfig(request, reply) {
       };
     }
     try {
-      if (import_core26.metricsServerManager.hasServer(tenantId, configKey)) {
-        import_core26.metricsServerManager.removeServer(tenantId, configKey);
+      if (import_core28.metricsServerManager.hasServer(tenantId, configKey)) {
+        import_core28.metricsServerManager.removeServer(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MetricsServerManager:", error);
@@ -6601,10 +7015,10 @@ async function deleteMetricsServerConfig(request, reply) {
   }
 }
 async function testMetricsServerConnection(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6615,11 +7029,11 @@ async function testMetricsServerConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core26.metricsServerManager.registerServer(tenantId, testKey, config.config);
+    import_core28.metricsServerManager.registerServer(tenantId, testKey, config.config);
     try {
-      const client = await import_core26.metricsServerManager.getClient(tenantId, testKey);
+      const client = await import_core28.metricsServerManager.getClient(tenantId, testKey);
       const result = await client.testConnection();
-      import_core26.metricsServerManager.removeServer(tenantId, testKey);
+      import_core28.metricsServerManager.removeServer(tenantId, testKey);
       return {
         success: true,
         message: result.connected ? "Connection test successful" : "Connection test failed",
@@ -6627,7 +7041,7 @@ async function testMetricsServerConnection(request, reply) {
       };
     } catch (error) {
       try {
-        import_core26.metricsServerManager.removeServer(tenantId, testKey);
+        import_core28.metricsServerManager.removeServer(tenantId, testKey);
       } catch {
       }
       return {
@@ -6652,10 +7066,10 @@ async function testMetricsServerConnection(request, reply) {
   }
 }
 async function listAvailableMetrics(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6665,10 +7079,10 @@ async function listAvailableMetrics(request, reply) {
         message: "Metrics server configuration not found"
       };
     }
-    if (!import_core26.metricsServerManager.hasServer(tenantId, key)) {
-      import_core26.metricsServerManager.registerServer(tenantId, key, config.config);
+    if (!import_core28.metricsServerManager.hasServer(tenantId, key)) {
+      import_core28.metricsServerManager.registerServer(tenantId, key, config.config);
     }
-    const client = await import_core26.metricsServerManager.getClient(tenantId, key);
+    const client = await import_core28.metricsServerManager.getClient(tenantId, key);
     const metrics = await client.listMetrics();
     return {
       success: true,
@@ -6690,11 +7104,11 @@ async function listAvailableMetrics(request, reply) {
   }
 }
 async function queryMetricsData(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   const { metricName, startTime, endTime, step, labels } = request.body;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6711,10 +7125,10 @@ async function queryMetricsData(request, reply) {
         message: "metricName is required"
       };
     }
-    if (!import_core26.metricsServerManager.hasServer(tenantId, key)) {
-      import_core26.metricsServerManager.registerServer(tenantId, key, config.config);
+    if (!import_core28.metricsServerManager.hasServer(tenantId, key)) {
+      import_core28.metricsServerManager.registerServer(tenantId, key, config.config);
     }
-    const client = await import_core26.metricsServerManager.getClient(tenantId, key);
+    const client = await import_core28.metricsServerManager.getClient(tenantId, key);
     const result = await client.queryMetricData(metricName, {
       startTime,
       endTime,
@@ -6738,10 +7152,10 @@ async function queryMetricsData(request, reply) {
   }
 }
 async function getDataSources(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6759,7 +7173,7 @@ async function getDataSources(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core26.SemanticMetricsClient(semanticConfig);
+    const client = new import_core28.SemanticMetricsClient(semanticConfig);
     const allDatasources = await client.getDataSources();
     const selectedIds = semanticConfig.selectedDataSources || [];
     const filteredDatasources = selectedIds.length > 0 ? allDatasources.filter((ds) => selectedIds.includes(String(ds.id))) : allDatasources;
@@ -6779,10 +7193,10 @@ async function getDataSources(request, reply) {
   }
 }
 async function getDatasourceMetrics(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key, datasourceId } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6800,7 +7214,7 @@ async function getDatasourceMetrics(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core26.SemanticMetricsClient(semanticConfig);
+    const client = new import_core28.SemanticMetricsClient(semanticConfig);
     const metrics = await client.getDatasourceMetrics(datasourceId);
     return {
       success: true,
@@ -6816,11 +7230,11 @@ async function getDatasourceMetrics(request, reply) {
   }
 }
 async function querySemanticMetrics(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   const body = request.body;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6845,7 +7259,7 @@ async function querySemanticMetrics(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core26.SemanticMetricsClient(semanticConfig);
+    const client = new import_core28.SemanticMetricsClient(semanticConfig);
     const result = await client.semanticQuery(body);
     const columnNames = result.columns.map((col) => col.name);
     const allDataPoints = [];
@@ -6905,7 +7319,7 @@ async function testSemanticDataSources(request, reply) {
       password: body.password,
       headers: body.headers
     };
-    const client = new import_core26.SemanticMetricsClient(testConfig);
+    const client = new import_core28.SemanticMetricsClient(testConfig);
     const datasources = await client.getDataSources();
     return {
       success: true,
@@ -6941,7 +7355,7 @@ async function testDatasourceMetrics(request, reply) {
       password: body.password,
       headers: body.headers
     };
-    const client = new import_core26.SemanticMetricsClient(testConfig);
+    const client = new import_core28.SemanticMetricsClient(testConfig);
     const metrics = await client.getDatasourceMetrics(datasourceId);
     return {
       success: true,
@@ -6973,7 +7387,7 @@ function registerMetricsServerConfigRoutes(app2) {
 }
 
 // src/controllers/connections.ts
-var import_core27 = require("@axiom-lattice/core");
+var import_core29 = require("@axiom-lattice/core");
 var import_zod = require("zod");
 var createBody = import_zod.z.object({
   type: import_zod.z.string().min(1),
@@ -6987,6 +7401,10 @@ var testOrDiscoverBody = import_zod.z.object({
   config: import_zod.z.record(import_zod.z.unknown()).optional()
 });
 function getTenant(request) {
+  const userTenantId = request.user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
   return request.headers["x-tenant-id"] || "default";
 }
 function maskSecrets(config) {
@@ -7010,7 +7428,7 @@ function maskSecrets(config) {
 }
 async function resolveConfig(type, body, tenantId) {
   if (body.key) {
-    const entry = await import_core27.ConnectionRegistry.get(type, body.key, tenantId);
+    const entry = await import_core29.ConnectionRegistry.get(type, body.key, tenantId);
     if (!entry) throw { status: 404, error: `Connection "${body.key}" not found` };
     return entry.config;
   }
@@ -7021,7 +7439,7 @@ function connectionRoutes(fastify2) {
   fastify2.get("/api/connections", async (request, reply) => {
     const { type } = request.query;
     if (!type) return reply.status(400).send({ error: "query 'type' required" });
-    const entries = await import_core27.ConnectionRegistry.list(type, getTenant(request));
+    const entries = await import_core29.ConnectionRegistry.list(type, getTenant(request));
     return reply.send({
       success: true,
       data: { records: entries.map((e) => ({ ...e, config: maskSecrets(e.config) })), total: entries.length }
@@ -7029,7 +7447,7 @@ function connectionRoutes(fastify2) {
   });
   fastify2.post("/api/connections", async (request, reply) => {
     const parsed = createBody.parse(request.body);
-    const entry = await import_core27.ConnectionRegistry.create({
+    const entry = await import_core29.ConnectionRegistry.create({
       tenantId: getTenant(request),
       type: parsed.type,
       key: parsed.key,
@@ -7048,7 +7466,7 @@ function connectionRoutes(fastify2) {
     const { key } = request.params;
     const body = request.body;
     const tenantId = getTenant(request);
-    const existing = await import_core27.ConnectionRegistry.get(type, key, tenantId);
+    const existing = await import_core29.ConnectionRegistry.get(type, key, tenantId);
     if (!existing) return reply.status(404).send({ error: "not found" });
     const updates = {};
     if (body.name !== void 0) updates.name = body.name;
@@ -7056,7 +7474,7 @@ function connectionRoutes(fastify2) {
     if (body.config) {
       updates.config = { ...existing.config, ...body.config };
     }
-    const entry = await import_core27.ConnectionRegistry.update(tenantId, type, key, updates);
+    const entry = await import_core29.ConnectionRegistry.update(tenantId, type, key, updates);
     return reply.send({
       success: true,
       data: { ...entry, config: maskSecrets(entry?.config ?? {}) }
@@ -7066,13 +7484,13 @@ function connectionRoutes(fastify2) {
     const { type } = request.query;
     if (!type) return reply.status(400).send({ error: "query 'type' required" });
     const { key } = request.params;
-    const ok = await import_core27.ConnectionRegistry.delete(getTenant(request), type, key);
+    const ok = await import_core29.ConnectionRegistry.delete(getTenant(request), type, key);
     return reply.send({ success: ok });
   });
   fastify2.post("/api/connections/test", async (request, reply) => {
     const { type } = request.query;
     if (!type) return reply.status(400).send({ error: "query 'type' required" });
-    const plugin = import_core27.PluginRegistry.get(type);
+    const plugin = import_core29.PluginRegistry.get(type);
     if (!plugin?.connection?.test) {
       return reply.status(400).send({ error: "plugin does not support connection testing" });
     }
@@ -7100,7 +7518,7 @@ function connectionRoutes(fastify2) {
   fastify2.post("/api/connections/discover", async (request, reply) => {
     const { type } = request.query;
     if (!type) return reply.status(400).send({ error: "query 'type' required" });
-    const plugin = import_core27.PluginRegistry.get(type);
+    const plugin = import_core29.PluginRegistry.get(type);
     if (!plugin?.connection?.discover) {
       return reply.status(400).send({ error: "plugin does not support resource discovery" });
     }
@@ -7130,13 +7548,12 @@ function connectionRoutes(fastify2) {
 init_mcp_configs();
 
 // src/controllers/eval.ts
-var import_core30 = require("@axiom-lattice/core");
+var import_core32 = require("@axiom-lattice/core");
 var import_uuid5 = require("uuid");
 
 // src/services/eval-runner.ts
 var import_events = require("events");
-var import_core29 = require("@axiom-lattice/core");
-var import_agent_eval = require("@axiom-lattice/agent-eval");
+var import_core31 = require("@axiom-lattice/core");
 var import_uuid4 = require("uuid");
 function mapLogs(logs) {
   return logs.map((l) => ({
@@ -7158,6 +7575,11 @@ var EvalRunner = class {
     const store2 = this.getEvalStore();
     const project = await store2.getProjectById(tenantId, projectId);
     if (!project) throw new Error("Project not found");
+    for (const ctx of this.runs.values()) {
+      if (ctx.projectId === projectId) {
+        throw new Error("A run is already in progress for this project");
+      }
+    }
     const existingRuns = await store2.getRunsByTenant(tenantId, { projectId, status: "running" });
     if (existingRuns.length > 0) {
       throw new Error("A run is already in progress for this project");
@@ -7174,7 +7596,7 @@ var EvalRunner = class {
           caseId: c.id,
           input: { message: c.inputMessage, files: c.inputFiles },
           steps: c.steps,
-          output: { type: c.outputType },
+          output: { type: "message_content" },
           eval: {
             content_assertion: c.contentAssertion,
             eval_rubrics: c.rubrics?.map((r) => ({
@@ -7186,35 +7608,32 @@ var EvalRunner = class {
         }))
       });
     }
-    const runId = (0, import_uuid4.v4)();
-    const concurrency = project.concurrency || 3;
-    await store2.createRun(tenantId, projectId, runId, { totalCases, concurrency });
-    const judgeCfg = project.judgeModelConfig;
-    const hasModelKey = Boolean(judgeCfg.modelKey);
-    const hasApiKey = Boolean(judgeCfg.apiKeyEnvName || judgeCfg.apiKey);
-    const hasCredentials = hasApiKey;
-    let judgeModelConfig = {};
-    if (hasModelKey) {
-      judgeModelConfig = { modelKey: judgeCfg.modelKey };
-    } else if (!hasCredentials) {
-      const firstModel = import_core29.modelLatticeManager.getAllLattices()[0];
-      if (firstModel) {
-        judgeModelConfig = { modelKey: firstModel.key };
-      } else {
-        judgeModelConfig = { model: judgeCfg };
+    const judgeCfg = project.judgeModelConfig ?? {};
+    const judgeModelKey = judgeCfg.modelKey || "";
+    let resolvedJudgeModelKey;
+    if (judgeModelKey) {
+      if (!import_core31.modelLatticeManager.hasLattice(judgeModelKey)) {
+        throw new Error(`Judge model "${judgeModelKey}" is not registered`);
       }
+      resolvedJudgeModelKey = judgeModelKey;
     } else {
-      judgeModelConfig = { model: judgeCfg };
+      const firstModel = import_core31.modelLatticeManager.getAllLattices()[0];
+      if (!firstModel) {
+        throw new Error("No model registered \u2014 cannot run eval without a judge model");
+      }
+      resolvedJudgeModelKey = firstModel.key;
+      console.warn(`[eval-runner] Project "${project.name}" has no judge modelKey \u2014 falling back to first registered model "${firstModel.key}"`);
     }
+    const runId = (0, import_uuid4.v4)();
+    const concurrency = Math.max(1, Math.floor(project.concurrency) || 3);
+    await store2.createRun(tenantId, projectId, runId, { totalCases, concurrency });
     const projectConfig = {
       projectName: project.name,
       version: project.version,
       description: project.description,
       suites: evalSuites,
-      judge_agent_config: judgeModelConfig,
+      judge_agent_config: { modelKey: resolvedJudgeModelKey },
       lattice_server_config: {
-        base_url: project.targetServerConfig.base_url || "",
-        api_key: project.targetServerConfig.api_key || "",
         tenant_id: tenantId
       },
       concurrency
@@ -7258,34 +7677,38 @@ var EvalRunner = class {
     };
     const runPromise = (async () => {
       try {
-        const evalProject = new import_agent_eval.LatticeEvalProject(projectConfig, onCaseComplete);
-        const { report } = await evalProject.runAllSuitesBatch(concurrency);
-        const completedCount = stats.passed + stats.failed;
-        await store2.updateRunStatus(tenantId, runId, {
-          status: "completed",
-          completedAt: /* @__PURE__ */ new Date(),
-          passedCases: stats.passed,
-          failedCases: stats.failed,
-          avgScore: completedCount > 0 ? stats.totalScore / completedCount : 0
-        });
-        this.eventEmitter.emit(`run:${runId}`, {
-          type: "completed",
-          runId,
-          data: { passed: stats.passed, failed: stats.failed, avgScore: completedCount > 0 ? stats.totalScore / completedCount : 0 }
-        });
+        const evalProject = new import_core31.LatticeEvalProject(projectConfig, onCaseComplete);
+        const { report } = await evalProject.runAllSuitesBatch(concurrency, abortController.signal);
+        if (!abortController.signal.aborted) {
+          const completedCount = stats.passed + stats.failed;
+          await store2.updateRunStatus(tenantId, runId, {
+            status: "completed",
+            completedAt: /* @__PURE__ */ new Date(),
+            passedCases: stats.passed,
+            failedCases: stats.failed,
+            avgScore: completedCount > 0 ? stats.totalScore / completedCount : 0
+          });
+          this.eventEmitter.emit(`run:${runId}`, {
+            type: "completed",
+            runId,
+            data: { passed: stats.passed, failed: stats.failed, avgScore: completedCount > 0 ? stats.totalScore / completedCount : 0 }
+          });
+        }
         return { report };
       } catch (err) {
         const errorMsg = err.message;
-        await store2.updateRunStatus(tenantId, runId, {
-          status: "failed",
-          error: errorMsg,
-          completedAt: /* @__PURE__ */ new Date()
-        });
-        this.eventEmitter.emit(`run:${runId}`, {
-          type: "error",
-          runId,
-          data: { message: errorMsg }
-        });
+        if (!abortController.signal.aborted) {
+          await store2.updateRunStatus(tenantId, runId, {
+            status: "failed",
+            error: errorMsg,
+            completedAt: /* @__PURE__ */ new Date()
+          });
+          this.eventEmitter.emit(`run:${runId}`, {
+            type: "error",
+            runId,
+            data: { message: errorMsg }
+          });
+        }
         throw err;
       } finally {
         this.runs.delete(runId);
@@ -7308,13 +7731,13 @@ var EvalRunner = class {
     return this.runs.has(runId);
   }
   getEvalStore() {
-    return (0, import_core29.getStoreLattice)("default", "eval").store;
+    return (0, import_core31.getStoreLattice)("default", "eval").store;
   }
 };
 var evalRunner = new EvalRunner();
 
 // src/controllers/eval.ts
-function getTenantId13(request) {
+function getTenantId14(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -7322,20 +7745,35 @@ function getTenantId13(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 function getEvalStore() {
-  return (0, import_core30.getStoreLattice)("default", "eval").store;
+  return (0, import_core32.getStoreLattice)("default", "eval").store;
 }
 async function createProject(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const id = (0, import_uuid5.v4)();
     const data = request.body;
+    const serverCfg = data.targetServerConfig || {};
+    const judgeCfg = data.judgeModelConfig || {};
+    const modelKey = judgeCfg.modelKey || "";
+    if (modelKey) {
+      const { modelLatticeManager: modelLatticeManager3 } = await import("@axiom-lattice/core");
+      if (!modelLatticeManager3.hasLattice(modelKey)) {
+        return reply.status(400).send({ success: false, message: `Judge model "${modelKey}" is not registered` });
+      }
+    }
     const project = await store2.createProject(tenantId, id, {
       name: data.name,
       description: data.description,
       version: data.version,
-      judgeModelConfig: data.judgeModelConfig ?? {},
-      targetServerConfig: data.targetServerConfig ?? {},
+      judgeModelConfig: {
+        modelKey,
+        displayName: judgeCfg.displayName || ""
+      },
+      targetServerConfig: {
+        base_url: serverCfg.base_url || "",
+        api_key: serverCfg.api_key || ""
+      },
       concurrency: data.concurrency ?? 1,
       reportConfig: data.reportConfig
     });
@@ -7351,7 +7789,7 @@ async function createProject(request, reply) {
 }
 async function listProjects(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     let projects = await store2.getProjectsByTenant(tenantId);
     if (projects.length === 0) {
@@ -7359,7 +7797,7 @@ async function listProjects(request, reply) {
         const { modelLatticeManager: modelLatticeManager3 } = await import("@axiom-lattice/core");
         const models = modelLatticeManager3.getAllLattices();
         const first = models[0];
-        const judgeModel = first ? { modelKey: first.key } : { provider: "openai", model: "gpt-4" };
+        const judgeModel = first ? { modelKey: first.key } : {};
         const host = request.hostname || "localhost";
         const baseUrl = `http://${host}:${process.env.PORT || 4001}`;
         await store2.createProject(tenantId, (0, import_uuid5.v4)(), {
@@ -7385,7 +7823,7 @@ async function listProjects(request, reply) {
 }
 async function getProject(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { pid } = request.params;
     const project = await store2.getProjectById(tenantId, pid);
@@ -7405,14 +7843,37 @@ async function getProject(request, reply) {
 }
 async function updateProject(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { pid } = request.params;
     const existing = await store2.getProjectById(tenantId, pid);
     if (!existing) {
       return reply.status(404).send({ success: false, message: "Project not found" });
     }
-    const updated = await store2.updateProject(tenantId, pid, request.body);
+    const body = request.body;
+    const updateData = { ...body };
+    const serverCfg = body.targetServerConfig || {};
+    if (body.targetServerConfig !== void 0) {
+      updateData.targetServerConfig = {
+        base_url: serverCfg.base_url || "",
+        api_key: serverCfg.api_key || ""
+      };
+    }
+    if (body.judgeModelConfig !== void 0) {
+      const judgeCfg = body.judgeModelConfig || {};
+      const modelKey = judgeCfg.modelKey || "";
+      if (modelKey) {
+        const { modelLatticeManager: modelLatticeManager3 } = await import("@axiom-lattice/core");
+        if (!modelLatticeManager3.hasLattice(modelKey)) {
+          return reply.status(400).send({ success: false, message: `Judge model "${modelKey}" is not registered` });
+        }
+      }
+      updateData.judgeModelConfig = {
+        modelKey,
+        displayName: judgeCfg.displayName || ""
+      };
+    }
+    const updated = await store2.updateProject(tenantId, pid, updateData);
     return {
       success: true,
       message: "Successfully updated project",
@@ -7425,7 +7886,7 @@ async function updateProject(request, reply) {
 }
 async function deleteProject(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { pid } = request.params;
     const existing = await store2.getProjectById(tenantId, pid);
@@ -7444,7 +7905,7 @@ async function deleteProject(request, reply) {
 }
 async function createSuite(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { pid } = request.params;
     const project = await store2.getProjectById(tenantId, pid);
@@ -7466,7 +7927,7 @@ async function createSuite(request, reply) {
 }
 async function updateSuite(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { sid } = request.params;
     const existing = await store2.getSuiteById(tenantId, sid);
@@ -7486,7 +7947,7 @@ async function updateSuite(request, reply) {
 }
 async function deleteSuite(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { sid } = request.params;
     const existing = await store2.getSuiteById(tenantId, sid);
@@ -7505,7 +7966,7 @@ async function deleteSuite(request, reply) {
 }
 async function createCase(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { sid } = request.params;
     const suite = await store2.getSuiteById(tenantId, sid);
@@ -7534,7 +7995,7 @@ async function createCase(request, reply) {
 }
 async function listCasesForSuite(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { sid } = request.params;
     const cases = await store2.getCasesBySuite(tenantId, sid);
@@ -7550,7 +8011,7 @@ async function listCasesForSuite(request, reply) {
 }
 async function updateCase(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { cid } = request.params;
     const existing = await store2.getCaseById(tenantId, cid);
@@ -7570,7 +8031,7 @@ async function updateCase(request, reply) {
 }
 async function deleteCase(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { cid } = request.params;
     const existing = await store2.getCaseById(tenantId, cid);
@@ -7602,7 +8063,7 @@ function registerEvalRoutes(app2) {
   app2.delete("/api/eval/projects/:pid/suites/:sid/cases/:cid", deleteCase);
   app2.post("/api/eval/projects/:pid/runs", async (request, reply) => {
     try {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const { pid } = request.params;
       const runId = await evalRunner.startRun(tenantId, pid);
       reply.status(202).send({ success: true, message: "Run started", data: { run_id: runId } });
@@ -7614,7 +8075,7 @@ function registerEvalRoutes(app2) {
   });
   app2.get("/api/eval/runs", async (request, reply) => {
     try {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const query = request.query;
       const runs = await getEvalStore().getRunsByTenant(tenantId, { projectId: query.project_id, status: query.status });
       reply.send({ success: true, message: "Ok", data: { records: runs, total: runs.length } });
@@ -7624,7 +8085,7 @@ function registerEvalRoutes(app2) {
   });
   app2.get("/api/eval/runs/:rid", async (request, reply) => {
     try {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const { rid } = request.params;
       const run = await getEvalStore().getRunById(tenantId, rid);
       if (!run) return reply.status(404).send({ success: false, message: "Run not found" });
@@ -7646,7 +8107,7 @@ function registerEvalRoutes(app2) {
     const emitter = evalRunner.getEventEmitter();
     const eventKey = `run:${rid}`;
     if (!evalRunner.isRunning(rid)) {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const run = await getEvalStore().getRunById(tenantId, rid);
       if (run) {
         const eventType = run.status === "completed" ? "completed" : "error";
@@ -7685,7 +8146,7 @@ data: ${JSON.stringify(event.data)}
   });
   app2.delete("/api/eval/runs/:rid", async (request, reply) => {
     try {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const { rid } = request.params;
       const deleted = await getEvalStore().deleteRun(tenantId, rid);
       if (!deleted) return reply.status(404).send({ success: false, message: "Run not found" });
@@ -7696,7 +8157,7 @@ data: ${JSON.stringify(event.data)}
   });
   app2.get("/api/eval/reports/projects/:pid", async (request, reply) => {
     try {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const { pid } = request.params;
       const report = await getEvalStore().getProjectReport(tenantId, pid);
       if (!report) return reply.status(404).send({ success: false, message: "Project not found" });
@@ -7708,11 +8169,11 @@ data: ${JSON.stringify(event.data)}
 }
 
 // src/controllers/users.ts
-var import_core31 = require("@axiom-lattice/core");
+var import_core33 = require("@axiom-lattice/core");
 var import_uuid6 = require("uuid");
 var UsersController = class {
   constructor() {
-    this.userStore = (0, import_core31.getStoreLattice)("default", "user").store;
+    this.userStore = (0, import_core33.getStoreLattice)("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -7790,11 +8251,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-var import_core32 = require("@axiom-lattice/core");
+var import_core34 = require("@axiom-lattice/core");
 var import_uuid7 = require("uuid");
 var TenantsController = class {
   constructor() {
-    this.tenantStore = (0, import_core32.getStoreLattice)("default", "tenant").store;
+    this.tenantStore = (0, import_core34.getStoreLattice)("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -7858,7 +8319,7 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-var import_core33 = require("@axiom-lattice/core");
+var import_core35 = require("@axiom-lattice/core");
 var import_uuid8 = require("uuid");
 var defaultAuthConfig = {
   autoApproveUsers: true,
@@ -7867,9 +8328,9 @@ var defaultAuthConfig = {
 };
 var AuthController = class {
   constructor(config = {}) {
-    this.userStore = (0, import_core33.getStoreLattice)("default", "user").store;
-    this.tenantStore = (0, import_core33.getStoreLattice)("default", "tenant").store;
-    this.userTenantLinkStore = (0, import_core33.getStoreLattice)("default", "userTenantLink").store;
+    this.userStore = (0, import_core35.getStoreLattice)("default", "user").store;
+    this.tenantStore = (0, import_core35.getStoreLattice)("default", "tenant").store;
+    this.userTenantLinkStore = (0, import_core35.getStoreLattice)("default", "userTenantLink").store;
     this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
@@ -8027,7 +8488,7 @@ var AuthController = class {
       const linkMeta = link?.metadata || {};
       let personalAssistant = null;
       if (linkMeta.personalAssistantId) {
-        const assistantStore = (0, import_core33.getStoreLattice)("default", "assistant").store;
+        const assistantStore = (0, import_core35.getStoreLattice)("default", "assistant").store;
         const exists = await assistantStore.hasAssistant(tenantId, linkMeta.personalAssistantId);
         if (exists) {
           personalAssistant = {
@@ -8447,7 +8908,7 @@ var larkChannelAdapter = {
 };
 
 // src/channels/lark/verification.ts
-var import_crypto7 = __toESM(require("crypto"));
+var import_crypto8 = __toESM(require("crypto"));
 function parseLarkRequestBody(body, encryptKey) {
   const parsed = body || {};
   if (encryptKey && typeof parsed.encrypt === "string") {
@@ -8456,11 +8917,11 @@ function parseLarkRequestBody(body, encryptKey) {
   return parsed;
 }
 function decryptLarkPayload(encryptKey, encryptedPayload) {
-  const key = import_crypto7.default.createHash("sha256").update(encryptKey).digest();
+  const key = import_crypto8.default.createHash("sha256").update(encryptKey).digest();
   const buffer = Buffer.from(encryptedPayload, "base64");
   const iv = buffer.subarray(0, 16);
   const ciphertext = buffer.subarray(16);
-  const decipher = import_crypto7.default.createDecipheriv("aes-256-cbc", key, iv);
+  const decipher = import_crypto8.default.createDecipheriv("aes-256-cbc", key, iv);
   const plaintext = Buffer.concat([
     decipher.update(ciphertext),
     decipher.final()
@@ -8577,14 +9038,14 @@ function registerChannelRoutes(app2, dependencies) {
 }
 
 // src/controllers/channel-installations.ts
-var import_crypto8 = require("crypto");
+var import_crypto9 = require("crypto");
 var _adapterRegistry;
 var _router;
 function setChannelControllerDeps(deps) {
   _adapterRegistry = deps.adapterRegistry;
   _router = deps.router;
 }
-function getTenantId14(request) {
+function getTenantId15(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -8592,8 +9053,8 @@ function getTenantId14(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getInstallationStore() {
-  const { getStoreLattice: getStoreLattice18 } = await import("@axiom-lattice/core");
-  const store2 = getStoreLattice18("default", "channelInstallation").store;
+  const { getStoreLattice: getStoreLattice31 } = await import("@axiom-lattice/core");
+  const store2 = getStoreLattice31("default", "channelInstallation").store;
   if (store2) return store2;
   const { PostgreSQLChannelInstallationStore } = await import("@axiom-lattice/pg-stores");
   const databaseUrl = process.env.DATABASE_URL;
@@ -8605,7 +9066,7 @@ async function getInstallationStore() {
   });
 }
 async function getChannelInstallationList(request, reply) {
-  const tenantId = getTenantId14(request);
+  const tenantId = getTenantId15(request);
   const { channel } = request.query;
   try {
     const store2 = await getInstallationStore();
@@ -8631,7 +9092,7 @@ async function getChannelInstallationList(request, reply) {
   }
 }
 async function getChannelInstallation(request, reply) {
-  const tenantId = getTenantId14(request);
+  const tenantId = getTenantId15(request);
   const { installationId } = request.params;
   try {
     const store2 = await getInstallationStore();
@@ -8664,7 +9125,7 @@ async function getChannelInstallation(request, reply) {
   }
 }
 async function createChannelInstallation(request, reply) {
-  const tenantId = getTenantId14(request);
+  const tenantId = getTenantId15(request);
   const body = request.body;
   try {
     if (!body.channel) {
@@ -8699,7 +9160,7 @@ async function createChannelInstallation(request, reply) {
       }
     }
     const store2 = await getInstallationStore();
-    const installationId = body.id || (0, import_crypto8.randomUUID)();
+    const installationId = body.id || (0, import_crypto9.randomUUID)();
     const installation = await store2.createInstallation(
       tenantId,
       installationId,
@@ -8737,7 +9198,7 @@ async function createChannelInstallation(request, reply) {
   }
 }
 async function updateChannelInstallation(request, reply) {
-  const tenantId = getTenantId14(request);
+  const tenantId = getTenantId15(request);
   const { installationId } = request.params;
   const body = request.body;
   try {
@@ -8791,7 +9252,7 @@ async function updateChannelInstallation(request, reply) {
   }
 }
 async function deleteChannelInstallation(request, reply) {
-  const tenantId = getTenantId14(request);
+  const tenantId = getTenantId15(request);
   const { installationId } = request.params;
   try {
     const store2 = await getInstallationStore();
@@ -8851,17 +9312,17 @@ function registerChannelInstallationRoutes(app2) {
 }
 
 // src/controllers/channel-bindings.ts
-var import_core34 = require("@axiom-lattice/core");
-function getTenantId15(request) {
+var import_core36 = require("@axiom-lattice/core");
+function getTenantId16(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) return userTenantId;
   return request.headers["x-tenant-id"] || "default";
 }
 async function getBindingList(request, _reply) {
-  const tenantId = getTenantId15(request);
+  const tenantId = getTenantId16(request);
   const { channel, agentId, channelInstallationId, limit, offset } = request.query;
   try {
-    const registry = (0, import_core34.getBindingRegistry)();
+    const registry = (0, import_core36.getBindingRegistry)();
     const bindings = await registry.list({ channel, agentId, tenantId, channelInstallationId, limit, offset });
     return { success: true, message: "Bindings retrieved", data: { records: bindings, total: bindings.length } };
   } catch (error) {
@@ -8870,9 +9331,9 @@ async function getBindingList(request, _reply) {
   }
 }
 async function getBinding(request, reply) {
-  const tenantId = getTenantId15(request);
+  const tenantId = getTenantId16(request);
   try {
-    const registry = (0, import_core34.getBindingRegistry)();
+    const registry = (0, import_core36.getBindingRegistry)();
     const bindings = await registry.list({ tenantId });
     const binding = bindings.find((b) => b.id === request.params.id);
     if (!binding || binding.tenantId !== tenantId) {
@@ -8886,9 +9347,9 @@ async function getBinding(request, reply) {
   }
 }
 async function createBinding(request, reply) {
-  const tenantId = getTenantId15(request);
+  const tenantId = getTenantId16(request);
   try {
-    const registry = (0, import_core34.getBindingRegistry)();
+    const registry = (0, import_core36.getBindingRegistry)();
     const binding = await registry.create({ ...request.body, tenantId });
     reply.status(201);
     return { success: true, message: "Binding created", data: binding };
@@ -8900,8 +9361,8 @@ async function createBinding(request, reply) {
 }
 async function updateBinding(request, reply) {
   try {
-    const tenantId = getTenantId15(request);
-    const registry = (0, import_core34.getBindingRegistry)();
+    const tenantId = getTenantId16(request);
+    const registry = (0, import_core36.getBindingRegistry)();
     const bindings = await registry.list({ tenantId });
     const existing = bindings.find((b) => b.id === request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
@@ -8918,8 +9379,8 @@ async function updateBinding(request, reply) {
 }
 async function deleteBinding(request, reply) {
   try {
-    const tenantId = getTenantId15(request);
-    const registry = (0, import_core34.getBindingRegistry)();
+    const tenantId = getTenantId16(request);
+    const registry = (0, import_core36.getBindingRegistry)();
     const bindings = await registry.list({ tenantId });
     const existing = bindings.find((b) => b.id === request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
@@ -8935,10 +9396,10 @@ async function deleteBinding(request, reply) {
   }
 }
 async function resolveBinding(request, _reply) {
-  const tenantId = getTenantId15(request);
+  const tenantId = getTenantId16(request);
   const { channel, senderId, channelInstallationId } = request.query;
   try {
-    const registry = (0, import_core34.getBindingRegistry)();
+    const registry = (0, import_core36.getBindingRegistry)();
     const binding = await registry.resolve({ channel, senderId, channelInstallationId, tenantId });
     if (!binding) {
       return { success: false, message: "No binding found", data: null };
@@ -8961,8 +9422,8 @@ function registerChannelBindingRoutes(app2) {
 }
 
 // src/controllers/menu-items.ts
-var import_core35 = require("@axiom-lattice/core");
-function getTenantId16(request) {
+var import_core37 = require("@axiom-lattice/core");
+function getTenantId17(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) return userTenantId;
   return request.headers["x-tenant-id"] || "default";
@@ -8971,9 +9432,9 @@ function errorMessage(err) {
   return err instanceof Error ? err.message : "Unexpected error";
 }
 async function getMenuItemList(request, _reply) {
-  const tenantId = getTenantId16(request);
+  const tenantId = getTenantId17(request);
   try {
-    const registry = (0, import_core35.getMenuRegistry)();
+    const registry = (0, import_core37.getMenuRegistry)();
     const items = await registry.list({ tenantId, menuTarget: request.query.menuTarget });
     return { success: true, message: "Menu items retrieved", data: { records: items, total: items.length } };
   } catch (error) {
@@ -8983,9 +9444,9 @@ async function getMenuItemList(request, _reply) {
   }
 }
 async function getMenuItem(request, reply) {
-  const tenantId = getTenantId16(request);
+  const tenantId = getTenantId17(request);
   try {
-    const registry = (0, import_core35.getMenuRegistry)();
+    const registry = (0, import_core37.getMenuRegistry)();
     const item = await registry.getById(request.params.id);
     if (!item || item.tenantId !== tenantId) {
       reply.status(404);
@@ -9000,9 +9461,9 @@ async function getMenuItem(request, reply) {
   }
 }
 async function createMenuItem(request, reply) {
-  const tenantId = getTenantId16(request);
+  const tenantId = getTenantId17(request);
   try {
-    const registry = (0, import_core35.getMenuRegistry)();
+    const registry = (0, import_core37.getMenuRegistry)();
     const item = await registry.create({ ...request.body, tenantId });
     reply.status(201);
     return { success: true, message: "Menu item created", data: item };
@@ -9015,8 +9476,8 @@ async function createMenuItem(request, reply) {
 }
 async function updateMenuItem(request, reply) {
   try {
-    const tenantId = getTenantId16(request);
-    const registry = (0, import_core35.getMenuRegistry)();
+    const tenantId = getTenantId17(request);
+    const registry = (0, import_core37.getMenuRegistry)();
     const existing = await registry.getById(request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
       reply.status(404);
@@ -9033,8 +9494,8 @@ async function updateMenuItem(request, reply) {
 }
 async function deleteMenuItem(request, reply) {
   try {
-    const tenantId = getTenantId16(request);
-    const registry = (0, import_core35.getMenuRegistry)();
+    const tenantId = getTenantId17(request);
+    const registry = (0, import_core37.getMenuRegistry)();
     const existing = await registry.getById(request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
       reply.status(404);
@@ -9466,11 +9927,37 @@ var registerLatticeRoutes = (app2, channelDeps) => {
   app2.delete("/api/workflows/runs/:runId", deleteWorkflowRun);
   app2.get("/api/workflows/runs/:runId/steps", getRunSteps);
   app2.get("/api/workflows/runs/:runId/tasks", getRunTasks);
+  app2.post("/api/workflows/runs/:runId/abort", abortWorkflowRun);
   app2.post("/api/workflows/inbox/reply", replyInboxTask);
   app2.delete(
     "/api/assistants/:assistant_id/threads/:thread_id/pending-messages/:message_id",
     removePendingMessageHandler
   );
+  app2.get("/api/tenants/exportable-types", getExportableTypes);
+  app2.post(
+    "/api/tenants/:tenantId/export",
+    exportConfig
+  );
+  app2.post(
+    "/api/tenants/:tenantId/export/confirm",
+    exportConfigConfirm
+  );
+  app2.post(
+    "/api/tenants/:tenantId/export/entities",
+    previewEntities
+  );
+  app2.get(
+    "/api/tenants/:tenantId/export/:jobId/download",
+    downloadExport
+  );
+  app2.post(
+    "/api/tenants/:tenantId/import/preview",
+    importPreview
+  );
+  app2.post(
+    "/api/tenants/:tenantId/import/apply",
+    importApply
+  );
 };
 
 // src/routes/resource-routes.ts
@@ -9499,9 +9986,1317 @@ function registerResourceRoutes(app2, controller) {
   app2.delete("/api/resources/share/:token", controller.revokeShare.bind(controller));
 }
 
+// src/export_registrations/index.ts
+var import_core51 = require("@axiom-lattice/core");
+
+// src/export_registrations/skill.registration.ts
+var import_core38 = require("@axiom-lattice/core");
+function getStore2() {
+  return (0, import_core38.getStoreLattice)("default", "skill").store;
+}
+var skillRegistration = {
+  entityType: "skill",
+  label: "Skill(\u6280\u80FD)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore2();
+    const skills = await store2.getAllSkills(tenantId);
+    return skills.map((s) => ({
+      _exportId: "",
+      data: {
+        id: s.id,
+        name: s.name,
+        description: s.description,
+        license: s.license,
+        compatibility: s.compatibility,
+        metadata: s.metadata,
+        content: s.content,
+        subSkills: s.subSkills
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore2();
+    const existing = await store2.getAllSkills(tenantId);
+    const existingIds = new Set(existing.map((s) => s.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const id = entity.data.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "skill",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: entity.data.name || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "skill",
+          name: entity.data.name || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore2();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteSkill(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createSkill(tenantId, id, {
+      name: data.name,
+      description: data.description,
+      license: data.license,
+      compatibility: data.compatibility,
+      metadata: data.metadata,
+      content: data.content,
+      subSkills: data.subSkills
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/agent.registration.ts
+var import_core39 = require("@axiom-lattice/core");
+function getStore3() {
+  return (0, import_core39.getStoreLattice)("default", "assistant").store;
+}
+var agentRegistration = {
+  entityType: "agent",
+  label: "Agent(\u667A\u80FD\u4F53)",
+  category: "core",
+  dependsOn: ["skill"],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore3();
+    const agents = await store2.getAllAssistants(tenantId);
+    return agents.map((a) => ({
+      _exportId: "",
+      data: {
+        id: a.id,
+        name: a.name,
+        description: a.description,
+        graphDefinition: a.graphDefinition
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore3();
+    const existing = await store2.getAllAssistants(tenantId);
+    const existingIds = new Set(existing.map((a) => a.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const id = entity.data.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "agent",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: entity.data.name || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "agent",
+          name: entity.data.name || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore3();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteAssistant(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createAssistant(tenantId, id, {
+      name: data.name,
+      description: data.description || "",
+      graphDefinition: data.graphDefinition
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/binding.registration.ts
+var import_core40 = require("@axiom-lattice/core");
+function getStore4() {
+  return (0, import_core40.getStoreLattice)("default", "channelBinding").store;
+}
+var bindingRegistration = {
+  entityType: "binding",
+  label: "Binding(\u6E20\u9053\u7ED1\u5B9A)",
+  category: "core",
+  dependsOn: ["agent", "channel_installation"],
+  cascadeParents: [],
+  referenceFields: { agentId: "agent", channelInstallationId: "channel_installation" },
+  async listForExport(tenantId) {
+    const store2 = getStore4();
+    const bindings = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    return bindings.map((b) => ({
+      _exportId: "",
+      data: {
+        channel: b.channel,
+        channelInstallationId: b.channelInstallationId,
+        senderId: b.senderId,
+        agentId: b.agentId,
+        threadId: b.threadId,
+        workspaceId: b.workspaceId,
+        projectId: b.projectId,
+        threadMode: b.threadMode,
+        senderDisplayName: b.senderDisplayName,
+        senderMetadata: b.senderMetadata,
+        enabled: b.enabled
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore4();
+    const existing = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    const existingKeys = new Set(
+      existing.map((b) => `${b.channel}:${b.channelInstallationId}:${b.senderId}`)
+    );
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const key = `${d.channel}:${d.channelInstallationId}:${d.senderId}`;
+      if (existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "binding",
+          conflictType: "unique_constraint",
+          existingName: `${d.channel}:${d.senderId}`,
+          field: "channel+channelInstallationId+senderId"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "binding",
+          name: `${d.channel}:${d.senderId}`
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    if (resolution.action === "skip") return {};
+    const store2 = getStore4();
+    const d = entity.data;
+    if (resolution.action === "overwrite") {
+      const existing = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+      const match = existing.find(
+        (b) => b.channel === d.channel && b.channelInstallationId === d.channelInstallationId && b.senderId === d.senderId
+      );
+      if (match) {
+        await store2.delete(match.id);
+      }
+    }
+    await store2.create({
+      channel: d.channel,
+      channelInstallationId: d.channelInstallationId,
+      tenantId,
+      senderId: d.senderId,
+      agentId: d.agentId,
+      threadMode: d.threadMode || "fixed",
+      senderDisplayName: d.senderDisplayName,
+      senderMetadata: d.senderMetadata,
+      workspaceId: d.workspaceId,
+      projectId: d.projectId
+    });
+    return { newId: void 0 };
+  }
+};
+
+// src/export_registrations/database-config.registration.ts
+var import_core41 = require("@axiom-lattice/core");
+function getStore5() {
+  return (0, import_core41.getStoreLattice)("default", "database").store;
+}
+var databaseConfigRegistration = {
+  entityType: "database_config",
+  label: "Database Config(\u6570\u636E\u5E93\u914D\u7F6E)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore5();
+    const configs = await store2.getAllConfigs(tenantId);
+    return configs.map((c) => ({
+      _exportId: "",
+      data: {
+        id: c.id,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore5();
+    const existing = await store2.getAllConfigs(tenantId);
+    const existingIds = new Set(existing.map((c) => c.id));
+    const existingKeys = new Set(existing.map((c) => c.key));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      const key = d.key;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "database_config",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.name || key
+        });
+      } else if (key && existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "database_config",
+          conflictType: "unique_constraint",
+          existingName: d.name || key,
+          field: "key"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "database_config",
+          name: d.name || key
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore5();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteConfig(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createConfig(tenantId, id, {
+      key: data.key,
+      name: data.name,
+      description: data.description,
+      config: data.config
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/metrics-config.registration.ts
+var import_core42 = require("@axiom-lattice/core");
+function getStore6() {
+  return (0, import_core42.getStoreLattice)("default", "metrics").store;
+}
+var metricsConfigRegistration = {
+  entityType: "metrics_config",
+  label: "Metrics Config(\u6307\u6807\u914D\u7F6E)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore6();
+    const configs = await store2.getAllConfigs(tenantId);
+    return configs.map((c) => ({
+      _exportId: "",
+      data: {
+        id: c.id,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore6();
+    const existing = await store2.getAllConfigs(tenantId);
+    const existingIds = new Set(existing.map((c) => c.id));
+    const existingKeys = new Set(existing.map((c) => c.key));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      const key = d.key;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "metrics_config",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.name || key
+        });
+      } else if (key && existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "metrics_config",
+          conflictType: "unique_constraint",
+          existingName: d.name || key,
+          field: "key"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "metrics_config",
+          name: d.name || key
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore6();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteConfig(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createConfig(tenantId, id, {
+      key: data.key,
+      name: data.name,
+      description: data.description,
+      config: data.config
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/mcp-config.registration.ts
+var import_core43 = require("@axiom-lattice/core");
+function getStore7() {
+  return (0, import_core43.getStoreLattice)("default", "mcp").store;
+}
+var mcpConfigRegistration = {
+  entityType: "mcp_config",
+  label: "MCP Config(MCP\u914D\u7F6E)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore7();
+    const configs = await store2.getAllConfigs(tenantId);
+    return configs.map((c) => ({
+      _exportId: "",
+      data: {
+        id: c.id,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config,
+        selectedTools: c.selectedTools,
+        status: c.status
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore7();
+    const existing = await store2.getAllConfigs(tenantId);
+    const existingIds = new Set(existing.map((c) => c.id));
+    const existingKeys = new Set(existing.map((c) => c.key));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      const key = d.key;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "mcp_config",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.name || key
+        });
+      } else if (key && existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "mcp_config",
+          conflictType: "unique_constraint",
+          existingName: d.name || key,
+          field: "key"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "mcp_config",
+          name: d.name || key
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore7();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteConfig(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createConfig(tenantId, id, {
+      key: data.key,
+      name: data.name,
+      description: data.description,
+      config: data.config,
+      selectedTools: data.selectedTools
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/connection.registration.ts
+var import_core44 = require("@axiom-lattice/core");
+function getStore8() {
+  return (0, import_core44.getStoreLattice)("default", "connection").store;
+}
+async function listAllConnections(tenantId) {
+  const store2 = getStore8();
+  if (typeof store2.listByTenant !== "function") {
+    throw new Error("ConnectionStore.listByTenant is not implemented. SQL bypass removed \u2014 upgrade your store adapter.");
+  }
+  return store2.listByTenant(tenantId);
+}
+var connectionRegistration = {
+  entityType: "connection",
+  label: "Connection(\u8FDE\u63A5)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const connections2 = await listAllConnections(tenantId);
+    return connections2.map((c) => ({
+      _exportId: "",
+      data: {
+        id: c.id,
+        type: c.type,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const existing = await listAllConnections(tenantId);
+    const existingCompositeKeys = new Set(
+      existing.map((c) => `${c.type}:${c.key}`)
+    );
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const compositeKey = `${d.type}:${d.key}`;
+      if (existingCompositeKeys.has(compositeKey)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "connection",
+          conflictType: "unique_constraint",
+          existingName: `${d.type}:${d.key}`,
+          field: "type+key"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "connection",
+          name: `${d.type}:${d.key}`
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    if (resolution.action === "skip") return {};
+    const store2 = getStore8();
+    const d = entity.data;
+    const type = d.type;
+    const key = d.key;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.delete(tenantId, type, key);
+      } catch {
+      }
+    }
+    await store2.create({
+      tenantId,
+      type,
+      key,
+      name: d.name,
+      description: d.description,
+      config: d.config
+    });
+    return { newId: void 0 };
+  }
+};
+
+// src/export_registrations/collection.registration.ts
+var import_core45 = require("@axiom-lattice/core");
+function getStore9() {
+  return (0, import_core45.getStoreLattice)("default", "collection").store;
+}
+var collectionRegistration = {
+  entityType: "collection",
+  label: "Collection(\u77E5\u8BC6\u5E93)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore9();
+    const collections = await store2.getAllCollections(tenantId);
+    return collections.map((c) => ({
+      _exportId: "",
+      data: {
+        id: c.id,
+        name: c.name,
+        label: c.label,
+        embeddingKey: c.embeddingKey,
+        schema: c.schema
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore9();
+    const existing = await store2.getAllCollections(tenantId);
+    const existingNames = new Set(existing.map((c) => c.name));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const name = d.name;
+      if (existingNames.has(name)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "collection",
+          conflictType: "unique_constraint",
+          existingName: name,
+          field: "name"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "collection",
+          name
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    if (resolution.action === "skip") return {};
+    const store2 = getStore9();
+    const d = entity.data;
+    const name = d.name;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteCollection(tenantId, name);
+      } catch {
+      }
+    }
+    await store2.createCollection(tenantId, {
+      name,
+      label: d.label,
+      embeddingKey: d.embeddingKey,
+      schema: d.schema
+    });
+    return { newId: void 0 };
+  }
+};
+
+// src/export_registrations/channel-installation.registration.ts
+var import_core46 = require("@axiom-lattice/core");
+function getStore10() {
+  return (0, import_core46.getStoreLattice)("default", "channelInstallation").store;
+}
+var channelInstallationRegistration = {
+  entityType: "channel_installation",
+  label: "Channel Installation(\u6E20\u9053\u5B89\u88C5)",
+  category: "core",
+  dependsOn: ["agent"],
+  cascadeParents: [],
+  referenceFields: { fallbackAgentId: "agent" },
+  async listForExport(tenantId) {
+    const store2 = getStore10();
+    const installations = await store2.getInstallationsByTenant(tenantId);
+    return installations.map((i) => ({
+      _exportId: "",
+      data: {
+        id: i.id,
+        channel: i.channel,
+        name: i.name,
+        config: i.config,
+        enabled: i.enabled,
+        fallbackAgentId: i.fallbackAgentId,
+        rejectWhenNoBinding: i.rejectWhenNoBinding
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore10();
+    const existing = await store2.getInstallationsByTenant(tenantId);
+    const existingIds = new Set(existing.map((i) => i.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "channel_installation",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.name || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "channel_installation",
+          name: d.name || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore10();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteInstallation(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createInstallation(tenantId, id, {
+      channel: data.channel,
+      name: data.name,
+      config: data.config,
+      enabled: data.enabled,
+      fallbackAgentId: data.fallbackAgentId,
+      rejectWhenNoBinding: data.rejectWhenNoBinding
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/menu.registration.ts
+var import_core47 = require("@axiom-lattice/core");
+function getStore11() {
+  return (0, import_core47.getStoreLattice)("default", "menu").store;
+}
+var menuRegistration = {
+  entityType: "menu",
+  label: "Menu(\u83DC\u5355)",
+  category: "core",
+  dependsOn: ["agent"],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore11();
+    const menus = await store2.list({ tenantId });
+    return menus.map((m) => ({
+      _exportId: "",
+      data: {
+        id: m.id,
+        menuTarget: m.menuTarget,
+        group: m.group,
+        name: m.name,
+        icon: m.icon,
+        sortOrder: m.sortOrder,
+        contentType: m.contentType,
+        contentConfig: m.contentConfig,
+        enabled: m.enabled
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore11();
+    const existing = await store2.list({ tenantId });
+    const existingIds = new Set(existing.map((m) => m.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "menu",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.name || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "menu",
+          name: d.name || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore11();
+    const d = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : d.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.delete(id);
+      } catch {
+      }
+    }
+    await store2.create({
+      tenantId,
+      menuTarget: d.menuTarget,
+      group: d.group,
+      name: d.name,
+      icon: d.icon,
+      sortOrder: d.sortOrder,
+      contentType: d.contentType,
+      contentConfig: d.contentConfig
+    });
+    return { newId: void 0 };
+  }
+};
+
+// src/export_registrations/task.registration.ts
+var import_core48 = require("@axiom-lattice/core");
+function getStore12() {
+  return (0, import_core48.getStoreLattice)("default", "task").store;
+}
+var taskRegistration = {
+  entityType: "task",
+  label: "Task(\u4EFB\u52A1)",
+  category: "core",
+  dependsOn: ["agent"],
+  cascadeParents: [],
+  referenceFields: { ownerId: "agent", parentId: "task" },
+  async listForExport(tenantId) {
+    const store2 = getStore12();
+    const tasks = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    return tasks.map((t) => ({
+      _exportId: "",
+      data: {
+        id: t.id,
+        title: t.title,
+        description: t.description,
+        status: t.status,
+        priority: t.priority,
+        dueDate: t.dueDate,
+        ownerType: t.ownerType,
+        ownerId: t.ownerId,
+        metadata: t.metadata,
+        parentId: t.parentId,
+        sourceId: t.sourceId,
+        context: t.context
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore12();
+    const existing = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    const existingIds = new Set(existing.map((t) => t.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "task",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.title || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "task",
+          name: d.title || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore12();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.delete(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.create({
+      tenantId,
+      ownerType: data.ownerType || "user",
+      ownerId: data.ownerId || "",
+      title: data.title,
+      description: data.description,
+      status: data.status,
+      priority: data.priority,
+      dueDate: data.dueDate,
+      metadata: data.metadata,
+      parentId: data.parentId,
+      sourceId: data.sourceId,
+      context: data.context
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/a2a-api-key.registration.ts
+var import_core49 = require("@axiom-lattice/core");
+function getStore13() {
+  return (0, import_core49.getStoreLattice)("default", "a2aApiKey").store;
+}
+var a2aApiKeyRegistration = {
+  entityType: "a2a_api_key",
+  label: "A2A API Key(API\u5BC6\u94A5)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore13();
+    const keys = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    return keys.map((k) => ({
+      _exportId: "",
+      data: {
+        id: k.id,
+        tenantId: k.tenantId,
+        projectId: k.projectId,
+        workspaceId: k.workspaceId,
+        label: k.label,
+        enabled: k.enabled
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore13();
+    const existing = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    const existingIds = new Set(existing.map((k) => k.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "a2a_api_key",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.label || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "a2a_api_key",
+          name: d.label || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    if (resolution.action === "skip") return {};
+    const store2 = getStore13();
+    const d = entity.data;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.delete(d.id);
+      } catch {
+      }
+    }
+    await store2.create({
+      tenantId,
+      projectId: d.projectId,
+      workspaceId: d.workspaceId,
+      label: d.label
+    });
+    return { newId: void 0 };
+  }
+};
+
+// src/export_registrations/eval.registration.ts
+var import_core50 = require("@axiom-lattice/core");
+function getStore14() {
+  return (0, import_core50.getStoreLattice)("default", "eval").store;
+}
+var evalRegistration = {
+  entityType: "eval",
+  label: "Eval(\u8BC4\u4F30)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  referenceFields: { suiteId: "eval_suite", projectId: "eval_project", runId: "eval_run", caseId: "eval_case" },
+  async listForExport(tenantId) {
+    const store2 = getStore14();
+    const projects = await store2.getProjectsByTenant(tenantId);
+    const entities = [];
+    for (const project of projects) {
+      entities.push({
+        _exportId: "",
+        data: {
+          _subType: "eval_project",
+          id: project.id,
+          name: project.name,
+          description: project.description,
+          version: project.version,
+          judgeModelConfig: project.judgeModelConfig,
+          targetServerConfig: project.targetServerConfig,
+          concurrency: project.concurrency,
+          reportConfig: project.reportConfig
+        }
+      });
+      const suites = await store2.getSuitesByProject(tenantId, project.id);
+      for (const suite of suites) {
+        entities.push({
+          _exportId: "",
+          data: {
+            _subType: "eval_suite",
+            id: suite.id,
+            projectId: suite.projectId,
+            name: suite.name
+          }
+        });
+        const cases = await store2.getCasesBySuite(tenantId, suite.id);
+        for (const c of cases) {
+          entities.push({
+            _exportId: "",
+            data: {
+              _subType: "eval_case",
+              id: c.id,
+              suiteId: c.suiteId,
+              inputMessage: c.inputMessage,
+              inputFiles: c.inputFiles,
+              steps: c.steps,
+              outputType: c.outputType,
+              contentAssertion: c.contentAssertion,
+              rubrics: c.rubrics
+            }
+          });
+        }
+      }
+      const runs = await store2.getRunsByTenant(tenantId, { projectId: project.id });
+      for (const run of runs) {
+        entities.push({
+          _exportId: "",
+          data: {
+            _subType: "eval_run",
+            id: run.id,
+            projectId: run.projectId,
+            status: run.status,
+            concurrency: run.concurrency,
+            totalCases: run.totalCases,
+            passedCases: run.passedCases,
+            failedCases: run.failedCases,
+            avgScore: run.avgScore,
+            error: run.error
+          }
+        });
+        const results = await store2.getResultsByRun(tenantId, run.id);
+        for (const result of results) {
+          entities.push({
+            _exportId: "",
+            data: {
+              _subType: "eval_run_result",
+              id: result.id,
+              runId: result.runId,
+              suiteName: result.suiteName,
+              caseId: result.caseId,
+              pass: result.pass,
+              score: result.score,
+              summary: result.summary,
+              dimensionResults: result.dimensionResults,
+              durationMs: result.durationMs,
+              messages: result.messages,
+              logs: result.logs,
+              error: result.error
+            }
+          });
+        }
+      }
+    }
+    return entities;
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore14();
+    const existingProjects = await store2.getProjectsByTenant(tenantId);
+    const existingProjectIds = new Set(existingProjects.map((p) => p.id));
+    const existingProjectNames = new Set(existingProjects.map((p) => p.name));
+    const existingSuites = /* @__PURE__ */ new Map();
+    const existingSuiteIds = /* @__PURE__ */ new Set();
+    const existingCaseIds = /* @__PURE__ */ new Set();
+    const existingRunIds = /* @__PURE__ */ new Set();
+    const existingResultIds = /* @__PURE__ */ new Set();
+    for (const project of existingProjects) {
+      const suites = await store2.getSuitesByProject(tenantId, project.id);
+      existingSuites.set(project.id, new Set(suites.map((s) => `${s.projectId}:${s.name}`)));
+      for (const s of suites) {
+        existingSuiteIds.add(s.id);
+        try {
+          const cases = await store2.getCasesBySuite(tenantId, s.id);
+          for (const c of cases) existingCaseIds.add(c.id);
+        } catch {
+        }
+      }
+    }
+    for (const project of existingProjects) {
+      const runs = await store2.getRunsByTenant(tenantId, { projectId: project.id });
+      for (const run of runs) {
+        existingRunIds.add(run.id);
+        try {
+          const results = await store2.getResultsByRun(tenantId, run.id);
+          for (const r of results) existingResultIds.add(r.id);
+        } catch {
+        }
+      }
+    }
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const subType = d._subType;
+      const id = d.id;
+      switch (subType) {
+        case "eval_project": {
+          const name = d.name;
+          if (existingProjectIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_project",
+              conflictType: "id_exists",
+              existingId: id,
+              existingName: name
+            });
+          } else if (name && existingProjectNames.has(name)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_project",
+              conflictType: "unique_constraint",
+              existingName: name,
+              field: "name"
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: "eval_project", name });
+          }
+          break;
+        }
+        case "eval_suite": {
+          const projectId = d.projectId;
+          const name = d.name;
+          const suiteKey = `${projectId}:${name}`;
+          const projectSuites = existingSuites.get(projectId);
+          if (existingSuiteIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_suite",
+              conflictType: "id_exists",
+              existingId: id,
+              existingName: name
+            });
+          } else if (projectSuites?.has(suiteKey)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_suite",
+              conflictType: "unique_constraint",
+              existingName: name,
+              field: "projectId+name"
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: "eval_suite", name });
+          }
+          break;
+        }
+        case "eval_case": {
+          if (existingCaseIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_case",
+              conflictType: "id_exists",
+              existingId: id
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: "eval_case", name: id });
+          }
+          break;
+        }
+        case "eval_run": {
+          if (existingRunIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_run",
+              conflictType: "id_exists",
+              existingId: id
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: "eval_run", name: id });
+          }
+          break;
+        }
+        case "eval_run_result": {
+          if (existingResultIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_run_result",
+              conflictType: "id_exists",
+              existingId: id
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: "eval_run_result", name: id });
+          }
+          break;
+        }
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    if (resolution.action === "skip") return {};
+    const store2 = getStore14();
+    const d = entity.data;
+    const subType = d._subType;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : d.id;
+    switch (subType) {
+      case "eval_project": {
+        if (resolution.action === "overwrite") {
+          try {
+            await store2.deleteProject(tenantId, id);
+          } catch {
+          }
+        }
+        await store2.createProject(tenantId, id, {
+          name: d.name,
+          description: d.description,
+          version: d.version,
+          judgeModelConfig: d.judgeModelConfig,
+          targetServerConfig: d.targetServerConfig,
+          concurrency: d.concurrency,
+          reportConfig: d.reportConfig
+        });
+        break;
+      }
+      case "eval_suite": {
+        if (resolution.action === "overwrite") {
+          try {
+            await store2.deleteSuite(tenantId, id);
+          } catch {
+          }
+        }
+        await store2.createSuite(tenantId, d.projectId, id, {
+          name: d.name
+        });
+        break;
+      }
+      case "eval_case": {
+        if (resolution.action === "overwrite") {
+          try {
+            await store2.deleteCase(tenantId, id);
+          } catch {
+          }
+        }
+        await store2.createCase(tenantId, d.suiteId, id, {
+          inputMessage: d.inputMessage,
+          inputFiles: d.inputFiles,
+          steps: d.steps,
+          outputType: d.outputType,
+          contentAssertion: d.contentAssertion,
+          rubrics: d.rubrics
+        });
+        break;
+      }
+      case "eval_run": {
+        if (resolution.action === "overwrite") {
+          try {
+            await store2.deleteRun(tenantId, id);
+          } catch {
+          }
+        }
+        await store2.createRun(tenantId, d.projectId, id, {
+          totalCases: d.totalCases,
+          concurrency: d.concurrency
+        });
+        break;
+      }
+      case "eval_run_result": {
+        if (resolution.action === "overwrite") {
+          try {
+            await store2.deleteRunResult(tenantId, entity.data.id);
+          } catch {
+          }
+        }
+        await store2.createRunResult(tenantId, d.runId, id, {
+          suiteName: d.suiteName,
+          caseId: d.caseId,
+          pass: d.pass,
+          score: d.score,
+          summary: d.summary,
+          dimensionResults: d.dimensionResults,
+          durationMs: d.durationMs,
+          messages: d.messages,
+          logs: d.logs,
+          error: d.error
+        });
+        break;
+      }
+    }
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/index.ts
+function registerAllBuiltinEntities() {
+  const registry = import_core51.ExportableEntityRegistry.getInstance();
+  registry.register(skillRegistration);
+  registry.register(agentRegistration);
+  registry.register(bindingRegistration);
+  registry.register(databaseConfigRegistration);
+  registry.register(metricsConfigRegistration);
+  registry.register(mcpConfigRegistration);
+  registry.register(connectionRegistration);
+  registry.register(collectionRegistration);
+  registry.register(channelInstallationRegistration);
+  registry.register(menuRegistration);
+  registry.register(taskRegistration);
+  registry.register(a2aApiKeyRegistration);
+  registry.register(evalRegistration);
+}
+
 // src/router/MessageRouter.ts
-var import_core36 = require("@axiom-lattice/core");
-var import_crypto9 = require("crypto");
+var import_core52 = require("@axiom-lattice/core");
+var import_crypto10 = require("crypto");
 var BindingNotFoundError = class extends Error {
   constructor(message) {
     super(message);
@@ -9661,7 +11456,7 @@ var MessageRouter = class {
             channel: message.channel,
             adapterChannel: adapter.channel
           }, "Thread resolved by adapter strategy");
-          const threadStore = (0, import_core36.getStoreLattice)("default", "thread").store;
+          const threadStore = (0, import_core52.getStoreLattice)("default", "thread").store;
           try {
             await threadStore.createThread(
               tenantId,
@@ -9698,8 +11493,8 @@ var MessageRouter = class {
           }
         }
         if (!threadId) {
-          const threadStore = (0, import_core36.getStoreLattice)("default", "thread").store;
-          const newThreadId = (0, import_crypto9.randomUUID)();
+          const threadStore = (0, import_core52.getStoreLattice)("default", "thread").store;
+          const newThreadId = (0, import_crypto10.randomUUID)();
           console.log({
             event: "dispatch:thread:create",
             agentId,
@@ -9738,7 +11533,7 @@ var MessageRouter = class {
           senderId: message.sender.id,
           contentLength: message.content.text.length
         }, "Dispatching to agent");
-        const agent = import_core36.agentInstanceManager.getAgent({
+        const agent = import_core52.agentInstanceManager.getAgent({
           tenant_id: tenantId,
           assistant_id: agentId,
           thread_id: threadId,
@@ -9983,7 +11778,7 @@ function createAuditLoggerMiddleware() {
 }
 
 // src/index.ts
-var import_core40 = require("@axiom-lattice/core");
+var import_core56 = require("@axiom-lattice/core");
 
 // src/swagger.ts
 var import_swagger = __toESM(require("@fastify/swagger"));
@@ -10048,7 +11843,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core37 = require("@axiom-lattice/core");
+var import_core53 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -10066,17 +11861,17 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
     console.log(
       `\u5F00\u59CB\u5904\u7406\u4EFB\u52A1 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
     );
-    const agent = import_core37.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
-    await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core37.QueueMode.STEER);
+    const agent = import_core53.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
+    await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core53.QueueMode.STEER);
     if (callback_event) {
       agent.subscribeOnce("message:completed", (evt) => {
-        import_core37.eventBus.publish(callback_event, {
+        import_core53.eventBus.publish(callback_event, {
           success: true,
           state: evt.state
         });
         if (main_thread_id && main_tenant_id) {
           try {
-            const mainAgent = import_core37.agentInstanceManager.getAgent({
+            const mainAgent = import_core53.agentInstanceManager.getAgent({
               assistant_id: main_assistant_id ?? assistant_id,
               thread_id: main_thread_id,
               tenant_id: main_tenant_id,
@@ -10106,7 +11901,7 @@ ${summary}`
         }
       });
       agent.subscribeOnce("message:interrupted", (evt) => {
-        import_core37.eventBus.publish(callback_event, {
+        import_core53.eventBus.publish(callback_event, {
           success: true,
           state: evt.state
         });
@@ -10129,7 +11924,7 @@ ${summary}`
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core37.eventBus.publish(callback_event, {
+      import_core53.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -10166,7 +11961,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core37.eventBus.subscribe(import_core37.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core53.eventBus.subscribe(import_core53.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
     this.startPollingQueue();
     console.log("Agent\u4EFB\u52A1\u6D88\u8D39\u8005\u5DF2\u542F\u52A8\u5E76\u76D1\u542C\u4EFB\u52A1\u4E8B\u4EF6\u548C\u961F\u5217");
   }
@@ -10285,7 +12080,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
     handleAgentTask(taskRequest).catch((error) => {
       console.error("\u5904\u7406Agent\u4EFB\u52A1\u65F6\u53D1\u751F\u672A\u6355\u83B7\u7684\u9519\u8BEF:", error);
       if (taskRequest.callback_event) {
-        import_core37.eventBus.publish(taskRequest.callback_event, {
+        import_core53.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error)
         });
@@ -10300,7 +12095,7 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core41 = require("@axiom-lattice/core");
+var import_core57 = require("@axiom-lattice/core");
 var import_protocols5 = require("@axiom-lattice/protocols");
 var import_meta = {};
 process.on("unhandledRejection", (reason, promise) => {
@@ -10316,11 +12111,11 @@ var DEFAULT_LOGGER_CONFIG = {
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger5 = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core41.loggerLatticeManager.hasLattice("default")) {
-    import_core41.loggerLatticeManager.removeLattice("default");
+  if (import_core57.loggerLatticeManager.hasLattice("default")) {
+    import_core57.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core41.registerLoggerLattice)("default", config);
-  return (0, import_core41.getLoggerLattice)("default");
+  (0, import_core57.registerLoggerLattice)("default", config);
+  return (0, import_core57.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -10431,7 +12226,7 @@ app.setErrorHandler((error, request, reply) => {
 });
 function getConfiguredSandboxProvider() {
   const sandboxProviderType = process.env.SANDBOX_PROVIDER_TYPE || "microsandbox-remote";
-  return (0, import_core41.createSandboxProvider)({
+  return (0, import_core57.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -10447,7 +12242,7 @@ function getConfiguredSandboxProvider() {
 }
 async function restoreMcpConnections() {
   try {
-    const storeLattice = (0, import_core41.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core57.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     if (!store2) {
       logger5.info("MCP store not configured, skipping connection restoration");
@@ -10461,15 +12256,15 @@ async function restoreMcpConnections() {
     for (const config of connectedConfigs) {
       try {
         const connection = convertToConnection2(config.config);
-        import_core41.mcpManager.addServer(config.key, connection);
+        import_core57.mcpManager.addServer(config.key, connection);
       } catch (err) {
         logger5.warn(`Failed to prepare MCP server "${config.key}" for restoration`, { error: err });
       }
     }
-    await import_core41.mcpManager.connect();
+    await import_core57.mcpManager.connect();
     for (const config of connectedConfigs) {
       try {
-        await import_core41.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
+        await import_core57.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
         logger5.info(`MCP server "${config.key}" restored with ${config.selectedTools.length} tools`);
       } catch (err) {
         logger5.warn(`Failed to register tools for MCP server "${config.key}"`, { error: err });
@@ -10499,10 +12294,10 @@ var start = async (config) => {
     const { wechatChannelAdapter: wechatChannelAdapter2 } = await Promise.resolve().then(() => (init_WechatChannelAdapter(), WechatChannelAdapter_exports));
     adapterRegistry.register(wechatChannelAdapter2);
     try {
-      const { getStoreLattice: getStore2 } = await import("@axiom-lattice/core");
-      const bindingStore = getStore2("default", "channelBinding").store;
-      const installationStore = getStore2("default", "channelInstallation").store;
-      (0, import_core40.setBindingRegistry)(bindingStore);
+      const { getStoreLattice: getStore15 } = await import("@axiom-lattice/core");
+      const bindingStore = getStore15("default", "channelBinding").store;
+      const installationStore = getStore15("default", "channelInstallation").store;
+      (0, import_core56.setBindingRegistry)(bindingStore);
       const router = new MessageRouter({
         middlewares: [
           createDeduplicationMiddleware(),
@@ -10515,7 +12310,7 @@ var start = async (config) => {
       });
       channelDeps = { router, installationStore };
       try {
-        const a2aKeyStore = getStore2("default", "a2aApiKey").store;
+        const a2aKeyStore = getStore15("default", "a2aApiKey").store;
         const a2a = await Promise.resolve().then(() => (init_a2a(), a2a_exports));
         a2a.setA2AKeyStore(a2aKeyStore);
         await a2a.refreshStoreKeyMap();
@@ -10527,27 +12322,29 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
+    (0, import_core56.setEvalRunService)(evalRunner);
     try {
-      const menuStore = (0, import_core41.getStoreLattice)("default", "menu").store;
-      (0, import_core40.setMenuRegistry)(menuStore);
+      const menuStore = (0, import_core57.getStoreLattice)("default", "menu").store;
+      (0, import_core56.setMenuRegistry)(menuStore);
       logger5.info("Menu registry initialized");
     } catch {
     }
+    registerAllBuiltinEntities();
     if (channelDeps?.router) {
       setChannelControllerDeps({ adapterRegistry, router: channelDeps.router });
     }
     registerLatticeRoutes(app, channelDeps);
-    if (!import_core41.sandboxLatticeManager.hasLattice("default")) {
-      import_core41.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+    if (!import_core57.sandboxLatticeManager.hasLattice("default")) {
+      import_core57.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
       logger5.info("Registered sandbox manager from env configuration");
     }
     try {
       const { ResourceController: ResourceController2 } = await Promise.resolve().then(() => (init_resources(), resources_exports));
-      const sharedResourceStore = (0, import_core41.getStoreLattice)("default", "sharedResource").store;
-      const cache = new import_core41.TokenCache();
+      const sharedResourceStore = (0, import_core57.getStoreLattice)("default", "sharedResource").store;
+      const cache = new import_core57.TokenCache();
       const resourceController = new ResourceController2({
         store: sharedResourceStore,
-        sandboxManager: import_core41.sandboxLatticeManager,
+        sandboxManager: import_core57.sandboxLatticeManager,
         cache,
         logger: logger5
       });
@@ -10587,11 +12384,13 @@ var start = async (config) => {
         agentTaskConsumer.startPollingQueue();
       }
     }
-    import_core41.agentInstanceManager.restore().then((stats) => {
-      logger5.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
-    }).catch((error) => {
-      logger5.error("Agent recovery failed", { error });
-    });
+    if (process.env.AXIOM_RESTORE_PENDING_ON_STARTUP === "true") {
+      import_core57.agentInstanceManager.restore().then((stats) => {
+        logger5.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
+      }).catch((error) => {
+        logger5.error("Agent recovery failed", { error });
+      });
+    }
     restoreMcpConnections().catch((error) => {
       logger5.error("MCP connection restoration failed", { error });
     });