@axiom-lattice/gateway 4.2.0 → 4.2.1

package/dist/index.js

@@ -30,6 +30,178 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/services/collection_service.ts
+var collection_service_exports = {};
+__export(collection_service_exports, {
+  CollectionService: () => CollectionService
+});
+function getTenantId5(request) {
+  return request.user?.tenantId || request.headers["x-tenant-id"] || "default";
+}
+var import_uuid2, import_documents, import_core11, CollectionService;
+var init_collection_service = __esm({
+  "src/services/collection_service.ts"() {
+    "use strict";
+    import_uuid2 = require("uuid");
+    import_documents = require("@langchain/core/documents");
+    import_core11 = require("@axiom-lattice/core");
+    CollectionService = class {
+      // ─── Collection CRUD ──────────────────────────────────────────
+      async getAllCollections(request) {
+        const tenantId = getTenantId5(request);
+        const collections = await import_core11.collectionLatticeManager.getAllCollections(tenantId);
+        for (const c2 of collections) {
+          try {
+            c2._entryCount = await (0, import_core11.getCollectionEntryCount)(c2.name, c2.embeddingKey, c2.tenantId);
+          } catch {
+            c2._entryCount = 0;
+          }
+        }
+        return collections;
+      }
+      async getCollectionByName(request, name) {
+        const tenantId = getTenantId5(request);
+        return import_core11.collectionLatticeManager.getCollection(tenantId, name);
+      }
+      async createCollection(request, data) {
+        const tenantId = getTenantId5(request);
+        const collection = await import_core11.collectionLatticeManager.registerCollection(tenantId, data);
+        try {
+          await (0, import_core11.getOrCreateCollectionVectorStore)(data.name, data.embeddingKey, tenantId);
+        } catch (err) {
+          console.warn(`[CollectionService] Failed to init vector store for ${data.name}:`, err);
+        }
+        return collection;
+      }
+      async updateCollection(request, name, updates) {
+        const tenantId = getTenantId5(request);
+        return import_core11.collectionLatticeManager.updateCollection(tenantId, name, updates);
+      }
+      async deleteCollection(request, name) {
+        const tenantId = getTenantId5(request);
+        await (0, import_core11.removeCollectionVectorStore)(name, tenantId);
+        return import_core11.collectionLatticeManager.removeCollection(tenantId, name);
+      }
+      // ─── Entry CRUD ───────────────────────────────────────────────
+      async getEntries(request, collectionName) {
+        const collection = await this.getCollectionByName(request, collectionName);
+        if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+        const docs = await (0, import_core11.listCollectionEntries)(collectionName, collection.embeddingKey, collection.tenantId);
+        return docs.map((doc) => ({
+          id: doc.metadata._id || "",
+          content: doc.pageContent,
+          metadata: Object.fromEntries(
+            Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
+          )
+        }));
+      }
+      async createEntry(request, collectionName, data) {
+        const collection = await this.getCollectionByName(request, collectionName);
+        if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+        const vectorStore = await (0, import_core11.getOrCreateCollectionVectorStore)(
+          collectionName,
+          collection.embeddingKey,
+          collection.tenantId
+        );
+        const entryId = (0, import_uuid2.v4)();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const doc = new import_documents.Document({
+          pageContent: data.content,
+          metadata: {
+            _id: entryId,
+            _created_at: now,
+            _updated_at: now,
+            ...data.metadata || {}
+          }
+        });
+        await vectorStore.addDocuments([doc]);
+        return { id: entryId, content: data.content, metadata: data.metadata || {} };
+      }
+      async getEntry(request, collectionName, entryId) {
+        const collection = await this.getCollectionByName(request, collectionName);
+        if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+        const docs = await (0, import_core11.listCollectionEntries)(collectionName, collection.embeddingKey, collection.tenantId);
+        const doc = docs.find((d) => d.metadata._id === entryId);
+        if (!doc) return null;
+        return {
+          id: entryId,
+          content: doc.pageContent,
+          metadata: Object.fromEntries(
+            Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
+          )
+        };
+      }
+      async updateEntry(request, collectionName, entryId, data) {
+        const existing = await this.getEntry(request, collectionName, entryId);
+        if (!existing) return null;
+        const collection = await this.getCollectionByName(request, collectionName);
+        if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+        const vectorStore = await (0, import_core11.getOrCreateCollectionVectorStore)(
+          collectionName,
+          collection.embeddingKey,
+          collection.tenantId
+        );
+        try {
+          await vectorStore.delete({ filter: { _id: entryId } });
+        } catch {
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const mergedMetadata = { ...existing.metadata, ...data.metadata || {} };
+        const doc = new import_documents.Document({
+          pageContent: data.content ?? existing.content,
+          metadata: { _id: entryId, _created_at: now, _updated_at: now, ...mergedMetadata }
+        });
+        await vectorStore.addDocuments([doc]);
+        return { id: entryId, content: data.content ?? existing.content, metadata: mergedMetadata };
+      }
+      async deleteEntry(request, collectionName, entryId) {
+        const collection = await this.getCollectionByName(request, collectionName);
+        if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+        const vectorStore = await (0, import_core11.getOrCreateCollectionVectorStore)(
+          collectionName,
+          collection.embeddingKey,
+          collection.tenantId
+        );
+        try {
+          await vectorStore.delete({ filter: { _id: entryId } });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async searchEntries(request, collectionName, params) {
+        const collection = await this.getCollectionByName(request, collectionName);
+        if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+        const vectorStore = await (0, import_core11.getOrCreateCollectionVectorStore)(
+          collectionName,
+          collection.embeddingKey,
+          collection.tenantId
+        );
+        let embeddings;
+        try {
+          embeddings = import_core11.embeddingsLatticeManager.getEmbeddingsClient(collection.embeddingKey);
+        } catch {
+          embeddings = import_core11.embeddingsLatticeManager.getEmbeddingsClient("default");
+        }
+        const queryVector = await embeddings.embedQuery(params.query);
+        const results = await vectorStore.similaritySearchVectorWithScore(
+          queryVector,
+          params.top_k || 5,
+          params.filter
+        );
+        return results.map(([doc, score]) => ({
+          id: doc.metadata._id || (0, import_uuid2.v4)(),
+          content: doc.pageContent,
+          metadata: Object.fromEntries(
+            Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
+          ),
+          score
+        }));
+      }
+    };
+  }
+});
+
 // src/utils/mime.ts
 function getContentTypeFromFilename(filename) {
   const ext = filename.includes(".") ? filename.slice(filename.lastIndexOf(".")).toLowerCase() : "";
@@ -78,6 +250,74 @@ var init_mime = __esm({
   }
 });
 
+// src/services/open/openToken.ts
+var openToken_exports = {};
+__export(openToken_exports, {
+  signOpenToken: () => signOpenToken,
+  verifyOpenToken: () => verifyOpenToken
+});
+function secret() {
+  return process.env.OPEN_TOKEN_SECRET || process.env.AUTH_TOKEN_SECRET || "open-token-dev-secret-fallback";
+}
+function signOpenToken(payload) {
+  const data = { ...payload, exp: payload.exp ?? Date.now() + 15 * 60 * 1e3 };
+  const encoded = Buffer.from(JSON.stringify(data)).toString("base64url");
+  const sig = (0, import_crypto5.createHmac)("sha256", secret()).update(encoded).digest("base64url");
+  return `${encoded}.${sig}`;
+}
+function verifyOpenToken(bearer) {
+  if (!bearer) return null;
+  const parts = bearer.split(".");
+  if (parts.length !== 2) return null;
+  const [encoded, sigStr] = parts;
+  if (!/^[A-Za-z0-9_-]{43}$/.test(sigStr)) return null;
+  try {
+    const actual = Buffer.from(sigStr, "base64url");
+    if (actual.toString("base64url") !== sigStr) return null;
+    const expected = (0, import_crypto5.createHmac)("sha256", secret()).update(encoded).digest();
+    if (actual.length !== expected.length || !(0, import_crypto5.timingSafeEqual)(actual, expected)) return null;
+    const payload = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    if (typeof payload !== "object" || payload === null) return null;
+    const p = payload;
+    if (typeof p.exp !== "number" || p.exp < Date.now() || p.kind !== "sandbox_token" && p.kind !== "browser_token" || typeof p.tenantId !== "string" || typeof p.projectId !== "string" || typeof p.grants !== "object") {
+      return null;
+    }
+    return p;
+  } catch {
+    return null;
+  }
+}
+var import_crypto5;
+var init_openToken = __esm({
+  "src/services/open/openToken.ts"() {
+    "use strict";
+    import_crypto5 = require("crypto");
+  }
+});
+
+// src/services/open/previewToken.ts
+function buildPreviewToken(ids) {
+  return signOpenToken({
+    kind: "browser_token",
+    tenantId: ids.tenantId,
+    workspaceId: ids.workspaceId,
+    projectId: ids.projectId,
+    preview: true,
+    grants: BROWSER_GRANTS
+  });
+}
+function buildPreviewTokenScript(ids) {
+  return `<script>window.__OPEN_API_TOKEN__=${JSON.stringify(buildPreviewToken(ids))};</script>`;
+}
+var BROWSER_GRANTS;
+var init_previewToken = __esm({
+  "src/services/open/previewToken.ts"() {
+    "use strict";
+    init_openToken();
+    BROWSER_GRANTS = [{ domain: "kb", items: ["search"] }];
+  }
+});
+
 // src/utils/path-containment.ts
 function isPathWithinRoot(rootPath, targetPath) {
   const relative2 = path2.relative(rootPath, targetPath);
@@ -333,7 +573,7 @@ async function createMcpServerConfig(request, reply) {
         message: "MCP server configuration with this key already exists"
       };
     }
-    const id3 = body.id || (0, import_crypto7.randomUUID)();
+    const id3 = body.id || (0, import_crypto8.randomUUID)();
     const config = await store2.createConfig(tenantId, id3, body);
     try {
       await connectAndRegisterTools(config);
@@ -670,12 +910,12 @@ function registerMcpServerConfigRoutes(app2) {
   app2.post("/api/mcp-servers/:key/disconnect", disconnectMcpServer);
   app2.post("/api/mcp-servers/test-tools", testMcpServerTools);
 }
-var import_core30, import_crypto7;
+var import_core30, import_crypto8;
 var init_mcp_configs = __esm({
   "src/controllers/mcp-configs.ts"() {
     "use strict";
     import_core30 = require("@axiom-lattice/core");
-    import_crypto7 = require("crypto");
+    import_crypto8 = require("crypto");
   }
 });
 
@@ -1264,10 +1504,11 @@ function devModeDefaults() {
   const projectId = process.env[DEFAULT_PROJECT_ENV] || void 0;
   return { tenantId, projectId };
 }
-var A2AAuthError, DEFAULT_TENANT_ENV, DEFAULT_TENANT_ID, DEFAULT_PROJECT_ENV, BEARER_SCHEME_RE, A2AAuthService;
+var import_protocols29, A2AAuthError, DEFAULT_TENANT_ENV, DEFAULT_TENANT_ID, DEFAULT_PROJECT_ENV, BEARER_SCHEME_RE, A2AAuthService;
 var init_A2AAuthService = __esm({
   "src/services/a2a/A2AAuthService.ts"() {
     "use strict";
+    import_protocols29 = require("@axiom-lattice/protocols");
     A2AAuthError = class extends Error {
       constructor(message, statusCode) {
         super(message);
@@ -1321,20 +1562,26 @@ var init_A2AAuthService = __esm({
         const merged = new Map([...this.envKeyMap, ...storeMap]);
         const entry = merged.get(token);
         if (!entry) return { authenticated: false };
+        const hasExplicitGrants = Array.isArray(entry.grants) && entry.grants.length > 0;
+        const agentGrant = (0, import_protocols29.effectiveGrants)(entry).find((g) => g.domain === "agent");
+        const assistantIds = hasExplicitGrants ? agentGrant?.items ?? [] : entry.assistantIds;
         return {
           authenticated: true,
           apiKey: token,
           tenantId: entry.tenantId,
           projectId: entry.projectId,
-          assistantIds: entry.assistantIds,
+          assistantIds,
           source: header2 && BEARER_SCHEME_RE.test(header2) ? "bearer" : "x-api-key"
         };
       }
       /**
-       * Assert that the given assistant is reachable under the provided auth context:
-       * authenticated, within the key's assistant whitelist, same tenant, and exposed.
+       * Assert that the given assistant is reachable under the provided auth
+       * context: authenticated, same tenant, and within the key's whitelist.
+       *
+       * Authorization is unified on the API key — the agent no longer carries an
+       * exposure flag; the key's assistant whitelist / grants is the single source.
        */
-      async assertExposedAgent(auth, assistantId) {
+      async assertAgentAccess(auth, assistantId) {
         if (!auth.authenticated || !auth.tenantId) {
           throw new A2AAuthError("Unauthorized", 401);
         }
@@ -1343,12 +1590,9 @@ var init_A2AAuthService = __esm({
           throw new A2AAuthError("Agent not found", 404);
         }
         const whitelist = auth.assistantIds;
-        if (whitelist && whitelist.length > 0 && !whitelist.includes(assistantId)) {
+        if (whitelist !== void 0 && !whitelist.includes(assistantId)) {
           throw new A2AAuthError("Agent not allowed for this key", 403);
         }
-        if (assistant.graphDefinition?.a2aExposure?.enabled !== true) {
-          throw new A2AAuthError("Agent not exposed", 404);
-        }
         return assistant;
       }
       /**
@@ -1356,7 +1600,7 @@ var init_A2AAuthService = __esm({
        * in the tenant and every assistant belongs to the same tenant.
        */
       async createKeyScoped(input) {
-        const { tenantId, projectId, assistantIds, label } = input;
+        const { tenantId, projectId, assistantIds, grants, label } = input;
         if (!projectId) {
           throw new A2AAuthError("projectId is required", 400);
         }
@@ -1372,7 +1616,25 @@ var init_A2AAuthService = __esm({
             }
           }
         }
-        return this.keyStore.create({ tenantId, projectId, assistantIds, label });
+        return this.keyStore.create({ tenantId, projectId, assistantIds, grants, label });
+      }
+      async updateKeyScoped(id3, tenantId, input) {
+        const { projectId, assistantIds, grants, label } = input;
+        if (projectId) {
+          const project = await this.projectStore.getProjectById(tenantId, projectId);
+          if (!project || project.tenantId !== tenantId) {
+            throw new A2AAuthError("Project not found", 400);
+          }
+        }
+        if (assistantIds && assistantIds.length > 0) {
+          for (const aId of assistantIds) {
+            const assistant = await this.assistantStore.getAssistantById(tenantId, aId);
+            if (!assistant || assistant.tenantId !== tenantId) {
+              throw new A2AAuthError("Assistant not found", 400);
+            }
+          }
+        }
+        return this.keyStore.update(id3, { label, projectId, assistantIds, grants });
       }
       extractToken(header2) {
         if (!header2) return void 0;
@@ -1387,42 +1649,45 @@ var init_A2AAuthService = __esm({
 });
 
 // src/services/a2a/A2AAgentCardBuilder.ts
+function deriveAgentSkills(assistant) {
+  const enabled = assistant.graphDefinition?.middleware?.filter((m) => m.enabled) ?? [];
+  return enabled.map((m) => ({
+    id: m.type || m.id,
+    name: m.name || m.type || m.id,
+    description: m.description || "",
+    tags: [],
+    examples: []
+  }));
+}
 function buildAgentCardForAssistant(params) {
-  const { assistant, exposure, baseUrl } = params;
+  const { assistant, baseUrl } = params;
   const jsonRpcUrl = `${baseUrl}/api/a2a/agents/${assistant.id}/jsonrpc`;
-  const skills = (exposure?.skills ?? []).map((s) => ({
-    id: s.id,
-    name: s.name,
-    description: s.description,
-    tags: s.tags ?? [],
-    examples: s.examples ?? []
-  }));
   return {
     name: assistant.name,
     description: assistant.description ?? "",
     url: jsonRpcUrl,
     protocolVersion: "0.3.0",
     version: "1.0.0",
-    defaultInputModes: exposure?.inputModes ?? ["text"],
-    defaultOutputModes: exposure?.outputModes ?? ["text"],
+    defaultInputModes: ["text"],
+    defaultOutputModes: ["text"],
     capabilities: {
       streaming: true,
       pushNotifications: false,
       stateTransitionHistory: true
     },
-    skills,
+    skills: deriveAgentSkills(assistant),
     additionalInterfaces: [{ transport: "JSONRPC", url: jsonRpcUrl }],
     securitySchemes: {
       bearer: {
         type: "http",
         scheme: "Bearer",
-        description: "A2A API key sent as an Authorization Bearer token"
+        description: "API key sent as an Authorization Bearer token"
       },
       apiKeyHeader: {
         type: "apiKey",
         in: "header",
         name: "x-api-key",
-        description: "A2A API key sent via the x-api-key header"
+        description: "API key sent via the x-api-key header"
       }
     },
     security: [{ bearer: [] }, { apiKeyHeader: [] }]
@@ -1896,13 +2161,20 @@ function agentMessage(text) {
     parts: [{ kind: "text", text }]
   };
 }
-var import_uuid11, import_core66, import_protocols29, _AxiomAgentExecutor, AxiomAgentExecutor;
+function assistantHasGovernedTask(assistant) {
+  const graph = assistant.graphDefinition;
+  const middleware = graph && typeof graph === "object" ? graph.middleware : void 0;
+  const taskMiddleware = Array.isArray(middleware) ? middleware.find((entry) => !!entry && typeof entry === "object" && entry.type === "task" && entry.enabled === true) : void 0;
+  const allowedTools = taskMiddleware?.allowedTools;
+  return !!taskMiddleware && (allowedTools === void 0 || Array.isArray(allowedTools) && (allowedTools.length === 0 || allowedTools.includes("manage_task")));
+}
+var import_uuid11, import_core66, import_protocols30, _AxiomAgentExecutor, AxiomAgentExecutor;
 var init_AxiomAgentExecutor = __esm({
   "src/services/a2a/AxiomAgentExecutor.ts"() {
     "use strict";
     import_uuid11 = require("uuid");
     import_core66 = require("@axiom-lattice/core");
-    import_protocols29 = require("@axiom-lattice/protocols");
+    import_protocols30 = require("@axiom-lattice/protocols");
     init_a2aFileRefs();
     init_task_file_refs();
     _AxiomAgentExecutor = class _AxiomAgentExecutor {
@@ -1949,18 +2221,13 @@ var init_AxiomAgentExecutor = __esm({
           });
         };
         try {
-          try {
-            if (!this.taskStore) {
-              throw new Error("A2A governed execution requires a canonical task store");
-            }
-            this.assertGovernedTaskCapability();
-          } catch (err) {
+          if (!this.taskStore) {
             const initialTask2 = createTask([]);
-            if (this.taskStore) await this.taskStore.save(initialTask2);
             bus.publish(initialTask2);
-            publishFailed(err);
+            publishFailed(new Error("A2A execution requires a canonical task store"));
             return;
           }
+          const governed = this.hasGovernedTaskCapability();
           const interruption = existing?.metadata?.interruption;
           const reviewInterruption = interruption && typeof interruption === "object" && interruption.type === "review_required";
           const reviewCommand = reviewInterruption ? this.reviewCommand(text) : void 0;
@@ -1997,13 +2264,13 @@ var init_AxiomAgentExecutor = __esm({
             const requestText = inputFiles.length > 0 ? `${text}
 
 ${formatFileRefsSection(inputFiles)}` : text;
-            const messageText = [
+            const messageText = governed ? [
               `A2A governed task instruction: get and update the existing TaskItem ${ctx.taskId}; do not create a replacement task.`,
               "Before doing the requested work, initialize its canonical description through manage_task with ## Objective, ## Acceptance Criteria, and ## Belief State sections.",
               "Keep lifecycle status truthful. Change status only through manage_task set_status; complete with a nonblank result and structured beliefImpact, and use interrupted, failed, or cancelled when appropriate. Use manage_task update for content fields only.",
               "",
               requestText
-            ].join("\n");
+            ].join("\n") : requestText;
             const continuationCommand = interruption && typeof interruption === "object" ? { resume: text } : void 0;
             const { messageId } = await agent.addMessage({
               input: { message: messageText },
@@ -2011,16 +2278,22 @@ ${formatFileRefsSection(inputFiles)}` : text;
               custom_run_config: { taskId: ctx.taskId }
             });
             const stream = agent.chunkStream(messageId, [
-              import_protocols29.MessageChunkTypes.MESSAGE_COMPLETED
+              import_protocols30.MessageChunkTypes.MESSAGE_COMPLETED
             ]);
+            let outputText = "";
+            let interrupted = false;
             for await (const chunk of stream) {
               if (execution.canceled) return;
               const chunkType = chunk.type;
               const chunkText = chunk.data?.content ?? "";
-              if (chunkType === import_protocols29.MessageChunkTypes.INTERRUPT) {
+              if (chunkType === import_protocols30.MessageChunkTypes.INTERRUPT) {
+                interrupted = true;
                 break;
               }
-              if (chunkType === import_protocols29.MessageChunkTypes.AI || chunkType === import_protocols29.MessageChunkTypes.TOOL) {
+              if (chunkType === import_protocols30.MessageChunkTypes.AI && chunkText) {
+                outputText += chunkText;
+              }
+              if (chunkType === import_protocols30.MessageChunkTypes.AI || chunkType === import_protocols30.MessageChunkTypes.TOOL) {
                 if (chunkText) {
                   bus.publish({
                     kind: "status-update",
@@ -2037,6 +2310,48 @@ ${formatFileRefsSection(inputFiles)}` : text;
               }
             }
             if (execution.canceled) return;
+            if (!governed) {
+              if (interrupted) {
+                const paused = {
+                  ...createTask(inputFiles),
+                  status: { state: "input-required", timestamp: isoNow() }
+                };
+                await this.taskStore.save(paused);
+                bus.publish({
+                  kind: "status-update",
+                  taskId: ctx.taskId,
+                  contextId: ctx.contextId,
+                  status: { state: "input-required", timestamp: isoNow() },
+                  final: true
+                });
+                return;
+              }
+              const resultArtifact = {
+                artifactId: (0, import_uuid11.v4)(),
+                name: "result",
+                parts: [{ kind: "text", text: outputText }]
+              };
+              const completed = {
+                ...createTask(inputFiles),
+                artifacts: [...existing?.artifacts ?? [], resultArtifact],
+                status: { state: "completed", timestamp: isoNow() }
+              };
+              await this.taskStore.save(completed);
+              bus.publish({
+                kind: "artifact-update",
+                taskId: ctx.taskId,
+                contextId: ctx.contextId,
+                artifact: resultArtifact
+              });
+              bus.publish({
+                kind: "status-update",
+                taskId: ctx.taskId,
+                contextId: ctx.contextId,
+                status: { state: "completed", timestamp: isoNow() },
+                final: true
+              });
+              return;
+            }
             const canonical = await this.taskStore.load(ctx.taskId);
             const canonicalState = canonical?.status.state;
             if (canonicalState === "completed") {
@@ -2116,15 +2431,8 @@ ${formatFileRefsSection(inputFiles)}` : text;
       taskKey(taskId) {
         return `${this.scope.tenantId}:${this.scope.projectId}:${this.scope.assistantId}:${taskId}`;
       }
-      assertGovernedTaskCapability() {
-        const graph = this.assistant.graphDefinition;
-        const middleware = graph && typeof graph === "object" ? graph.middleware : void 0;
-        const taskMiddleware = Array.isArray(middleware) ? middleware.find((entry) => !!entry && typeof entry === "object" && entry.type === "task" && entry.enabled === true) : void 0;
-        const allowedTools = taskMiddleware?.allowedTools;
-        const exposesManageTask = taskMiddleware && (allowedTools === void 0 || Array.isArray(allowedTools) && (allowedTools.length === 0 || allowedTools.includes("manage_task")));
-        if (!exposesManageTask) {
-          throw new Error("A2A execution requires enabled TaskMiddleware exposing manage_task");
-        }
+      hasGovernedTaskCapability() {
+        return assistantHasGovernedTask(this.assistant);
       }
       /**
        * Cancel a running task: resolve its thread id from the task store, abort the
@@ -2444,27 +2752,15 @@ function getHeader(value) {
   if (Array.isArray(value)) return value[0];
   return value;
 }
-function getTenantHeader(request) {
-  return getHeader(request.headers["x-tenant-id"]) ?? "default";
-}
 function getSessionUser(request) {
   return request.user;
 }
-function getSessionTenantId(request) {
-  const userTenantId = getSessionUser(request)?.tenantId;
-  if (userTenantId) return userTenantId;
-  return getTenantHeader(request);
-}
 function buildBaseUrl(request) {
   const protocol = getHeader(request.headers["x-forwarded-proto"]) ?? request.protocol;
   const forwardedHost = getHeader(request.headers["x-forwarded-host"]);
   const host = forwardedHost ? forwardedHost.split(",")[0].trim() : request.host;
   return `${protocol}://${host}`;
 }
-function getExposure(assistant) {
-  const graphDefinition = assistant.graphDefinition;
-  return graphDefinition?.a2aExposure;
-}
 function makeFileIngestor(tenantId, maxFileBytes) {
   return new A2AFileIngestor({
     saveProjectFile: (params) => saveProjectFile({ tenantId, ...params }),
@@ -2504,33 +2800,6 @@ function registerA2AStandardRoutes(app2, deps) {
   const resolveTaskWorkItems = deps.getTaskWorkItemStore ?? (() => (0, import_core67.getStoreLattice)("default", "taskWorkItem").store);
   const getAssistantStore2 = deps.getAssistantStore ?? (() => (0, import_core67.getStoreLattice)("default", "assistant").store);
   const getProjectStore2 = deps.getProjectStore ?? (() => (0, import_core67.getStoreLattice)("default", "project").store);
-  const getTenantStore = deps.getTenantStore ?? (() => {
-    try {
-      return (0, import_core67.getStoreLattice)("default", "tenant").store;
-    } catch {
-      return void 0;
-    }
-  });
-  async function findExposedAssistant(request, assistantId) {
-    const tenantId = getSessionTenantId(request);
-    const direct = await getAssistantStore2().getAssistantById(
-      tenantId,
-      assistantId
-    );
-    if (direct) return direct;
-    const tenantStore = getTenantStore();
-    if (!tenantStore) return null;
-    const tenants = await tenantStore.getAllTenants();
-    for (const tenant2 of tenants) {
-      if (tenant2.id === tenantId) continue;
-      const found = await getAssistantStore2().getAssistantById(
-        tenant2.id,
-        assistantId
-      );
-      if (found) return found;
-    }
-    return null;
-  }
   const runtimeRegistry = deps.runtimeRegistry ?? new A2ARuntimeRegistry();
   app2.addHook("onClose", async () => {
     runtimeRegistry.close();
@@ -2538,19 +2807,32 @@ function registerA2AStandardRoutes(app2, deps) {
   app2.get(
     "/api/a2a/agents/:assistantId/.well-known/agent-card.json",
     async (request, reply) => {
-      const assistant = await findExposedAssistant(
-        request,
-        request.params.assistantId
+      const auth = await authService.authenticate(
+        getHeader(request.headers.authorization) ?? getHeader(request.headers["x-api-key"])
       );
-      if (!assistant || getExposure(assistant)?.enabled !== true) {
-        reply.status(404).send({ error: "Not found" });
+      if (!auth.authenticated) {
+        reply.status(401).send({ error: "Unauthorized" });
+        return;
+      }
+      let assistant;
+      try {
+        assistant = await authService.assertAgentAccess(
+          auth,
+          request.params.assistantId
+        );
+      } catch (err) {
+        if (err instanceof A2AAuthError) {
+          reply.status(err.statusCode).send({ error: err.message });
+          return;
+        }
+        request.log.error({ err }, "a2a:agent-card:auth");
+        reply.status(500).send({ error: "Internal error" });
         return;
       }
       reply.header("A2A-Version", "0.3");
       reply.status(200).send(
         buildAgentCardForAssistant({
           assistant,
-          exposure: getExposure(assistant),
           baseUrl: buildBaseUrl(request)
         })
       );
@@ -2569,7 +2851,7 @@ function registerA2AStandardRoutes(app2, deps) {
       }
       let assistant;
       try {
-        assistant = await authService.assertExposedAgent(
+        assistant = await authService.assertAgentAccess(
           auth,
           request.params.assistantId
         );
@@ -2595,7 +2877,7 @@ function registerA2AStandardRoutes(app2, deps) {
       };
       const internalTasks = resolveTasks();
       const workItems = resolveTaskWorkItems();
-      const taskStore = new A2ATaskStoreAdapter({
+      const taskStore = assistantHasGovernedTask(assistant) ? new A2ATaskStoreAdapter({
         taskStore: internalTasks,
         workItemStore: workItems,
         lifecycle: (0, import_core67.createTaskLifecycleService)({
@@ -2603,12 +2885,11 @@ function registerA2AStandardRoutes(app2, deps) {
           workItemStore: workItems
         }),
         scope
-      });
+      }) : new import_server2.InMemoryTaskStore();
       const ingestor = makeFileIngestor(scope.tenantId, deps.maxFileBytes);
       const executor = new AxiomAgentExecutor({ scope, assistant, taskStore, ingestor });
       const card = buildAgentCardForAssistant({
         assistant,
-        exposure: getExposure(assistant),
         baseUrl: buildBaseUrl(request)
       });
       let runtimeLease;
@@ -2714,7 +2995,7 @@ data: ${JSON.stringify(errorResponse)}
       const ingestor = makeFileIngestor(scope.tenantId, deps.maxFileBytes);
       const internalTasks = resolveTasks();
       const workItems = resolveTaskWorkItems();
-      const taskStore = new A2ATaskStoreAdapter({
+      const taskStore = assistantHasGovernedTask(assistant) ? new A2ATaskStoreAdapter({
         taskStore: internalTasks,
         workItemStore: workItems,
         lifecycle: (0, import_core67.createTaskLifecycleService)({
@@ -2722,7 +3003,7 @@ data: ${JSON.stringify(errorResponse)}
           workItemStore: workItems
         }),
         scope
-      });
+      }) : new import_server2.InMemoryTaskStore();
       const executor = new AxiomAgentExecutor({ scope, assistant, taskStore, ingestor });
       const taskId = (0, import_uuid12.v4)();
       const contextId = (0, import_uuid12.v4)();
@@ -2857,6 +3138,7 @@ async function handleApiKeyCreate(request, reply) {
       tenantId,
       projectId: body.projectId,
       assistantIds: body.assistantIds,
+      grants: body.grants,
       label: body.label
     });
     await refreshStoreKeyMap();
@@ -2870,6 +3152,36 @@ async function handleApiKeyCreate(request, reply) {
     reply.status(500).send({ success: false, error: "Failed to create key" });
   }
 }
+async function handleApiKeyUpdate(request, reply) {
+  if (!_a2aKeyStore || !_a2aAuthService) {
+    reply.status(501).send({ error: "Key store not configured" });
+    return;
+  }
+  if (!await authorizeKeyMutation(request, reply)) return;
+  const body = request.body;
+  const tenantId = getUserTenantId(request);
+  try {
+    const record = await _a2aAuthService.updateKeyScoped(
+      request.params.id,
+      tenantId,
+      {
+        label: body.label,
+        projectId: body.projectId,
+        assistantIds: body.assistantIds,
+        grants: body.grants
+      }
+    );
+    await refreshStoreKeyMap();
+    reply.status(200).send({ success: true, data: record });
+  } catch (err) {
+    if (err instanceof A2AAuthError) {
+      reply.status(err.statusCode).send({ success: false, error: err.message });
+      return;
+    }
+    request.log.error({ err }, "a2a:keys:update");
+    reply.status(500).send({ success: false, error: "Failed to update key" });
+  }
+}
 async function handleApiKeyDelete(request, reply) {
   if (!await authorizeKeyMutation(request, reply)) return;
   await _a2aKeyStore.delete(request.params.id);
@@ -2896,36 +3208,43 @@ async function handleApiKeyRotate(request, reply) {
 }
 function registerA2ARoutes(app2) {
   const options = { preHandler: requireTenantSession };
-  app2.get(
-    "/api/a2a/keys",
-    options,
-    handleApiKeyList
-  );
-  app2.post(
-    "/api/a2a/keys",
-    options,
-    handleApiKeyCreate
-  );
-  app2.delete(
-    "/api/a2a/keys/:id",
-    options,
-    handleApiKeyDelete
-  );
-  app2.post(
-    "/api/a2a/keys/:id/disable",
-    options,
-    handleApiKeyDisable
-  );
-  app2.post(
-    "/api/a2a/keys/:id/enable",
-    options,
-    handleApiKeyEnable
-  );
-  app2.post(
-    "/api/a2a/keys/:id/rotate",
-    options,
-    handleApiKeyRotate
-  );
+  for (const base of ["/api/keys", "/api/a2a/keys"]) {
+    app2.get(
+      base,
+      options,
+      handleApiKeyList
+    );
+    app2.post(
+      base,
+      options,
+      handleApiKeyCreate
+    );
+    app2.delete(
+      `${base}/:id`,
+      options,
+      handleApiKeyDelete
+    );
+    app2.post(
+      `${base}/:id/disable`,
+      options,
+      handleApiKeyDisable
+    );
+    app2.post(
+      `${base}/:id/enable`,
+      options,
+      handleApiKeyEnable
+    );
+    app2.post(
+      `${base}/:id/rotate`,
+      options,
+      handleApiKeyRotate
+    );
+    app2.patch(
+      `${base}/:id`,
+      options,
+      handleApiKeyUpdate
+    );
+  }
 }
 var _a2aKeyStore, _a2aAuthService;
 var init_a2a = __esm({
@@ -2937,233 +3256,1358 @@ var init_a2a = __esm({
   }
 });
 
-// src/services/open/openCredentials.ts
-function resolveSpikeCredential(token) {
-  if (!token) return null;
-  return SPIKE_CREDENTIALS.get(token) ?? null;
-}
-var SPIKE_CREDENTIALS;
-var init_openCredentials = __esm({
-  "src/services/open/openCredentials.ts"() {
+// src/services/open/openAuthService.ts
+var import_protocols31, OpenAuthService;
+var init_openAuthService = __esm({
+  "src/services/open/openAuthService.ts"() {
     "use strict";
-    SPIKE_CREDENTIALS = /* @__PURE__ */ new Map([
-      [
-        "spike_all",
-        {
-          credentialId: "spike_all",
+    import_protocols31 = require("@axiom-lattice/protocols");
+    OpenAuthService = class {
+      constructor(keyStore) {
+        this.keyStore = keyStore;
+      }
+      async resolve(bearer) {
+        if (!bearer) return null;
+        const record = await this.keyStore.findByKey(bearer);
+        if (!record || !record.enabled) return null;
+        return {
+          credentialId: record.id,
           kind: "api_key",
-          tenantId: "spike-tenant",
-          projectId: "spike-project",
-          grants: [{ domain: "kb" }, { domain: "sandbox" }]
+          tenantId: record.tenantId,
+          projectId: record.projectId,
+          grants: (0, import_protocols31.effectiveGrants)(record)
+        };
+      }
+    };
+  }
+});
+
+// src/services/open/openCredentialService.ts
+var import_protocols32, OpenCredentialService;
+var init_openCredentialService = __esm({
+  "src/services/open/openCredentialService.ts"() {
+    "use strict";
+    import_protocols32 = require("@axiom-lattice/protocols");
+    init_openToken();
+    init_openAuthService();
+    OpenCredentialService = class {
+      constructor(keyStore, projectStore) {
+        this.projectStore = projectStore;
+        this.auth = new OpenAuthService(keyStore);
+      }
+      async resolve(bearer) {
+        if (!bearer) return null;
+        const token = verifyOpenToken(bearer);
+        if (token) {
+          if (token.kind === "sandbox_token") {
+            return {
+              credentialId: `sandbox:${token.sandboxName}`,
+              kind: "sandbox_token",
+              tenantId: token.tenantId,
+              projectId: token.projectId,
+              workspaceId: token.workspaceId,
+              sandboxName: token.sandboxName,
+              grants: token.grants
+            };
+          }
+          return {
+            credentialId: `browser:${token.preview ? "preview:" : ""}${token.shareId ?? token.tenantId}`,
+            kind: "browser_token",
+            tenantId: token.tenantId,
+            projectId: token.projectId,
+            workspaceId: token.workspaceId,
+            grants: token.grants
+          };
         }
-      ],
-      [
-        "spike_kb",
-        {
-          credentialId: "spike_kb",
-          kind: "api_key",
-          tenantId: "spike-tenant",
-          projectId: "spike-project",
-          grants: [{ domain: "kb" }]
+        const ctx = await this.auth.resolve(bearer);
+        if (!ctx) return null;
+        let workspaceId;
+        if (this.projectStore) {
+          try {
+            const project = await this.projectStore.getProjectById(
+              ctx.tenantId,
+              ctx.projectId
+            );
+            workspaceId = project?.workspaceId;
+          } catch {
+          }
         }
-      ]
-    ]);
+        return {
+          credentialId: ctx.credentialId,
+          kind: "api_key",
+          tenantId: ctx.tenantId,
+          projectId: ctx.projectId,
+          workspaceId,
+          grants: ctx.grants
+        };
+      }
+    };
   }
 });
 
-// src/services/open/mcpTransportRegistry.ts
-var mcpTransportRegistry_exports = {};
-__export(mcpTransportRegistry_exports, {
-  clearSessions: () => clearSessions,
-  deleteSession: () => deleteSession,
-  getSession: () => getSession,
-  registerSession: () => registerSession
-});
-async function registerSession(sessionId, credential, parts) {
-  sessions.set(sessionId, { ...parts, credential });
-}
-async function getSession(sessionId) {
-  return sessions.get(sessionId) ?? null;
+// src/services/open/openAuditService.ts
+function redactArgs(args, depth = 0) {
+  if (args === null || typeof args !== "object") return args;
+  if (depth > 6) return "[depth-limit]";
+  if (Array.isArray(args)) return args.map((v) => redactArgs(v, depth + 1));
+  const out = {};
+  for (const [key, value] of Object.entries(args)) {
+    out[key] = SENSITIVE_KEY.test(key) ? "[redacted]" : redactArgs(value, depth + 1);
+  }
+  return out;
 }
-async function deleteSession(sessionId) {
-  const entry = sessions.get(sessionId);
-  if (!entry) return;
-  sessions.delete(sessionId);
-  await entry.transport.close().catch(() => void 0);
-  await entry.server.close().catch(() => void 0);
+function truncate2(value) {
+  const s = JSON.stringify(value ?? null);
+  if (s.length <= MAX_ARGS_CHARS) return value ?? null;
+  return `${s.slice(0, MAX_ARGS_CHARS)}...[truncated]`;
 }
-async function clearSessions() {
-  for (const sessionId of [...sessions.keys()]) {
-    await deleteSession(sessionId);
+var SENSITIVE_KEY, MAX_ARGS_CHARS, OpenAuditService;
+var init_openAuditService = __esm({
+  "src/services/open/openAuditService.ts"() {
+    "use strict";
+    SENSITIVE_KEY = /pass(word)?|secret|token|api[-_]?key|authorization|credential/i;
+    MAX_ARGS_CHARS = 2e3;
+    OpenAuditService = class {
+      constructor(store2) {
+        this.store = store2;
+      }
+      async record(input) {
+        try {
+          await this.store.append({
+            ...input,
+            args: truncate2(redactArgs(input.args))
+          });
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// src/services/open/openRateLimiter.ts
+var OpenRateLimiter;
+var init_openRateLimiter = __esm({
+  "src/services/open/openRateLimiter.ts"() {
+    "use strict";
+    OpenRateLimiter = class {
+      constructor(options = {}) {
+        this.buckets = /* @__PURE__ */ new Map();
+        this.defaultPerMinute = options.defaultPerMinute ?? 60;
+        this.agentPerMinute = options.agentPerMinute ?? 10;
+      }
+      bucketClass(domain) {
+        return domain === "agent" ? "agent" : "default";
+      }
+      limitFor(domain) {
+        return domain === "agent" ? this.agentPerMinute : this.defaultPerMinute;
+      }
+      /** Consume one token; denied calls report how long to wait. */
+      check(credentialId, domain) {
+        const limit = this.limitFor(domain);
+        const key = `${this.bucketClass(domain)}:${credentialId}`;
+        const now = Date.now();
+        const bucket = this.buckets.get(key) ?? { tokens: limit, updatedAt: now };
+        const refillPerMs = limit / 6e4;
+        const elapsed = now - bucket.updatedAt;
+        bucket.tokens = Math.min(limit, bucket.tokens + elapsed * refillPerMs);
+        bucket.updatedAt = now;
+        if (bucket.tokens >= 1) {
+          bucket.tokens -= 1;
+          this.buckets.set(key, bucket);
+          return { allowed: true };
+        }
+        this.buckets.set(key, bucket);
+        const deficit = 1 - bucket.tokens;
+        return { allowed: false, retryAfterMs: Math.ceil(deficit / refillPerMs) };
+      }
+      /** Test helper. */
+      reset() {
+        this.buckets.clear();
+      }
+    };
   }
+});
+
+// src/services/open/openLattice.ts
+var openLattice_exports = {};
+__export(openLattice_exports, {
+  ActionNotFoundError: () => ActionNotFoundError,
+  GrantDeniedError: () => GrantDeniedError,
+  OpenLattice: () => OpenLattice,
+  ValidationError: () => ValidationError,
+  openLattice: () => openLattice
+});
+function effectiveToolName(domain, action) {
+  return action.toolName ?? `${domain}_${action.name}`;
 }
-var sessions;
-var init_mcpTransportRegistry = __esm({
-  "src/services/open/mcpTransportRegistry.ts"() {
+function grantCoversAction(grants, domain, action) {
+  return grants.some(
+    (g) => g.domain === domain && (!g.items || g.items.length === 0 || g.items.includes(action))
+  );
+}
+var import_zod16, GrantDeniedError, ValidationError, ActionNotFoundError, OpenLattice, openLattice;
+var init_openLattice = __esm({
+  "src/services/open/openLattice.ts"() {
+    "use strict";
+    import_zod16 = require("zod");
+    GrantDeniedError = class extends Error {
+      constructor(toolName) {
+        super(`GRANT_DENIED: no grant covers ${toolName}`);
+        this.code = "GRANT_DENIED";
+        this.name = "GrantDeniedError";
+      }
+    };
+    ValidationError = class extends Error {
+      constructor(detail) {
+        super(`VALIDATION_FAILED: ${detail}`);
+        this.code = "VALIDATION_FAILED";
+        this.name = "ValidationError";
+      }
+    };
+    ActionNotFoundError = class extends Error {
+      constructor(toolName) {
+        super(`ACTION_NOT_FOUND: ${toolName}`);
+        this.code = "ACTION_NOT_FOUND";
+        this.name = "ActionNotFoundError";
+      }
+    };
+    OpenLattice = class {
+      constructor() {
+        this.providers = /* @__PURE__ */ new Map();
+      }
+      /** Register a provider; domain+action collisions are rejected. */
+      register(declaration) {
+        const existing = this.providers.get(declaration.domain);
+        if (existing) {
+          throw new Error(
+            `Open provider domain already registered: ${declaration.domain}`
+          );
+        }
+        const actions = /* @__PURE__ */ new Map();
+        for (const action of declaration.actions) {
+          actions.set(action.name, action);
+        }
+        this.providers.set(declaration.domain, { declaration, actions });
+      }
+      /** Tool descriptors visible under the given grants (default-deny). */
+      async catalogFor(grants, ctx) {
+        const catalog = [];
+        for (const [domain, entry] of this.providers) {
+          for (const [actionName, action] of entry.actions) {
+            if (!grantCoversAction(grants, domain, actionName)) continue;
+            catalog.push({
+              toolName: effectiveToolName(domain, action),
+              domain,
+              action: actionName,
+              description: action.description,
+              schema: action.schema,
+              annotations: action.annotations
+            });
+          }
+          if (entry.declaration.instanceActions) {
+            const instances = await entry.declaration.instanceActions(grants, ctx);
+            for (const action of instances) {
+              catalog.push({
+                toolName: effectiveToolName(domain, action),
+                domain,
+                action: action.name,
+                description: action.description,
+                schema: action.schema,
+                annotations: action.annotations
+              });
+            }
+          }
+        }
+        return catalog;
+      }
+      /**
+       * Full grantable catalog (unfiltered by grants) for the management picker.
+       * Instance domains (agent) return an empty item list — the catalog service
+       * fills their per-tenant instances.
+       */
+      describeCatalog() {
+        const domains = [];
+        for (const [domain, entry] of this.providers) {
+          const declaration = entry.declaration;
+          const items = [];
+          if ((declaration.itemKind ?? "action") === "action") {
+            for (const [actionName, action] of entry.actions) {
+              items.push({
+                id: actionName,
+                toolName: `${domain}_${actionName}`,
+                label: action.label ?? actionName,
+                description: action.description,
+                annotations: action.annotations
+              });
+            }
+          }
+          domains.push({
+            domain,
+            label: declaration.label ?? domain,
+            source: declaration.source ?? "builtin",
+            scopeKind: declaration.scopeKind ?? "tenant",
+            itemKind: declaration.itemKind ?? "action",
+            items
+          });
+        }
+        return domains;
+      }
+      async resolveAction(grants, toolName, ctx) {
+        for (const [domain, entry] of this.providers) {
+          for (const [actionName, action] of entry.actions) {
+            if (effectiveToolName(domain, action) === toolName) {
+              return { domain, entry, action, actionName };
+            }
+          }
+          if (entry.declaration.instanceActions) {
+            const instances = await entry.declaration.instanceActions(grants, ctx);
+            for (const action of instances) {
+              if (effectiveToolName(domain, action) === toolName) {
+                return { domain, entry, action, actionName: action.name };
+              }
+            }
+          }
+        }
+        return null;
+      }
+      /** Whether the given grants cover a tool (`{domain}_{action}`). */
+      isAllowed(grants, toolName) {
+        const sep2 = toolName.indexOf("_");
+        const domain = sep2 > 0 ? toolName.slice(0, sep2) : toolName;
+        const action = sep2 > 0 ? toolName.slice(sep2 + 1) : "";
+        return grantCoversAction(grants, domain, action);
+      }
+      /** The single credential-driven execution path. */
+      async invoke(grants, ctx, toolName, args) {
+        const resolved = await this.resolveAction(grants, toolName, { tenantId: ctx.tenantId });
+        if (!resolved) {
+          throw new ActionNotFoundError(toolName);
+        }
+        if (!grantCoversAction(grants, resolved.domain, resolved.actionName)) {
+          throw new GrantDeniedError(toolName);
+        }
+        const resolvedSchema = resolved.action.schema;
+        const parsed = "safeParse" in resolvedSchema ? resolvedSchema.safeParse(args) : import_zod16.z.object(resolvedSchema).safeParse(args);
+        if (!parsed.success) {
+          throw new ValidationError(parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; "));
+        }
+        return resolved.entry.declaration.execute(resolved.actionName, parsed.data, ctx);
+      }
+    };
+    openLattice = new OpenLattice();
+  }
+});
+
+// src/services/open/mcpTransportRegistry.ts
+var mcpTransportRegistry_exports = {};
+__export(mcpTransportRegistry_exports, {
+  clearSessions: () => clearSessions,
+  deleteSession: () => deleteSession,
+  getSession: () => getSession,
+  registerSession: () => registerSession
+});
+async function registerSession(sessionId, credential, parts) {
+  sessions.set(sessionId, { ...parts, credential });
+}
+async function getSession(sessionId) {
+  return sessions.get(sessionId) ?? null;
+}
+async function deleteSession(sessionId) {
+  const entry = sessions.get(sessionId);
+  if (!entry) return;
+  sessions.delete(sessionId);
+  await entry.transport.close().catch(() => void 0);
+  await entry.server.close().catch(() => void 0);
+}
+async function clearSessions() {
+  for (const sessionId of [...sessions.keys()]) {
+    await deleteSession(sessionId);
+  }
+}
+var sessions;
+var init_mcpTransportRegistry = __esm({
+  "src/services/open/mcpTransportRegistry.ts"() {
+    "use strict";
+    sessions = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/services/open/openMcpServer.ts
+async function buildSessionServer(options) {
+  const { credential, grants, catalog, invoke } = options;
+  const server = new import_mcp.McpServer(OPEN_MCP_SERVER_INFO);
+  for (const tool of catalog) {
+    server.registerTool(
+      tool.toolName,
+      {
+        description: tool.description,
+        inputSchema: tool.schema,
+        annotations: {
+          readOnlyHint: tool.annotations.readOnlyHint,
+          destructiveHint: tool.annotations.destructiveHint
+        }
+      },
+      async (args) => {
+        const result = await invoke(tool.toolName, args);
+        return { content: result.content, isError: result.isError };
+      }
+    );
+  }
+  const transport = new import_streamableHttp.StreamableHTTPServerTransport({
+    sessionIdGenerator: () => {
+      const sessionId = (0, import_crypto13.randomUUID)();
+      void registerSession(
+        sessionId,
+        { credentialId: credential.credentialId, kind: credential.kind },
+        { server, transport }
+      );
+      return sessionId;
+    },
+    enableJsonResponse: true,
+    onsessionclosed: (closedId) => {
+      void Promise.resolve().then(() => (init_mcpTransportRegistry(), mcpTransportRegistry_exports)).then(
+        ({ deleteSession: deleteSession2 }) => deleteSession2(closedId)
+      );
+    }
+  });
+  await server.connect(transport);
+  return { server, transport, tools: catalog };
+}
+var import_mcp, import_streamableHttp, import_crypto13, OPEN_MCP_SERVER_INFO;
+var init_openMcpServer = __esm({
+  "src/services/open/openMcpServer.ts"() {
+    "use strict";
+    import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+    import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    import_crypto13 = require("crypto");
+    init_mcpTransportRegistry();
+    OPEN_MCP_SERVER_INFO = {
+      name: "axiom-open",
+      version: "0.1.0"
+    };
+  }
+});
+
+// src/routes/open.ts
+var open_exports = {};
+__export(open_exports, {
+  registerOpenRoutes: () => registerOpenRoutes
+});
+function extractBearer(request) {
+  const header2 = request.headers.authorization;
+  if (!header2?.startsWith("Bearer ")) return void 0;
+  return header2.slice("Bearer ".length).trim() || void 0;
+}
+function readSessionId(request) {
+  const raw = request.headers["mcp-session-id"];
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function registerOpenRoutes(app2, deps = {}) {
+  const openAuth = deps.openAuth ?? new OpenCredentialService(
+    (0, import_core68.getStoreLattice)("default", "a2aApiKey").store,
+    (0, import_core68.getStoreLattice)("default", "project").store
+  );
+  const grantsSource = deps.grantsSource ?? ((ctx) => ctx.grants);
+  const audit = deps.audit ?? (() => {
+    try {
+      const store2 = (0, import_core68.getStoreLattice)("default", "openAudit").store;
+      return new OpenAuditService(store2);
+    } catch {
+      return void 0;
+    }
+  })();
+  const rateLimiter = deps.rateLimiter ?? new OpenRateLimiter();
+  app2.post("/open/mcp", async (request, reply) => {
+    const context = await openAuth.resolve(extractBearer(request));
+    if (!context) {
+      return reply.status(401).send({ error: "AUTH_FAILED" });
+    }
+    const body = request.body;
+    const sessionId = readSessionId(request);
+    if (sessionId) {
+      const session = await getSession(sessionId);
+      if (!session || session.credential.credentialId !== context.credentialId) {
+        return reply.status(404).send({ error: "SESSION_NOT_FOUND" });
+      }
+      reply.hijack();
+      await session.transport.handleRequest(request.raw, reply.raw, body);
+      return;
+    }
+    if (!(0, import_types.isInitializeRequest)(body)) {
+      return reply.status(400).send({ error: "SESSION_REQUIRED" });
+    }
+    const grants = grantsSource(context);
+    const catalog = await openLattice.catalogFor(grants, { tenantId: context.tenantId });
+    const built = await buildSessionServer({
+      credential: { credentialId: context.credentialId, kind: context.kind },
+      grants,
+      catalog,
+      invoke: async (toolName, args) => {
+        const startedAt = Date.now();
+        const sep2 = toolName.indexOf("_");
+        const auditDomain = sep2 > 0 ? toolName.slice(0, sep2) : toolName;
+        const auditAction = sep2 > 0 ? toolName.slice(sep2 + 1) : "";
+        const decision = rateLimiter.check(context.credentialId, auditDomain);
+        if (!decision.allowed) {
+          await audit?.record({
+            tenantId: context.tenantId,
+            credentialId: context.credentialId,
+            credentialKind: context.kind,
+            projectId: context.projectId,
+            domain: auditDomain,
+            action: auditAction,
+            args,
+            status: "error",
+            errorCode: "RATE_LIMITED",
+            durationMs: Date.now() - startedAt
+          });
+          throw Object.assign(
+            new Error(
+              `RATE_LIMITED: retry after ${decision.retryAfterMs ?? 1e3}ms`
+            ),
+            { rpcCode: RPC_ERROR.RATE_LIMITED }
+          );
+        }
+        try {
+          const result = await openLattice.invoke(
+            grants,
+            {
+              tenantId: context.tenantId,
+              projectId: context.projectId,
+              workspaceId: context.workspaceId,
+              runConfig: {
+                sandboxName: context.sandboxName,
+                credentialId: context.credentialId
+              }
+            },
+            toolName,
+            args
+          );
+          await audit?.record({
+            tenantId: context.tenantId,
+            credentialId: context.credentialId,
+            credentialKind: context.kind,
+            projectId: context.projectId,
+            domain: auditDomain,
+            action: auditAction,
+            args,
+            status: "ok",
+            durationMs: Date.now() - startedAt
+          });
+          return result;
+        } catch (err) {
+          const code = err instanceof GrantDeniedError ? RPC_ERROR.GRANT_DENIED : err instanceof ActionNotFoundError ? RPC_ERROR.ACTION_NOT_FOUND : err instanceof ValidationError ? RPC_ERROR.VALIDATION_FAILED : RPC_ERROR.EXECUTION_ERROR;
+          await audit?.record({
+            tenantId: context.tenantId,
+            credentialId: context.credentialId,
+            credentialKind: context.kind,
+            projectId: context.projectId,
+            domain: auditDomain,
+            action: auditAction,
+            args,
+            status: "error",
+            errorCode: err instanceof GrantDeniedError ? "GRANT_DENIED" : err instanceof ActionNotFoundError ? "ACTION_NOT_FOUND" : err instanceof ValidationError ? "VALIDATION_FAILED" : "EXECUTION_ERROR",
+            durationMs: Date.now() - startedAt
+          });
+          throw Object.assign(
+            new Error(err instanceof Error ? err.message : String(err)),
+            { rpcCode: code }
+          );
+        }
+      }
+    });
+    reply.hijack();
+    await built.transport.handleRequest(request.raw, reply.raw, body);
+  });
+  app2.delete(
+    "/open/mcp",
+    async (request, reply) => {
+      const sessionId = readSessionId(request);
+      if (!sessionId) {
+        return reply.status(400).send({ error: "SESSION_REQUIRED" });
+      }
+      await deleteSession(sessionId);
+      return reply.status(204).send();
+    }
+  );
+}
+var import_types, import_core68, RPC_ERROR;
+var init_open = __esm({
+  "src/routes/open.ts"() {
+    "use strict";
+    import_types = require("@modelcontextprotocol/sdk/types.js");
+    import_core68 = require("@axiom-lattice/core");
+    init_openCredentialService();
+    init_openAuditService();
+    init_openRateLimiter();
+    init_openLattice();
+    init_openMcpServer();
+    init_mcpTransportRegistry();
+    RPC_ERROR = {
+      GRANT_DENIED: -32001,
+      ACTION_NOT_FOUND: -32002,
+      VALIDATION_FAILED: -32003,
+      EXECUTION_ERROR: -32004,
+      RATE_LIMITED: -32005
+    };
+  }
+});
+
+// src/routes/open-session.ts
+var open_session_exports = {};
+__export(open_session_exports, {
+  registerOpenSessionRoutes: () => registerOpenSessionRoutes
+});
+function registerOpenSessionRoutes(app2) {
+  app2.post(
+    "/open/session",
+    async (request, reply) => {
+      const body = request.body ?? {};
+      const shareToken = body.shareToken;
+      if (typeof shareToken !== "string" || shareToken.length === 0) {
+        return reply.status(400).send({ error: "SHARE_TOKEN_REQUIRED" });
+      }
+      const store2 = (0, import_core69.getStoreLattice)("default", "sharedResource").store;
+      const record = await store2.findByToken(shareToken);
+      if (!record || record.revoked) {
+        return reply.status(404).send({ error: "SHARE_NOT_FOUND" });
+      }
+      if (record.expiresAt && new Date(record.expiresAt) < /* @__PURE__ */ new Date()) {
+        return reply.status(410).send({ error: "SHARE_EXPIRED" });
+      }
+      const grants = BROWSER_GRANTS;
+      const browserToken = signOpenToken({
+        kind: "browser_token",
+        tenantId: record.tenantId,
+        projectId: record.projectId,
+        shareId: record.token,
+        grants
+      });
+      const actions = await openLattice.catalogFor(grants, { tenantId: record.tenantId });
+      return reply.status(200).send({
+        browserToken,
+        expiresAt: Date.now() + 15 * 60 * 1e3,
+        actions: actions.map((a) => a.toolName)
+      });
+    }
+  );
+}
+var import_core69;
+var init_open_session = __esm({
+  "src/routes/open-session.ts"() {
+    "use strict";
+    import_core69 = require("@axiom-lattice/core");
+    init_openToken();
+    init_previewToken();
+    init_openLattice();
+  }
+});
+
+// src/services/open/openCatalogService.ts
+var OpenCatalogService;
+var init_openCatalogService = __esm({
+  "src/services/open/openCatalogService.ts"() {
+    "use strict";
+    init_openLattice();
+    OpenCatalogService = class {
+      constructor(assistantStore, lattice = openLattice) {
+        this.assistantStore = assistantStore;
+        this.lattice = lattice;
+      }
+      async buildForTenant(tenantId) {
+        const domains = this.lattice.describeCatalog();
+        const enriched = [];
+        for (const domain of domains) {
+          if (domain.domain === "agent" && domain.itemKind === "instance") {
+            let items = [];
+            try {
+              const assistants = await this.assistantStore.getAllAssistants(tenantId);
+              items = assistants.map((a) => ({
+                id: a.id,
+                toolName: `invoke_${a.id}`,
+                label: a.name || a.id
+              }));
+            } catch {
+              items = [];
+            }
+            enriched.push({ ...domain, items });
+          } else {
+            enriched.push(domain);
+          }
+        }
+        return { domains: enriched };
+      }
+    };
+  }
+});
+
+// src/routes/open-catalog.ts
+var open_catalog_exports = {};
+__export(open_catalog_exports, {
+  registerOpenCatalogRoutes: () => registerOpenCatalogRoutes
+});
+function tenantIdOf(request) {
+  return request.user?.tenantId;
+}
+function registerOpenCatalogRoutes(app2) {
+  app2.get("/api/open/catalog", async (request, reply) => {
+    const tenantId = tenantIdOf(request);
+    if (!tenantId) {
+      return reply.status(401).send({ success: false, error: "Unauthorized" });
+    }
+    const assistantStore = (0, import_core70.getStoreLattice)("default", "assistant").store;
+    const service2 = new OpenCatalogService(assistantStore);
+    const catalog = await service2.buildForTenant(tenantId);
+    return reply.status(200).send({ success: true, data: catalog });
+  });
+}
+var import_core70;
+var init_open_catalog = __esm({
+  "src/routes/open-catalog.ts"() {
+    "use strict";
+    import_core70 = require("@axiom-lattice/core");
+    init_openCatalogService();
+  }
+});
+
+// src/services/open/providers/sandboxProvider.ts
+var sandboxProvider_exports = {};
+__export(sandboxProvider_exports, {
+  createOpenSandboxProvider: () => createOpenSandboxProvider,
+  resolveContextSandbox: () => resolveContextSandbox
+});
+async function resolveContextSandbox(ctx) {
+  return import_core71.sandboxLatticeManager.getSandboxFromConfig({
+    assistant_id: "",
+    thread_id: "",
+    tenantId: ctx.tenantId,
+    workspaceId: ctx.workspaceId ?? "",
+    projectId: ctx.projectId
+  });
+}
+function createOpenSandboxProvider() {
+  return {
+    domain: "sandbox",
+    label: "Sandbox",
+    source: "builtin",
+    scopeKind: "project",
+    actions: [
+      {
+        name: "files_read",
+        label: "Read files",
+        description: "Read a file from the project sandbox.",
+        schema: { path: import_zod17.z.string().min(1) },
+        annotations: { readOnlyHint: true, destructiveHint: false }
+      },
+      {
+        name: "files_list",
+        label: "List files",
+        description: "List files under a directory in the project sandbox.",
+        schema: { path: import_zod17.z.string(), recursive: import_zod17.z.boolean().optional() },
+        annotations: { readOnlyHint: true, destructiveHint: false }
+      },
+      {
+        name: "files_write",
+        label: "Write files",
+        description: "Write content to a file in the project sandbox.",
+        schema: { path: import_zod17.z.string().min(1), content: import_zod17.z.string() },
+        annotations: { readOnlyHint: false, destructiveHint: true }
+      },
+      {
+        name: "shell_exec",
+        label: "Run shell commands",
+        description: "Execute a shell command in the project sandbox. Returns stdout (up to 64KB) and exit code.",
+        schema: {
+          command: import_zod17.z.string().min(1),
+          exec_dir: import_zod17.z.string().optional(),
+          timeout: import_zod17.z.number().int().min(1e3).optional()
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true }
+      }
+    ],
+    execute: async (actionName, args, ctx) => {
+      const sandbox = await resolveContextSandbox(ctx);
+      switch (actionName) {
+        case "files_read": {
+          const { path: path7 } = args;
+          const file = await sandbox.file.readFile(path7);
+          return { content: [{ type: "text", text: file.content }] };
+        }
+        case "files_list": {
+          const { path: path7, recursive } = args;
+          const listing = await sandbox.file.listPath(path7, { recursive });
+          return {
+            content: [{ type: "text", text: JSON.stringify(listing.files) }]
+          };
+        }
+        case "files_write": {
+          const { path: path7, content } = args;
+          await sandbox.file.writeFile(path7, content);
+          return { content: [{ type: "text", text: `wrote ${path7}` }] };
+        }
+        case "shell_exec": {
+          const { command, exec_dir, timeout } = args;
+          const result = await sandbox.shell.execCommand({
+            command,
+            exec_dir,
+            timeout: timeout ?? 12e4
+          });
+          const truncated = result.output.length > MAX_OUTPUT_BYTES ? result.output.slice(0, MAX_OUTPUT_BYTES) + `
+...[truncated ${result.output.length - MAX_OUTPUT_BYTES} bytes]` : result.output;
+          return {
+            content: [
+              {
+                type: "text",
+                text: `exit_code: ${result.exit_code}
+${truncated}`
+              }
+            ]
+          };
+        }
+        default:
+          return {
+            content: [
+              { type: "text", text: `Unknown sandbox action: ${actionName}` }
+            ],
+            isError: true
+          };
+      }
+    }
+  };
+}
+var import_zod17, import_core71, MAX_OUTPUT_BYTES;
+var init_sandboxProvider = __esm({
+  "src/services/open/providers/sandboxProvider.ts"() {
+    "use strict";
+    import_zod17 = require("zod");
+    import_core71 = require("@axiom-lattice/core");
+    MAX_OUTPUT_BYTES = 64e3;
+  }
+});
+
+// src/routes/open-files.ts
+var open_files_exports = {};
+__export(open_files_exports, {
+  registerOpenFilesRoutes: () => registerOpenFilesRoutes
+});
+function extractBearer2(request) {
+  const header2 = request.headers.authorization;
+  if (!header2?.startsWith("Bearer ")) return void 0;
+  return header2.slice("Bearer ".length).trim() || void 0;
+}
+function safePath(raw) {
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  if (raw.includes("..")) return null;
+  return raw.startsWith("/") ? raw : `/${raw}`;
+}
+function registerOpenFilesRoutes(app2, deps = {}) {
+  const openAuth = deps.openAuth ?? new OpenCredentialService(
+    (0, import_core72.getStoreLattice)("default", "a2aApiKey").store,
+    (0, import_core72.getStoreLattice)("default", "project").store
+  );
+  const audit = deps.audit ?? (() => {
+    try {
+      const store2 = (0, import_core72.getStoreLattice)("default", "openAudit").store;
+      return new OpenAuditService(store2);
+    } catch {
+      return void 0;
+    }
+  })();
+  app2.addContentTypeParser(
+    "application/octet-stream",
+    { parseAs: "buffer" },
+    (_req, body, done) => done(null, body)
+  );
+  app2.get("/open/sandbox/files/download", async (request, reply) => {
+    const context = await openAuth.resolve(extractBearer2(request));
+    if (!context) return reply.status(401).send({ error: "AUTH_FAILED" });
+    const path7 = safePath(request.query.path);
+    if (!path7) return reply.status(400).send({ error: "PATH_REQUIRED" });
+    if (!openLattice.isAllowed(context.grants, "sandbox_files_read")) {
+      return reply.status(403).send({ error: "GRANT_DENIED" });
+    }
+    const startedAt = Date.now();
+    try {
+      const sandbox = await resolveContextSandbox({
+        tenantId: context.tenantId,
+        projectId: context.projectId,
+        workspaceId: context.workspaceId,
+        runConfig: {}
+      });
+      const data = await sandbox.file.downloadFile({ file: path7 });
+      await audit?.record({
+        tenantId: context.tenantId,
+        credentialId: context.credentialId,
+        credentialKind: context.kind,
+        projectId: context.projectId,
+        domain: "sandbox",
+        action: "files_read",
+        args: { path: path7 },
+        status: "ok",
+        durationMs: Date.now() - startedAt
+      });
+      return reply.status(200).type("application/octet-stream").header("Content-Disposition", "attachment").send(data);
+    } catch (err) {
+      await audit?.record({
+        tenantId: context.tenantId,
+        credentialId: context.credentialId,
+        credentialKind: context.kind,
+        projectId: context.projectId,
+        domain: "sandbox",
+        action: "files_read",
+        args: { path: path7 },
+        status: "error",
+        errorCode: "EXECUTION_ERROR",
+        durationMs: Date.now() - startedAt
+      });
+      return reply.status(502).send({
+        error: err instanceof Error ? err.message : "SANDBOX_ERROR"
+      });
+    }
+  });
+  app2.post("/open/sandbox/files/upload", async (request, reply) => {
+    const context = await openAuth.resolve(extractBearer2(request));
+    if (!context) return reply.status(401).send({ error: "AUTH_FAILED" });
+    const path7 = safePath(request.query.path);
+    if (!path7) return reply.status(400).send({ error: "PATH_REQUIRED" });
+    if (!openLattice.isAllowed(context.grants, "sandbox_files_write")) {
+      return reply.status(403).send({ error: "GRANT_DENIED" });
+    }
+    const body = request.body;
+    if (!Buffer.isBuffer(body)) {
+      return reply.status(400).send({ error: "BINARY_BODY_REQUIRED" });
+    }
+    const startedAt = Date.now();
+    try {
+      const sandbox = await resolveContextSandbox({
+        tenantId: context.tenantId,
+        projectId: context.projectId,
+        workspaceId: context.workspaceId,
+        runConfig: {}
+      });
+      await sandbox.file.uploadFile({ file: path7, data: body });
+      await audit?.record({
+        tenantId: context.tenantId,
+        credentialId: context.credentialId,
+        credentialKind: context.kind,
+        projectId: context.projectId,
+        domain: "sandbox",
+        action: "files_write",
+        args: { path: path7, bytes: body.length },
+        status: "ok",
+        durationMs: Date.now() - startedAt
+      });
+      return reply.status(200).send({ success: true, path: path7 });
+    } catch (err) {
+      await audit?.record({
+        tenantId: context.tenantId,
+        credentialId: context.credentialId,
+        credentialKind: context.kind,
+        projectId: context.projectId,
+        domain: "sandbox",
+        action: "files_write",
+        args: { path: path7, bytes: body.length },
+        status: "error",
+        errorCode: "EXECUTION_ERROR",
+        durationMs: Date.now() - startedAt
+      });
+      return reply.status(502).send({
+        error: err instanceof Error ? err.message : "SANDBOX_ERROR"
+      });
+    }
+  });
+}
+var import_core72;
+var init_open_files = __esm({
+  "src/routes/open-files.ts"() {
+    "use strict";
+    import_core72 = require("@axiom-lattice/core");
+    init_openCredentialService();
+    init_openLattice();
+    init_sandboxProvider();
+    init_openAuditService();
+  }
+});
+
+// src/routes/open-audit.ts
+var open_audit_exports = {};
+__export(open_audit_exports, {
+  registerOpenAuditRoutes: () => registerOpenAuditRoutes
+});
+function registerOpenAuditRoutes(app2) {
+  app2.get(
+    "/api/open/audit",
+    async (request, reply) => {
+      const tenantId = request.user?.tenantId;
+      if (!tenantId) {
+        return reply.status(401).send({ success: false, error: "Unauthorized" });
+      }
+      const status = request.query.status === "ok" || request.query.status === "error" ? request.query.status : void 0;
+      const store2 = (0, import_core73.getStoreLattice)("default", "openAudit").store;
+      const records = await store2.query({
+        tenantId,
+        credentialId: request.query.credentialId,
+        domain: request.query.domain,
+        status,
+        from: request.query.from,
+        to: request.query.to,
+        limit: request.query.limit ? parseInt(request.query.limit, 10) : void 0,
+        offset: request.query.offset ? parseInt(request.query.offset, 10) : void 0
+      });
+      return reply.status(200).send({ success: true, data: { records } });
+    }
+  );
+}
+var import_core73;
+var init_open_audit = __esm({
+  "src/routes/open-audit.ts"() {
+    "use strict";
+    import_core73 = require("@axiom-lattice/core");
+  }
+});
+
+// src/routes/open-exposure.ts
+var open_exposure_exports = {};
+__export(open_exposure_exports, {
+  registerOpenExposureRoutes: () => registerOpenExposureRoutes
+});
+function registerOpenExposureRoutes(app2) {
+  app2.get(
+    "/api/keys/:id/exposure",
+    async (request, reply) => {
+      const tenantId = request.user?.tenantId;
+      if (!tenantId) {
+        return reply.status(401).send({ success: false, error: "Unauthorized" });
+      }
+      const keyStore = (0, import_core74.getStoreLattice)("default", "a2aApiKey").store;
+      const record = await keyStore.findById(request.params.id);
+      if (!record || record.tenantId !== tenantId) {
+        return reply.status(404).send({ success: false, error: "Key not found" });
+      }
+      const grants = (0, import_protocols33.effectiveGrants)(record);
+      const forwardedHost = request.headers["x-forwarded-host"];
+      const host = (Array.isArray(forwardedHost) ? forwardedHost[0] : forwardedHost) ?? (Array.isArray(request.headers.host) ? request.headers.host[0] : request.headers.host) ?? request.hostname;
+      const baseUrl = `${request.protocol}://${host}`;
+      const tools = (await openLattice.catalogFor(grants, { tenantId })).map((t2) => ({
+        domain: t2.domain,
+        toolName: t2.toolName,
+        description: t2.description,
+        annotations: t2.annotations
+      }));
+      const agentGrant = grants.find((g) => g.domain === "agent");
+      const assistantStore = (0, import_core74.getStoreLattice)("default", "assistant").store;
+      const agents = [];
+      for (const assistantId of agentGrant?.items ?? []) {
+        const assistant = await assistantStore.getAssistantById(
+          tenantId,
+          assistantId
+        );
+        if (!assistant) continue;
+        agents.push({
+          assistantId,
+          cardUrl: `${baseUrl}/api/a2a/agents/${assistantId}/.well-known/agent-card.json`,
+          jsonrpcUrl: `${baseUrl}/api/a2a/agents/${assistantId}/jsonrpc`,
+          card: buildAgentCardForAssistant({ assistant, baseUrl })
+        });
+      }
+      return reply.status(200).send({
+        success: true,
+        data: {
+          tenantId,
+          projectId: record.projectId,
+          grants,
+          mcp: { endpoint: `${baseUrl}/open/mcp`, tools },
+          a2a: { agents }
+        }
+      });
+    }
+  );
+}
+var import_core74, import_protocols33;
+var init_open_exposure = __esm({
+  "src/routes/open-exposure.ts"() {
+    "use strict";
+    import_core74 = require("@axiom-lattice/core");
+    import_protocols33 = require("@axiom-lattice/protocols");
+    init_openLattice();
+    init_A2AAgentCardBuilder();
+  }
+});
+
+// src/services/open/providers/kbProvider.ts
+var kbProvider_exports = {};
+__export(kbProvider_exports, {
+  createKbProvider: () => createKbProvider
+});
+function createKbProvider(collectionService3) {
+  return {
+    domain: "kb",
+    label: "Knowledge Base",
+    source: "builtin",
+    scopeKind: "tenant",
+    actions: [
+      {
+        name: "search",
+        label: "Search collections",
+        description: "Search a knowledge base collection. Returns matched entries with content, metadata and similarity score.",
+        schema: {
+          collection: import_zod18.z.string().min(1),
+          query: import_zod18.z.string().min(1),
+          limit: import_zod18.z.number().int().min(1).max(50).optional()
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false }
+      }
+    ],
+    execute: async (action, args, ctx) => {
+      if (action !== "search") {
+        return {
+          content: [{ type: "text", text: `Unknown kb action: ${action}` }],
+          isError: true
+        };
+      }
+      const { collection, query, limit } = args;
+      const req = {
+        user: { tenantId: ctx.tenantId },
+        headers: {}
+      };
+      const entries = await collectionService3.searchEntries(
+        req,
+        collection,
+        { query, top_k: limit ?? 5 }
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(entries, null, 2) }]
+      };
+    }
+  };
+}
+var import_zod18;
+var init_kbProvider = __esm({
+  "src/services/open/providers/kbProvider.ts"() {
+    "use strict";
+    import_zod18 = require("zod");
+  }
+});
+
+// src/services/open/providers/agentProvider.ts
+var agentProvider_exports = {};
+__export(agentProvider_exports, {
+  createAgentProvider: () => createAgentProvider
+});
+function createAgentProvider(deps = {}) {
+  return {
+    domain: "agent",
+    label: "Agents",
+    source: "agent",
+    scopeKind: "project",
+    itemKind: "instance",
+    actions: [],
+    instanceActions: async (grants, ctx) => {
+      const agentGrant = grants.find((g) => g.domain === "agent");
+      const assistantIds = agentGrant?.items ?? [];
+      const tenantId = ctx?.tenantId;
+      return Promise.all(
+        assistantIds.map(async (assistantId) => {
+          let name = assistantId;
+          let description = "";
+          if (tenantId && deps.resolveAssistant) {
+            try {
+              const meta = await deps.resolveAssistant(tenantId, assistantId);
+              if (meta?.name) name = meta.name;
+              if (meta?.description) description = meta.description;
+            } catch {
+            }
+          }
+          return {
+            name: assistantId,
+            toolName: `invoke_${assistantId}`,
+            label: name,
+            description: `Invoke the "${name}" agent${description ? ` \u2014 ${description}` : ""}. Returns its final reply.`,
+            schema: { message: import_zod19.z.string().min(1) },
+            annotations: { readOnlyHint: false, destructiveHint: false }
+          };
+        })
+      );
+    },
+    execute: async (assistantId, args, ctx) => {
+      const { message } = args;
+      const credentialId = ctx.runConfig.credentialId ?? ctx.projectId;
+      const threadId = `open:${credentialId}:${assistantId}`;
+      if (deps.threadStore) {
+        try {
+          await deps.threadStore.createThread(ctx.tenantId, assistantId, threadId, {
+            metadata: {
+              source: "open_api",
+              credentialId,
+              workspaceId: ctx.workspaceId ?? void 0,
+              projectId: ctx.projectId
+            }
+          });
+        } catch {
+        }
+      }
+      const agent = import_core75.agentInstanceManager.getAgent({
+        tenant_id: ctx.tenantId,
+        assistant_id: assistantId,
+        thread_id: threadId,
+        workspace_id: ctx.workspaceId ?? "",
+        project_id: ctx.projectId
+      });
+      const { messageId } = await agent.addMessage({
+        input: { message }
+      });
+      const parts = [];
+      const stream = agent.chunkStream(messageId, [...STOP_TYPES]);
+      for await (const chunk of stream) {
+        const text = chunk.data?.content;
+        if (chunk.type === import_protocols34.MessageChunkTypes.INTERRUPT) break;
+        if (chunk.type === import_protocols34.MessageChunkTypes.AI && text) {
+          parts.push(text);
+        }
+      }
+      return {
+        content: [{ type: "text", text: parts.join("") || "(no output)" }]
+      };
+    }
+  };
+}
+var import_zod19, import_core75, import_protocols34, STOP_TYPES;
+var init_agentProvider = __esm({
+  "src/services/open/providers/agentProvider.ts"() {
     "use strict";
-    sessions = /* @__PURE__ */ new Map();
+    import_zod19 = require("zod");
+    import_core75 = require("@axiom-lattice/core");
+    import_protocols34 = require("@axiom-lattice/protocols");
+    STOP_TYPES = [import_protocols34.MessageChunkTypes.MESSAGE_COMPLETED];
   }
 });
 
-// src/services/open/mcpCatalog.ts
-function textResult(text) {
-  return [{ type: "text", text }];
-}
-function filterCatalogByGrants(credential) {
-  const domains = new Set(credential.grants.map((g) => g.domain));
-  return SPIKE_TOOL_CATALOG.filter((tool) => domains.has(tool.domain));
+// src/services/open/pluginExposeAdapter.ts
+function schemaOf(tool) {
+  return tool.lc_kwargs?.schema ?? tool.schema ?? import_zod20.z.object({}).passthrough();
 }
-var import_zod16, SPIKE_TOOL_CATALOG;
-var init_mcpCatalog = __esm({
-  "src/services/open/mcpCatalog.ts"() {
-    "use strict";
-    import_zod16 = require("zod");
-    SPIKE_TOOL_CATALOG = [
-      {
-        toolName: "kb_search",
-        domain: "kb",
-        description: "Spike: pretend knowledge-base search.",
-        schema: {
-          query: import_zod16.z.string(),
-          limit: import_zod16.z.number().int().optional()
-        },
-        annotations: { readOnlyHint: true, destructiveHint: false },
-        execute: async (args) => {
-          const { query } = args;
-          return textResult(`kb_search spike result for: ${query}`);
-        }
-      },
-      {
-        toolName: "echo",
-        domain: "sandbox",
-        description: "Spike: echoes the message back.",
-        schema: { message: import_zod16.z.string() },
-        annotations: { readOnlyHint: true, destructiveHint: false },
-        execute: async (args) => {
-          const { message } = args;
-          return textResult(`echo: ${message}`);
-        }
+function createPluginProvider(domain, tools, options = {}) {
+  function toAction(info) {
+    return {
+      name: info.name,
+      description: info.description || info.tool.description || `Plugin tool ${info.name}`,
+      schema: schemaOf(info.tool),
+      annotations: {
+        readOnlyHint: info.readOnly ?? false,
+        destructiveHint: info.destructive ?? false
       }
-    ];
+    };
   }
-});
-
-// src/services/open/openMcpServer.ts
-function registerTools(server, tools) {
-  for (const tool of tools) {
-    server.registerTool(
-      tool.toolName,
-      {
-        description: tool.description,
-        inputSchema: tool.schema,
-        annotations: {
-          readOnlyHint: tool.annotations.readOnlyHint,
-          destructiveHint: tool.annotations.destructiveHint
+  const actions = tools.map(toAction);
+  return {
+    domain,
+    label: options.label ?? domain,
+    source: "plugin",
+    scopeKind: "tenant",
+    actions,
+    execute: async (action, args, ctx) => {
+      const info = tools.find((t2) => t2.name === action);
+      if (!info) {
+        return {
+          content: [{ type: "text", text: `Unknown action: ${action}` }],
+          isError: true
+        };
+      }
+      const exeConfig = {
+        configurable: {
+          runConfig: {
+            tenantId: ctx.tenantId,
+            _resolvedConnections: ctx.runConfig._resolvedConnections ?? []
+          }
         }
-      },
-      async (args) => ({ content: await tool.execute(args) })
-    );
-  }
-}
-async function buildSessionServer(credential) {
-  const tools = filterCatalogByGrants(credential);
-  const server = new import_mcp.McpServer(OPEN_MCP_SERVER_INFO);
-  registerTools(server, tools);
-  const transport = new import_streamableHttp.StreamableHTTPServerTransport({
-    sessionIdGenerator: () => {
-      const sessionId = (0, import_crypto12.randomUUID)();
-      void registerSession(
-        sessionId,
-        { credentialId: credential.credentialId, kind: credential.kind },
-        { server, transport }
-      );
-      return sessionId;
-    },
-    enableJsonResponse: true,
-    onsessionclosed: (closedId) => {
-      void Promise.resolve().then(() => (init_mcpTransportRegistry(), mcpTransportRegistry_exports)).then(
-        ({ deleteSession: deleteSession2 }) => deleteSession2(closedId)
-      );
+      };
+      const output = await info.tool.invoke(args, exeConfig);
+      return { content: [{ type: "text", text: output }] };
     }
-  });
-  await server.connect(transport);
-  return { server, transport, tools };
+  };
 }
-var import_mcp, import_streamableHttp, import_crypto12, OPEN_MCP_SERVER_INFO;
-var init_openMcpServer = __esm({
-  "src/services/open/openMcpServer.ts"() {
+var import_zod20;
+var init_pluginExposeAdapter = __esm({
+  "src/services/open/pluginExposeAdapter.ts"() {
     "use strict";
-    import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-    import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-    import_crypto12 = require("crypto");
-    init_mcpTransportRegistry();
-    init_mcpCatalog();
-    OPEN_MCP_SERVER_INFO = {
-      name: "axiom-open",
-      version: "0.1.0"
-    };
+    import_zod20 = require("zod");
   }
 });
 
-// src/routes/open.ts
-var open_exports = {};
-__export(open_exports, {
-  registerOpenRoutes: () => registerOpenRoutes
+// src/services/open/registerExposedPlugins.ts
+var registerExposedPlugins_exports = {};
+__export(registerExposedPlugins_exports, {
+  registerExposedPluginTools: () => registerExposedPluginTools
 });
-function extractBearer(request) {
-  const header2 = request.headers.authorization;
-  if (!header2?.startsWith("Bearer ")) return void 0;
-  return header2.slice("Bearer ".length).trim() || void 0;
-}
-function readSessionId(request) {
-  const raw = request.headers["mcp-session-id"];
-  const value = Array.isArray(raw) ? raw[0] : raw;
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function registerOpenRoutes(app2) {
-  app2.post("/open/mcp", async (request, reply) => {
-    const credential = resolveSpikeCredential(extractBearer(request));
-    if (!credential) {
-      return reply.status(401).send({ error: "AUTH_FAILED" });
-    }
-    const body = request.body;
-    const sessionId = readSessionId(request);
-    if (sessionId) {
-      const session = await getSession(sessionId);
-      if (!session || session.credential.credentialId !== credential.credentialId) {
-        return reply.status(404).send({ error: "SESSION_NOT_FOUND" });
-      }
-      reply.hijack();
-      await session.transport.handleRequest(request.raw, reply.raw, body);
-      return;
-    }
-    if (!(0, import_types.isInitializeRequest)(body)) {
-      return reply.status(400).send({ error: "SESSION_REQUIRED" });
-    }
-    const built = await buildSessionServer(credential);
-    reply.hijack();
-    await built.transport.handleRequest(request.raw, reply.raw, body);
-  });
-  app2.delete(
-    "/open/mcp",
-    async (request, reply) => {
-      const sessionId = readSessionId(request);
-      if (!sessionId) {
-        return reply.status(400).send({ error: "SESSION_REQUIRED" });
+async function registerExposedPluginTools() {
+  for (const key of import_core76.PluginRegistry.list()) {
+    const plugin = import_core76.PluginRegistry.get(key);
+    if (!plugin?.middleware) continue;
+    const openExpose = plugin.meta.openExpose;
+    const exposed = openExpose ? openExpose.map(
+      (entry) => typeof entry === "string" ? { name: entry, description: "", expose: true } : {
+        name: entry.name,
+        description: "",
+        expose: true,
+        readOnly: entry.readOnly,
+        destructive: entry.destructive
       }
-      await deleteSession(sessionId);
-      return reply.status(204).send();
+    ) : plugin.meta.tools?.filter((t2) => t2.expose) ?? [];
+    if (exposed.length === 0) continue;
+    try {
+      const middleware = await plugin.middleware({
+        ...plugin.meta.defaultConfig ?? {},
+        connectAll: true
+      });
+      const toolObjects = middleware.tools ?? [];
+      const matched = exposed.map((tm) => {
+        const tool = toolObjects.find((t2) => t2.name === tm.name);
+        if (!tool) return null;
+        const annotations = tm;
+        return {
+          name: tm.name,
+          description: tm.description,
+          tool,
+          readOnly: annotations.readOnly,
+          destructive: annotations.destructive
+        };
+      }).filter(Boolean);
+      if (matched.length === 0) continue;
+      const provider = createPluginProvider(key, matched, { label: plugin.meta.name });
+      openLattice.register(provider);
+    } catch {
     }
-  );
+  }
 }
-var import_types;
-var init_open = __esm({
-  "src/routes/open.ts"() {
+var import_core76;
+var init_registerExposedPlugins = __esm({
+  "src/services/open/registerExposedPlugins.ts"() {
     "use strict";
-    import_types = require("@modelcontextprotocol/sdk/types.js");
-    init_openCredentials();
-    init_openMcpServer();
-    init_mcpTransportRegistry();
+    import_core76 = require("@axiom-lattice/core");
+    init_openLattice();
+    init_pluginExposeAdapter();
+  }
+});
+
+// src/services/open/sandboxGrants.ts
+function sanitizeShareOpenGrants(grants) {
+  const out = [];
+  for (const grant of grants ?? []) {
+    const allowed = ALLOWED[grant.domain];
+    if (!allowed) continue;
+    const items = grant.items && grant.items.length > 0 ? grant.items.filter((item) => allowed.includes(item)) : allowed;
+    if (items.length > 0) out.push({ domain: grant.domain, items });
+  }
+  return out;
+}
+var ALLOWED;
+var init_sandboxGrants = __esm({
+  "src/services/open/sandboxGrants.ts"() {
+    "use strict";
+    ALLOWED = {
+      kb: ["search", "entries_read"]
+    };
   }
 });
 
@@ -3172,13 +4616,14 @@ var resources_exports = {};
 __export(resources_exports, {
   ResourceController: () => ResourceController
 });
-var import_bcryptjs, import_core68, ResourceController;
+var import_bcryptjs, import_core77, ResourceController;
 var init_resources = __esm({
   "src/controllers/resources.ts"() {
     "use strict";
     import_bcryptjs = __toESM(require("bcryptjs"));
-    import_core68 = require("@axiom-lattice/core");
+    import_core77 = require("@axiom-lattice/core");
     init_mime();
+    init_sandboxGrants();
     ResourceController = class {
       constructor(deps) {
         this.deps = deps;
@@ -3192,14 +4637,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_core68.createSharePayload)(
+        const payload = (0, import_core77.createSharePayload)(
           tenantId,
           workspaceId,
           projectId,
           userId,
           body
         );
-        const token = (0, import_core68.generateToken)();
+        const token = (0, import_core77.generateToken)();
         try {
           await this.deps.store.create({ ...payload, token });
           this.deps.logger.info(
@@ -3351,7 +4796,7 @@ var init_resources = __esm({
             resourcePath: subPath
           }, subPath, ext, request, reply);
         }
-        const volume = (0, import_core68.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
+        const volume = (0, import_core77.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
         return this._resolveAndServe(
           volume,
           subPath,
@@ -3463,7 +4908,8 @@ var init_resources = __esm({
           workspaceId: record.workspaceId,
           projectId: record.projectId,
           assistantId: record.assistantId,
-          resourcePath: basePath + apiSubPath
+          resourcePath: basePath + apiSubPath,
+          openGrants: record.openGrants
         }, apiSubPath, ext, request, reply);
       }
       async _execApiCore(config, apiSubPath, ext, request, reply) {
@@ -3494,9 +4940,10 @@ var init_resources = __esm({
           `export API_QUERY='${JSON.stringify(queryObj).replace(/'/g, "'\\''")}'`,
           `export API_BODY='${bodyStr.replace(/'/g, "'\\''")}'`,
           `export API_METHOD='${request.method}'`,
-          `export API_GATEWAY_URL='${request.protocol}://${request.hostname}'`,
+          `export API_GATEWAY_URL='${request.protocol}://${request.headers["x-forwarded-host"] ?? request.headers.host ?? request.hostname}'`,
           `export API_TENANT_ID='${config.tenantId}'`,
-          `export API_ASSISTANT_ID='${config.assistantId || ""}'`
+          `export API_ASSISTANT_ID='${config.assistantId || ""}'`,
+          `export OPEN_API_TOKEN='${this._mintSandboxToken(sandbox.name, config)}'`
         ].join(" && ");
         const fullCmd = `${envVars} && ${cmd}`;
         this.deps.logger.info("[api] exec", { scriptPath, cmd: cmd.substring(0, 80) });
@@ -3524,6 +4971,23 @@ var init_resources = __esm({
       _passwordPage(token) {
         return `<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Password Protected</title><style>body{font-family:-apple-system,BlinkMacSystemFont,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0;background:#f5f5f5}.card{background:#fff;padding:32px;border-radius:12px;box-shadow:0 2px 8px rgba(0,0,0,.1);width:100%;max-width:360px;text-align:center}h2{margin:0 0 8px;font-size:20px}p{margin:0 0 20px;color:#666;font-size:14px}input{width:100%;padding:10px 12px;border:1px solid #d9d9d9;border-radius:8px;font-size:14px;box-sizing:border-box;margin-bottom:12px}button{width:100%;padding:10px;background:#6366f1;color:#fff;border:none;border-radius:8px;font-size:14px;cursor:pointer}.error{color:#ef4444;font-size:13px;margin-top:8px;display:none}</style></head><body><div class="card"><h2>Password Protected</h2><p>This share requires a password to access.</p><form id="f"><input type="password" id="p" placeholder="Enter password" required><button type="submit">Unlock</button><div class="error" id="e">Incorrect password</div></form></div><script>document.getElementById('f').onsubmit=async(e)=>{e.preventDefault();const r=await fetch('/s/${token}/unlock',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({password:document.getElementById('p').value})});if(r.ok)location.reload();else document.getElementById('e').style.display='block'}</script></body></html>`;
       }
+      _mintSandboxToken(sandboxName, config) {
+        const { signOpenToken: signOpenToken2 } = (init_openToken(), __toCommonJS(openToken_exports));
+        return signOpenToken2({
+          kind: "sandbox_token",
+          tenantId: config.tenantId,
+          workspaceId: config.workspaceId,
+          projectId: config.projectId,
+          sandboxName,
+          grants: [
+            {
+              domain: "sandbox",
+              items: ["files_read", "files_list", "files_write", "shell_exec"]
+            },
+            ...sanitizeShareOpenGrants(config.openGrants)
+          ]
+        });
+      }
     };
   }
 });
@@ -5560,6 +7024,36 @@ var SkillService = class {
   constructor() {
     this.store = new import_core10.SandboxSkillStore();
   }
+  /**
+   * Read the read-only skills contributed by the tenant's sandbox plugins.
+   * Sandbox failures degrade silently so the system view still returns
+   * built-in and store skills.
+   */
+  async tenantPluginSkills(tenantId) {
+    const items = [];
+    try {
+      const loaded = await (0, import_core10.getSandboxPluginCatalog)().ensureLoaded(tenantId);
+      for (const plugin of loaded.plugins) {
+        for (const [name, definition] of Object.entries(plugin.skills ?? {})) {
+          const { meta } = (0, import_core10.parseSkillFrontmatter)(definition.content);
+          items.push({
+            id: name,
+            name: meta.name || name,
+            description: meta.description || "",
+            version: definition.version,
+            pluginType: plugin.meta.type,
+            resourcePaths: Object.entries(definition.resources ?? {}).map(([path7, resource]) => ({
+              path: path7,
+              mimeType: resource.mimeType
+            })),
+            content: definition.content
+          });
+        }
+      }
+    } catch {
+    }
+    return items;
+  }
   async getAllSkills(request) {
     const tenantId = getTenantId4(request);
     const storeSkills = await this.store.getAllSkills(tenantId, buildContext(request));
@@ -5570,6 +7064,9 @@ var SkillService = class {
     for (const item of import_core10.PluginRegistry.listSkills()) {
       merged.set(item.id, pluginSkillToSkill(item, tenantId));
     }
+    for (const item of await this.tenantPluginSkills(tenantId)) {
+      merged.set(item.id, pluginSkillToSkill(item, tenantId, item.content));
+    }
     return Array.from(merged.values());
   }
   async getSkillById(request, id3) {
@@ -5582,21 +7079,23 @@ var SkillService = class {
         return pluginSkillToSkill(item, tenantId, definition.content);
       }
     }
+    const tenantItem = (await this.tenantPluginSkills(tenantId)).find((entry) => entry.id === id3);
+    if (tenantItem) return pluginSkillToSkill(tenantItem, tenantId, tenantItem.content);
     return this.store.getSkillById(tenantId, id3, buildContext(request));
   }
   async createSkill(request, id3, data) {
     const tenantId = getTenantId4(request);
-    this.assertNotPluginSkill(id3, "created");
+    await this.assertMutable(tenantId, id3, "created");
     return this.store.createSkill(tenantId, id3, data, buildContext(request));
   }
   async updateSkill(request, id3, updates) {
     const tenantId = getTenantId4(request);
-    this.assertNotPluginSkill(id3, "modified");
+    await this.assertMutable(tenantId, id3, "modified");
     return this.store.updateSkill(tenantId, id3, updates, buildContext(request));
   }
   async deleteSkill(request, id3) {
     const tenantId = getTenantId4(request);
-    this.assertNotPluginSkill(id3, "deleted");
+    await this.assertMutable(tenantId, id3, "deleted");
     return this.store.deleteSkill(tenantId, id3, buildContext(request));
   }
   async searchByMetadata(request, key, value) {
@@ -5612,7 +7111,18 @@ var SkillService = class {
     return this.store.filterByLicense(tenantId, license, buildContext(request));
   }
   /**
-   * Guard against mutating a registered plugin skill.
+   * Guard against mutating a built-in or tenant-plugin skill.
+   * Message style mirrors SandboxSkillStore built-in errors so the controller's
+   * existing "built-in skill" -> 403 mapping applies. Runs before any store write.
+   */
+  async assertMutable(tenantId, id3, action) {
+    this.assertNotPluginSkill(id3, action);
+    if ((await this.tenantPluginSkills(tenantId)).some((skill) => skill.id === id3)) {
+      throw new Error(`Skill "${id3}" is a built-in skill and cannot be ${action}`);
+    }
+  }
+  /**
+   * Guard against mutating a globally registered plugin skill.
    * Message style mirrors SandboxSkillStore built-in errors so the controller's
    * existing "built-in skill" -> 403 mapping applies.
    */
@@ -5818,169 +7328,8 @@ async function filterSkillsByLicense(request, reply) {
   }
 }
 
-// src/services/collection_service.ts
-var import_uuid2 = require("uuid");
-var import_documents = require("@langchain/core/documents");
-var import_core11 = require("@axiom-lattice/core");
-function getTenantId5(request) {
-  return request.user?.tenantId || request.headers["x-tenant-id"] || "default";
-}
-var CollectionService = class {
-  // ─── Collection CRUD ──────────────────────────────────────────
-  async getAllCollections(request) {
-    const tenantId = getTenantId5(request);
-    const collections = await import_core11.collectionLatticeManager.getAllCollections(tenantId);
-    for (const c2 of collections) {
-      try {
-        c2._entryCount = await (0, import_core11.getCollectionEntryCount)(c2.name, c2.embeddingKey, c2.tenantId);
-      } catch {
-        c2._entryCount = 0;
-      }
-    }
-    return collections;
-  }
-  async getCollectionByName(request, name) {
-    const tenantId = getTenantId5(request);
-    return import_core11.collectionLatticeManager.getCollection(tenantId, name);
-  }
-  async createCollection(request, data) {
-    const tenantId = getTenantId5(request);
-    const collection = await import_core11.collectionLatticeManager.registerCollection(tenantId, data);
-    try {
-      await (0, import_core11.getOrCreateCollectionVectorStore)(data.name, data.embeddingKey, tenantId);
-    } catch (err) {
-      console.warn(`[CollectionService] Failed to init vector store for ${data.name}:`, err);
-    }
-    return collection;
-  }
-  async updateCollection(request, name, updates) {
-    const tenantId = getTenantId5(request);
-    return import_core11.collectionLatticeManager.updateCollection(tenantId, name, updates);
-  }
-  async deleteCollection(request, name) {
-    const tenantId = getTenantId5(request);
-    await (0, import_core11.removeCollectionVectorStore)(name, tenantId);
-    return import_core11.collectionLatticeManager.removeCollection(tenantId, name);
-  }
-  // ─── Entry CRUD ───────────────────────────────────────────────
-  async getEntries(request, collectionName) {
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-    const docs = await (0, import_core11.listCollectionEntries)(collectionName, collection.embeddingKey, collection.tenantId);
-    return docs.map((doc) => ({
-      id: doc.metadata._id || "",
-      content: doc.pageContent,
-      metadata: Object.fromEntries(
-        Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
-      )
-    }));
-  }
-  async createEntry(request, collectionName, data) {
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-    const vectorStore = await (0, import_core11.getOrCreateCollectionVectorStore)(
-      collectionName,
-      collection.embeddingKey,
-      collection.tenantId
-    );
-    const entryId = (0, import_uuid2.v4)();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const doc = new import_documents.Document({
-      pageContent: data.content,
-      metadata: {
-        _id: entryId,
-        _created_at: now,
-        _updated_at: now,
-        ...data.metadata || {}
-      }
-    });
-    await vectorStore.addDocuments([doc]);
-    return { id: entryId, content: data.content, metadata: data.metadata || {} };
-  }
-  async getEntry(request, collectionName, entryId) {
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-    const docs = await (0, import_core11.listCollectionEntries)(collectionName, collection.embeddingKey, collection.tenantId);
-    const doc = docs.find((d) => d.metadata._id === entryId);
-    if (!doc) return null;
-    return {
-      id: entryId,
-      content: doc.pageContent,
-      metadata: Object.fromEntries(
-        Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
-      )
-    };
-  }
-  async updateEntry(request, collectionName, entryId, data) {
-    const existing = await this.getEntry(request, collectionName, entryId);
-    if (!existing) return null;
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-    const vectorStore = await (0, import_core11.getOrCreateCollectionVectorStore)(
-      collectionName,
-      collection.embeddingKey,
-      collection.tenantId
-    );
-    try {
-      await vectorStore.delete({ filter: { _id: entryId } });
-    } catch {
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const mergedMetadata = { ...existing.metadata, ...data.metadata || {} };
-    const doc = new import_documents.Document({
-      pageContent: data.content ?? existing.content,
-      metadata: { _id: entryId, _created_at: now, _updated_at: now, ...mergedMetadata }
-    });
-    await vectorStore.addDocuments([doc]);
-    return { id: entryId, content: data.content ?? existing.content, metadata: mergedMetadata };
-  }
-  async deleteEntry(request, collectionName, entryId) {
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-    const vectorStore = await (0, import_core11.getOrCreateCollectionVectorStore)(
-      collectionName,
-      collection.embeddingKey,
-      collection.tenantId
-    );
-    try {
-      await vectorStore.delete({ filter: { _id: entryId } });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async searchEntries(request, collectionName, params) {
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-    const vectorStore = await (0, import_core11.getOrCreateCollectionVectorStore)(
-      collectionName,
-      collection.embeddingKey,
-      collection.tenantId
-    );
-    let embeddings;
-    try {
-      embeddings = import_core11.embeddingsLatticeManager.getEmbeddingsClient(collection.embeddingKey);
-    } catch {
-      embeddings = import_core11.embeddingsLatticeManager.getEmbeddingsClient("default");
-    }
-    const queryVector = await embeddings.embedQuery(params.query);
-    const results = await vectorStore.similaritySearchVectorWithScore(
-      queryVector,
-      params.top_k || 5,
-      params.filter
-    );
-    return results.map(([doc, score]) => ({
-      id: doc.metadata._id || (0, import_uuid2.v4)(),
-      content: doc.pageContent,
-      metadata: Object.fromEntries(
-        Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
-      ),
-      score
-    }));
-  }
-};
-
 // src/controllers/collections.ts
+init_collection_service();
 var collectionService = new CollectionService();
 function serializeCollection(collection) {
   return {
@@ -6120,6 +7469,7 @@ async function listEmbeddings(_request, _reply) {
 }
 
 // src/controllers/entries.ts
+init_collection_service();
 var collectionService2 = new CollectionService();
 async function listEntries(request, reply) {
   try {
@@ -7989,10 +9339,20 @@ async function importApply(request, reply) {
 
 // src/controllers/middleware-types.ts
 var import_core19 = require("@axiom-lattice/core");
+async function collectMiddlewareMetas(tenantId) {
+  let tenantPlugins = [];
+  try {
+    tenantPlugins = (await (0, import_core19.getSandboxPluginCatalog)().ensureLoaded(tenantId)).plugins;
+  } catch {
+    tenantPlugins = [];
+  }
+  const globalPlugins = import_core19.PluginRegistry.list().map((type) => import_core19.PluginRegistry.get(type)).filter((p) => Boolean(p));
+  return (0, import_core19.mergePluginSources)(globalPlugins, tenantPlugins).map(import_core19.serializePluginMeta);
+}
 function middlewareTypesRoutes(fastify2) {
-  fastify2.get("/api/middleware-types", async (_request, reply) => {
-    const metas = import_core19.PluginRegistry.listMeta();
-    return reply.send(metas);
+  fastify2.get("/api/middleware-types", async (request, reply) => {
+    const tenantId = request.user?.tenantId || request.headers["x-tenant-id"] || "default";
+    return reply.send(await collectMiddlewareMetas(tenantId));
   });
 }
 
@@ -8714,6 +10074,7 @@ var import_core25 = require("@axiom-lattice/core");
 var import_core26 = require("@axiom-lattice/core");
 var import_uuid3 = require("uuid");
 init_mime();
+init_previewToken();
 init_workspace_file_service();
 init_path_containment();
 
@@ -9666,7 +11027,7 @@ var WorkspaceController = class {
               workspaceId,
               projectId,
               timestamp: Date.now()
-            })};</script>`;
+            })};</script>` + buildPreviewTokenScript({ tenantId, workspaceId, projectId });
             if (content2.toLowerCase().includes("</head>")) {
               content2 = content2.replace(/<\/head>/i, `${contextScript}</head>`);
               console.log(`[viewFile] Context script injected before </head>`);
@@ -9697,7 +11058,7 @@ var WorkspaceController = class {
           workspaceId,
           projectId,
           timestamp: Date.now()
-        })};</script>`;
+        })};</script>` + buildPreviewTokenScript({ tenantId, workspaceId, projectId });
         if (content.toLowerCase().includes("</head>")) {
           finalContent = content.replace(/<\/head>/i, `${contextScript}</head>`);
           console.log(`[viewFile] Context script injected before </head>`);
@@ -10020,13 +11381,17 @@ var ProjectAccessService = class {
     this.requireCapability(membership, input.capability);
     return { project, membership };
   }
-  /** Authorizes roster visibility: read for public rooms, manage elsewhere. */
+  /**
+   * Authorizes roster visibility for any active participant (owner/admin/member/viewer).
+   * Mutating the roster requires `manage` separately; reading it never does, because every
+   * room participant needs the member list to render the room and derive their own capabilities.
+   */
   async requireRosterAccess(input) {
     const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
     if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
     return this.requireProjectAccess({
       ...input,
-      capability: project.kind === "public" ? "read" : "manage"
+      capability: "read"
     });
   }
   async requirePublicProjectAccess(project, input) {
@@ -10111,7 +11476,7 @@ var ProjectAccessService = class {
 
 // src/controllers/database-configs.ts
 var import_core27 = require("@axiom-lattice/core");
-var import_crypto5 = require("crypto");
+var import_crypto6 = require("crypto");
 function getTenantId9(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
@@ -10189,7 +11554,7 @@ async function createDatabaseConfig(request, reply) {
         message: "Database configuration with this key already exists"
       };
     }
-    const id3 = body.id || (0, import_crypto5.randomUUID)();
+    const id3 = body.id || (0, import_crypto6.randomUUID)();
     const config = await store2.createConfig(tenantId, id3, body);
     try {
       import_core27.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
@@ -10390,7 +11755,7 @@ function registerDatabaseConfigRoutes(app2) {
 
 // src/controllers/metrics-configs.ts
 var import_core28 = require("@axiom-lattice/core");
-var import_crypto6 = require("crypto");
+var import_crypto7 = require("crypto");
 function getTenantId10(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
@@ -10471,7 +11836,7 @@ async function createMetricsServerConfig(request, reply) {
         message: "selectedDataSources is required for semantic metrics servers"
       };
     }
-    const id3 = body.id || (0, import_crypto6.randomUUID)();
+    const id3 = body.id || (0, import_crypto7.randomUUID)();
     const configData = {
       key: body.key,
       name: body.name,
@@ -10992,6 +12357,17 @@ function getTenant(request) {
   }
   return request.headers["x-tenant-id"] || "default";
 }
+async function getTenantPlugin(request, type) {
+  const tenantId = getTenant(request);
+  let tenantPlugins = [];
+  try {
+    tenantPlugins = (await (0, import_core29.getSandboxPluginCatalog)().ensureLoaded(tenantId)).plugins;
+  } catch {
+    tenantPlugins = [];
+  }
+  const globalPlugins = import_core29.PluginRegistry.list().map((t2) => import_core29.PluginRegistry.get(t2)).filter((p) => Boolean(p));
+  return (0, import_core29.mergePluginSources)(globalPlugins, tenantPlugins).find((p) => p.meta.type === type);
+}
 function maskSecrets(config) {
   const sensitive = /* @__PURE__ */ new Set([
     "password",
@@ -11075,7 +12451,7 @@ function connectionRoutes(fastify2) {
   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_core29.PluginRegistry.get(type);
+    const plugin = await getTenantPlugin(request, type);
     if (!plugin?.connection?.test) {
       return reply.status(400).send({ error: "plugin does not support connection testing" });
     }
@@ -11103,7 +12479,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_core29.PluginRegistry.get(type);
+    const plugin = await getTenantPlugin(request, type);
     if (!plugin?.connection?.discover) {
       return reply.status(400).send({ error: "plugin does not support resource discovery" });
     }
@@ -12526,9 +13902,9 @@ function resolveConsoleTokenSecret(_authRequired) {
   return devSessionSecret;
 }
 var devSessionSecret;
-function createConsoleSessionToken(payload, secret) {
+function createConsoleSessionToken(payload, secret2) {
   const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
-  const signature = (0, import_node_crypto4.createHmac)("sha256", secret).update(encodedPayload).digest("base64url");
+  const signature = (0, import_node_crypto4.createHmac)("sha256", secret2).update(encodedPayload).digest("base64url");
   return `${encodedPayload}.${signature}`;
 }
 function isConsoleSessionPayload(value) {
@@ -12536,17 +13912,17 @@ function isConsoleSessionPayload(value) {
   const payload = value;
   return typeof payload.userId === "string" && payload.userId.length > 0 && typeof payload.exp === "number" && (payload.tenantId === void 0 || typeof payload.tenantId === "string");
 }
-function extractUserFromAuthHeader(authHeader, secret) {
-  const session = verifySignedConsoleSession(authHeader, secret);
+function extractUserFromAuthHeader(authHeader, secret2) {
+  const session = verifySignedConsoleSession(authHeader, secret2);
   return session ? { id: session.id, tenantId: session.tenantId } : void 0;
 }
-function verifyConsoleSessionAuthHeader(authHeader, secret) {
-  const session = verifySignedConsoleSession(authHeader, secret);
+function verifyConsoleSessionAuthHeader(authHeader, secret2) {
+  const session = verifySignedConsoleSession(authHeader, secret2);
   if (!session?.tenantId || session.tenantId.trim() !== session.tenantId) return void 0;
   return { id: session.id, tenantId: session.tenantId, expiresAt: session.expiresAt };
 }
-function verifySignedConsoleSession(authHeader, secret) {
-  if (!secret || !authHeader?.startsWith("Bearer ")) return void 0;
+function verifySignedConsoleSession(authHeader, secret2) {
+  if (!secret2 || !authHeader?.startsWith("Bearer ")) return void 0;
   const token = authHeader.substring(7);
   const parts = token.split(".");
   if (parts.length !== 2) return void 0;
@@ -12555,7 +13931,7 @@ function verifySignedConsoleSession(authHeader, secret) {
   try {
     const actualSignature = Buffer.from(encodedSignature, "base64url");
     if (actualSignature.toString("base64url") !== encodedSignature) return void 0;
-    const expectedSignature = (0, import_node_crypto4.createHmac)("sha256", secret).update(encodedPayload).digest();
+    const expectedSignature = (0, import_node_crypto4.createHmac)("sha256", secret2).update(encodedPayload).digest();
     if (actualSignature.length !== expectedSignature.length || !(0, import_node_crypto4.timingSafeEqual)(actualSignature, expectedSignature)) {
       return void 0;
     }
@@ -12588,7 +13964,7 @@ function isStaleConsoleSessionCredential(authHeader) {
 function bypassesConsoleAuth(request) {
   const path7 = request.url.split("?")[0];
   const method = request.method;
-  if (method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/bootstrap$/.test(path7) || (method === "GET" || method === "POST") && /^\/api\/web-apps\/[^/]+\/runtime\/threads$/.test(path7) || (method === "PATCH" || method === "DELETE") && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/messages$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/files\/(viewfile|downloadfile)$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/api\/assistants\/[^/]+\/threads\/[^/]+\/sandbox\/(viewfile|downloadfile)$/.test(path7) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/(messages\/stream|abort|attachments)$/.test(path7) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/interrupts\/[^/]+\/resume$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/chat$/.test(path7) || method === "GET" && /^\/embed\/[^/]+$/.test(path7) || (method === "POST" || method === "DELETE") && path7 === "/open/mcp") return true;
+  if (method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/bootstrap$/.test(path7) || (method === "GET" || method === "POST") && /^\/api\/web-apps\/[^/]+\/runtime\/threads$/.test(path7) || (method === "PATCH" || method === "DELETE") && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/messages$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/files\/(viewfile|downloadfile)$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/api\/assistants\/[^/]+\/threads\/[^/]+\/sandbox\/(viewfile|downloadfile)$/.test(path7) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/(messages\/stream|abort|attachments)$/.test(path7) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/interrupts\/[^/]+\/resume$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/chat$/.test(path7) || method === "GET" && /^\/embed\/[^/]+$/.test(path7) || (method === "POST" || method === "DELETE") && path7 === "/open/mcp" || method === "POST" && path7 === "/open/session" || (method === "GET" || method === "POST") && path7.startsWith("/open/sandbox/files/")) return true;
   if (request.method === "GET" && /^\/api\/a2a\/agents\/[^/]+\/\.well-known\/agent-card\.json$/.test(path7)) {
     return true;
   }
@@ -12596,8 +13972,8 @@ function bypassesConsoleAuth(request) {
 }
 function registerConsoleAuthHook(app2, options) {
   app2.addHook("preHandler", async (request, reply) => {
-    const secret = options.tokenSecret ?? resolveConsoleTokenSecret(options.authRequired);
-    const session = verifySignedConsoleSession(request.headers.authorization, secret);
+    const secret2 = options.tokenSecret ?? resolveConsoleTokenSecret(options.authRequired);
+    const session = verifySignedConsoleSession(request.headers.authorization, secret2);
     if (session) {
       const user = { id: session.id, tenantId: session.tenantId, tokenExpiresAt: session.expiresAt };
       request.user = user;
@@ -12850,7 +14226,7 @@ var larkChannelAdapter = {
 };
 
 // src/channels/lark/verification.ts
-var import_crypto8 = __toESM(require("crypto"));
+var import_crypto9 = __toESM(require("crypto"));
 function parseLarkRequestBody(body, encryptKey) {
   const parsed = body || {};
   if (encryptKey && typeof parsed.encrypt === "string") {
@@ -12859,11 +14235,11 @@ function parseLarkRequestBody(body, encryptKey) {
   return parsed;
 }
 function decryptLarkPayload(encryptKey, encryptedPayload) {
-  const key = import_crypto8.default.createHash("sha256").update(encryptKey).digest();
+  const key = import_crypto9.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_crypto8.default.createDecipheriv("aes-256-cbc", key, iv);
+  const decipher = import_crypto9.default.createDecipheriv("aes-256-cbc", key, iv);
   const plaintext = Buffer.concat([
     decipher.update(ciphertext),
     decipher.final()
@@ -12980,7 +14356,7 @@ function registerChannelRoutes(app2, dependencies) {
 }
 
 // src/controllers/channel-installations.ts
-var import_crypto9 = require("crypto");
+var import_crypto10 = require("crypto");
 var import_protocols5 = require("@axiom-lattice/protocols");
 var _adapterRegistry;
 var _router;
@@ -13105,8 +14481,8 @@ function snapshotPlainObject(value) {
   }
 }
 async function getInstallationStore() {
-  const { getStoreLattice: getStoreLattice31 } = await import("@axiom-lattice/core");
-  const store2 = getStoreLattice31("default", "channelInstallation").store;
+  const { getStoreLattice: getStoreLattice37 } = await import("@axiom-lattice/core");
+  const store2 = getStoreLattice37("default", "channelInstallation").store;
   if (store2) return store2;
   const { PostgreSQLChannelInstallationStore } = await import("@axiom-lattice/pg-stores");
   const databaseUrl = process.env.DATABASE_URL;
@@ -13182,7 +14558,7 @@ async function createChannelInstallation(request, reply) {
       };
     }
     const store2 = await getInstallationStore();
-    const installationId = (0, import_crypto9.randomUUID)();
+    const installationId = (0, import_crypto10.randomUUID)();
     const createInput = {
       channel: body.channel,
       name: body.name,
@@ -16612,10 +17988,10 @@ function resolveAgentWebAppAttachmentSecret(consoleSecret) {
   return process.env.WEB_APP_ATTACHMENT_SECRET || process.env.AUTH_TOKEN_SECRET || process.env.JWT_SECRET || consoleSecret;
 }
 var AgentWebAppAttachmentRefService = class {
-  constructor(secret, now = Date.now) {
+  constructor(secret2, now = Date.now) {
     this.now = now;
-    if (!secret) throw new Error("Attachment signing secret is required");
-    this.key = (0, import_node_crypto9.createHash)("sha256").update(secret, "utf8").digest();
+    if (!secret2) throw new Error("Attachment signing secret is required");
+    this.key = (0, import_node_crypto9.createHash)("sha256").update(secret2, "utf8").digest();
   }
   sign(input) {
     const payload = {
@@ -17875,7 +19251,14 @@ function registerProjectRoomRoutes(app2, deps) {
     await deps.readStateService.mark(actor(request, params.projectId));
     return { data: { marked: true } };
   }));
-  app2.get("/api/projects/:projectId/members", async (request, reply) => run(reply, async () => ({ data: await deps.membershipService.list(actor(request, projectRoomParamsSchema.parse(request.params).projectId)) })));
+  app2.get("/api/projects/:projectId/members", async (request, reply) => run(reply, async () => {
+    const memberships = await deps.membershipService.list(actor(request, projectRoomParamsSchema.parse(request.params).projectId));
+    const enriched = await Promise.all(memberships.map(async (membership) => {
+      const user = await deps.userDirectory.getUserById(membership.userId);
+      return user === null ? membership : { ...membership, name: user.name };
+    }));
+    return { data: enriched };
+  }));
   app2.post("/api/projects/:projectId/members", async (request, reply) => run(reply, async () => {
     const p = projectRoomParamsSchema.parse(request.params);
     return { statusCode: 201, data: await deps.membershipService.add(actor(request, p.projectId), addProjectMemberSchema.parse(request.body)) };
@@ -18047,13 +19430,16 @@ function registerCoSpaceRoutes(app2, deps) {
               project.id
             );
             const participantNames = [];
+            const otherHumanNames = [];
             for (const m of memberships) {
               if (m.status !== "active") continue;
               const user = await deps.userStore.getUserById(m.userId);
               if (user) {
                 participantNames.push(user.name);
+                if (m.userId !== actor2.userId) otherHumanNames.push(user.name);
               }
             }
+            const displayName = project.kind === "personal" && otherHumanNames.length === 1 ? otherHumanNames[0] : void 0;
             rooms.push({
               project,
               room,
@@ -18062,6 +19448,7 @@ function registerCoSpaceRoutes(app2, deps) {
                 (m) => m.status === "active"
               ).length,
               participantNames,
+              ...displayName === void 0 ? {} : { displayName },
               unreadCount: await computeUnread(
                 deps,
                 actor2.tenantId,
@@ -18079,41 +19466,45 @@ function registerCoSpaceRoutes(app2, deps) {
           const bTime = b.lastMessage ? Date.parse(b.lastMessage.createdAt) : 0;
           return bTime - aTime;
         });
-        const publicRoom = await deps.publicRoom.ensure(actor2.tenantId, params.workspaceId);
-        if (publicRoom) {
-          const publicMessages = await deps.messageStore.list({
-            tenantId: actor2.tenantId,
-            roomId: publicRoom.room.id,
-            limit: 1
-          });
-          const publicLastMessage = publicMessages[0];
-          const publicMemberships = await deps.membershipStore.list(
-            actor2.tenantId,
-            publicRoom.project.id
-          );
-          const publicParticipantNames = [];
-          for (const m of publicMemberships) {
-            if (m.status !== "active") continue;
-            const user = await deps.userStore.getUserById(m.userId);
-            if (user) {
-              publicParticipantNames.push(user.name);
+        try {
+          const publicRoom = await deps.publicRoom.ensure(actor2.tenantId, params.workspaceId);
+          if (publicRoom) {
+            const publicMessages = await deps.messageStore.list({
+              tenantId: actor2.tenantId,
+              roomId: publicRoom.room.id,
+              limit: 1
+            });
+            const publicLastMessage = publicMessages[0];
+            const publicMemberships = await deps.membershipStore.list(
+              actor2.tenantId,
+              publicRoom.project.id
+            );
+            const publicParticipantNames = [];
+            for (const m of publicMemberships) {
+              if (m.status !== "active") continue;
+              const user = await deps.userStore.getUserById(m.userId);
+              if (user) {
+                publicParticipantNames.push(user.name);
+              }
             }
+            rooms.unshift({
+              project: publicRoom.project,
+              room: publicRoom.room,
+              lastMessage: publicLastMessage === void 0 ? void 0 : (0, import_protocols15.toProjectRoomPublicMessage)(publicLastMessage),
+              participantCount: publicMemberships.filter((m) => m.status === "active").length,
+              participantNames: publicParticipantNames,
+              isPublic: true,
+              unreadCount: await computeUnread(
+                deps,
+                actor2.tenantId,
+                actor2.userId,
+                publicRoom.room.id,
+                publicLastMessage
+              )
+            });
           }
-          rooms.unshift({
-            project: publicRoom.project,
-            room: publicRoom.room,
-            lastMessage: publicLastMessage === void 0 ? void 0 : (0, import_protocols15.toProjectRoomPublicMessage)(publicLastMessage),
-            participantCount: publicMemberships.filter((m) => m.status === "active").length,
-            participantNames: publicParticipantNames,
-            isPublic: true,
-            unreadCount: await computeUnread(
-              deps,
-              actor2.tenantId,
-              actor2.userId,
-              publicRoom.room.id,
-              publicLastMessage
-            )
-          });
+        } catch (e) {
+          console.error("[CoSpace] Failed to assemble public room:", e);
         }
         return { data: { rooms } };
       });
@@ -18138,7 +19529,6 @@ function registerCoSpaceRoutes(app2, deps) {
           );
         }
         let projectId;
-        let otherPartyId;
         if (body.type === "human") {
           projectId = (0, import_core44.generateDirectHumanProjectId)(
             actor2.tenantId,
@@ -18146,7 +19536,6 @@ function registerCoSpaceRoutes(app2, deps) {
             actor2.userId,
             body.targetUserId
           );
-          otherPartyId = body.targetUserId;
         } else {
           projectId = (0, import_core44.generateDirectBotProjectId)(
             actor2.tenantId,
@@ -18154,14 +19543,24 @@ function registerCoSpaceRoutes(app2, deps) {
             actor2.userId,
             body.assistantId
           );
-          otherPartyId = body.assistantId;
         }
         let project = await deps.projectStore.getProjectById(
           actor2.tenantId,
           projectId
         );
         if (!project) {
-          const name = body.type === "human" ? `Direct with ${otherPartyId}` : `Chat with ${otherPartyId}`;
+          let displayName;
+          if (body.type === "human") {
+            const targetUser = await deps.userStore.getUserById(body.targetUserId);
+            displayName = targetUser?.name ?? body.targetUserId;
+          } else {
+            const targetAssistant = await deps.assistantStore.getAssistantById(
+              actor2.tenantId,
+              body.assistantId
+            );
+            displayName = targetAssistant?.name ?? body.assistantId;
+          }
+          const name = body.type === "human" ? `Direct with ${displayName}` : `Chat with ${displayName}`;
           project = await deps.projectStore.createProject(
             actor2.tenantId,
             params.workspaceId,
@@ -18354,12 +19753,28 @@ function registerCoSpaceRoutes(app2, deps) {
             actor2.tenantId,
             directProjectId
           );
-          bots.push({
+          const bot = {
             assistantId: assistant.id,
             name: assistant.name,
             description: assistant.description,
             hasDirectRoom: existingProject !== null
-          });
+          };
+          if (assistant.createdAt) bot.createdAt = assistant.createdAt.toISOString();
+          if (existingProject) {
+            const membership = await deps.botMembershipStore.findByAssistant(
+              actor2.tenantId,
+              directProjectId,
+              assistant.id
+            );
+            if (membership) {
+              if (membership.role) bot.role = membership.role;
+              if (membership.mentionName) bot.mentionName = membership.mentionName;
+              if (membership.responsibility) bot.responsibility = membership.responsibility;
+              bot.status = membership.status;
+              if (membership.joinedAt) bot.joinedAt = membership.joinedAt.toISOString();
+            }
+          }
+          bots.push(bot);
         }
         return { data: { bots } };
       });
@@ -18400,13 +19815,15 @@ function registerCoSpaceRoutes(app2, deps) {
             actor2.tenantId,
             directProjectId
           );
-          members.push({
+          const member = {
             userId: link.userId,
             name: user.name,
             email: user.email,
             role: link.role,
             hasDirectRoom: existingProject !== null
-          });
+          };
+          if (link.joinedAt) member.joinedAt = link.joinedAt.toISOString();
+          members.push(member);
         }
         return { data: { members } };
       });
@@ -22252,7 +23669,15 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       });
     }
   };
-  registerProjectRoomRoutes(app2, { roomService, membershipService, messageService, readStateService });
+  registerProjectRoomRoutes(app2, {
+    roomService,
+    membershipService,
+    messageService,
+    readStateService,
+    userDirectory: {
+      getUserById: (id3) => (0, import_core51.getStoreLattice)("default", "user").store.getUserById(id3).then((u) => u ? { name: u.name } : null)
+    }
+  });
   registerProjectRosterRoutes(app2, { service: rosterService });
   registerCoSpaceRoutes(app2, {
     projectStore: {
@@ -23617,7 +25042,7 @@ var collectionRegistration = {
 
 // src/export_registrations/channel-installation.registration.ts
 var import_core59 = require("@axiom-lattice/core");
-var import_crypto10 = require("crypto");
+var import_crypto11 = require("crypto");
 var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var PUBLIC_CHANNELS = /* @__PURE__ */ new Set(["lark", "email", "slack", "wechat"]);
 function isPublicChannel(channel) {
@@ -23776,7 +25201,7 @@ var channelInstallationRegistration = {
       }
       id3 = sourceId;
     } else {
-      id3 = (0, import_crypto10.randomUUID)();
+      id3 = (0, import_crypto11.randomUUID)();
     }
     await store2.createInstallation(tenantId, id3, createInput);
     return { newId: id3 };
@@ -24323,7 +25748,7 @@ function createAuditLoggerMiddleware() {
 }
 
 // src/index.ts
-var import_core69 = require("@axiom-lattice/core");
+var import_core78 = require("@axiom-lattice/core");
 
 // src/swagger.ts
 var import_swagger = __toESM(require("@fastify/swagger"));
@@ -24640,7 +26065,7 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core70 = require("@axiom-lattice/core");
+var import_core79 = require("@axiom-lattice/core");
 
 // src/channels/ChannelInfrastructure.ts
 var import_core65 = require("@axiom-lattice/core");
@@ -24648,7 +26073,7 @@ var import_core65 = require("@axiom-lattice/core");
 // src/router/MessageRouter.ts
 var import_core64 = require("@axiom-lattice/core");
 var import_protocols27 = require("@axiom-lattice/protocols");
-var import_crypto11 = require("crypto");
+var import_crypto12 = require("crypto");
 var BindingNotFoundError = class extends Error {
   constructor(message) {
     super(message);
@@ -24963,7 +26388,7 @@ var MessageRouter = class {
         }
         if (!threadId) {
           const threadStore = (0, import_core64.getStoreLattice)("default", "thread").store;
-          const newThreadId = (0, import_crypto11.randomUUID)();
+          const newThreadId = (0, import_crypto12.randomUUID)();
           console.log({
             event: "dispatch:thread:create",
             agentId,
@@ -25009,7 +26434,7 @@ var MessageRouter = class {
           workspace_id: binding?.workspaceId || "",
           project_id: binding?.projectId || ""
         });
-        const inputMessageId = (0, import_crypto11.randomUUID)();
+        const inputMessageId = (0, import_crypto12.randomUUID)();
         const replyTarget = internalRoom ? correlatedRoomReplyTarget(message.replyTarget, inputMessageId) : message.replyTarget;
         const replyAdapter = replyTarget ? this.adapterRegistry.get(replyTarget.adapterChannel) : void 0;
         if (options.trustedMessageOptions && (!this.trustedDispatcher || !replyTarget || !replyAdapter)) {
@@ -25207,25 +26632,25 @@ async function prepareProjectTaskRuntime(runtime, log2) {
 }
 
 // src/index.ts
-var import_protocols30 = require("@axiom-lattice/protocols");
+var import_protocols35 = require("@axiom-lattice/protocols");
 process.on("unhandledRejection", (reason, promise) => {
   console.error("\u672A\u5904\u7406\u7684Promise\u62D2\u7EDD:", reason);
 });
 var DEFAULT_LOGGER_CONFIG = {
   name: "default",
   description: "Default logger for lattice-gateway service",
-  type: import_protocols30.LoggerType.PINO,
+  type: import_protocols35.LoggerType.PINO,
   serviceName: "lattice/gateway",
   loggerName: "lattice/gateway"
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger6 = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core70.loggerLatticeManager.hasLattice("default")) {
-    import_core70.loggerLatticeManager.removeLattice("default");
+  if (import_core79.loggerLatticeManager.hasLattice("default")) {
+    import_core79.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core70.registerLoggerLattice)("default", config);
-  return (0, import_core70.getLoggerLattice)("default");
+  (0, import_core79.registerLoggerLattice)("default", config);
+  return (0, import_core79.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -25322,7 +26747,7 @@ app.setErrorHandler((error, request, reply) => {
 });
 function getConfiguredSandboxProvider() {
   const sandboxProviderType = process.env.SANDBOX_PROVIDER_TYPE || "microsandbox-remote";
-  return (0, import_core70.createSandboxProvider)({
+  return (0, import_core79.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -25338,7 +26763,7 @@ function getConfiguredSandboxProvider() {
 }
 async function restoreMcpConnections() {
   try {
-    const storeLattice = (0, import_core70.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core79.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     if (!store2) {
       logger6.info("MCP store not configured, skipping connection restoration");
@@ -25352,15 +26777,15 @@ async function restoreMcpConnections() {
     for (const config of connectedConfigs) {
       try {
         const connection = convertToConnection2(config.config);
-        import_core70.mcpManager.addServer(config.key, connection);
+        import_core79.mcpManager.addServer(config.key, connection);
       } catch (err) {
         logger6.warn(`Failed to prepare MCP server "${config.key}" for restoration`, { error: err });
       }
     }
-    await import_core70.mcpManager.connect();
+    await import_core79.mcpManager.connect();
     for (const config of connectedConfigs) {
       try {
-        await import_core70.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
+        await import_core79.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
         logger6.info(`MCP server "${config.key}" restored with ${config.selectedTools.length} tools`);
       } catch (err) {
         logger6.warn(`Failed to register tools for MCP server "${config.key}"`, { error: err });
@@ -25388,9 +26813,9 @@ var start = async (config) => {
     let projectRoomRealtimeRuntime;
     if (projectRoomRealtimeMode === "single-gateway") {
       projectRoomRealtimeRuntime = createProjectRoomRealtimeRuntime({
-        tasks: (0, import_core70.getStoreLattice)("default", "task").store,
-        rooms: (0, import_core70.getStoreLattice)("default", "projectRoom").store,
-        memberships: (0, import_core70.getStoreLattice)("default", "projectBotMembership").store,
+        tasks: (0, import_core79.getStoreLattice)("default", "task").store,
+        rooms: (0, import_core79.getStoreLattice)("default", "projectRoom").store,
+        memberships: (0, import_core79.getStoreLattice)("default", "projectBotMembership").store,
         log: { warn: (message, context) => logger6.warn(message, context) }
       });
     }
@@ -25404,7 +26829,7 @@ var start = async (config) => {
       const infrastructure = createChannelInfrastructure({
         adapterRegistry,
         getStore: ((kind) => getStore11("default", kind).store),
-        trustedDispatcher: (0, import_core70.createTrustedAgentMessageDispatcher)((scope) => import_core70.agentInstanceManager.getAgent(scope)),
+        trustedDispatcher: (0, import_core79.createTrustedAgentMessageDispatcher)((scope) => import_core79.agentInstanceManager.getAgent(scope)),
         middlewares: [
           createDeduplicationMiddleware(),
           createRateLimitMiddleware(),
@@ -25415,7 +26840,7 @@ var start = async (config) => {
       });
       const bindingStore = infrastructure.bindingRegistry;
       const installationStore = infrastructure.installationStore;
-      (0, import_core69.setBindingRegistry)(bindingStore);
+      (0, import_core78.setBindingRegistry)(bindingStore);
       const router = infrastructure.router;
       app.addHook("onClose", async () => router.dispose());
       channelDeps = {
@@ -25431,10 +26856,10 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    (0, import_core69.setEvalRunService)(evalRunner);
+    (0, import_core78.setEvalRunService)(evalRunner);
     try {
-      const menuStore = (0, import_core70.getStoreLattice)("default", "menu").store;
-      (0, import_core69.setMenuRegistry)(menuStore);
+      const menuStore = (0, import_core79.getStoreLattice)("default", "menu").store;
+      (0, import_core78.setMenuRegistry)(menuStore);
       logger6.info("Menu registry initialized");
     } catch {
     }
@@ -25451,10 +26876,10 @@ var start = async (config) => {
       const { A2AAuthService: A2AAuthService2, parseEnvKeys: parseEnvKeys2 } = await Promise.resolve().then(() => (init_A2AAuthService(), A2AAuthService_exports));
       const { registerA2AStandardRoutes: registerA2AStandardRoutes2 } = await Promise.resolve().then(() => (init_a2a_standard(), a2a_standard_exports));
       const a2a = await Promise.resolve().then(() => (init_a2a(), a2a_exports));
-      const a2aKeyStore = (0, import_core70.getStoreLattice)("default", "a2aApiKey").store;
-      const assistantStore = (0, import_core70.getStoreLattice)("default", "assistant").store;
-      const projectStore = (0, import_core70.getStoreLattice)("default", "project").store;
-      const taskStore = (0, import_core70.getStoreLattice)("default", "task").store;
+      const a2aKeyStore = (0, import_core79.getStoreLattice)("default", "a2aApiKey").store;
+      const assistantStore = (0, import_core79.getStoreLattice)("default", "assistant").store;
+      const projectStore = (0, import_core79.getStoreLattice)("default", "project").store;
+      const taskStore = (0, import_core79.getStoreLattice)("default", "task").store;
       const authService = new A2AAuthService2({
         keyStore: a2aKeyStore,
         assistantStore,
@@ -25480,24 +26905,54 @@ var start = async (config) => {
     }
     try {
       const { registerOpenRoutes: registerOpenRoutes2 } = await Promise.resolve().then(() => (init_open(), open_exports));
+      const { registerOpenSessionRoutes: registerOpenSessionRoutes2 } = await Promise.resolve().then(() => (init_open_session(), open_session_exports));
+      const { registerOpenCatalogRoutes: registerOpenCatalogRoutes2 } = await Promise.resolve().then(() => (init_open_catalog(), open_catalog_exports));
+      const { registerOpenFilesRoutes: registerOpenFilesRoutes2 } = await Promise.resolve().then(() => (init_open_files(), open_files_exports));
+      const { registerOpenAuditRoutes: registerOpenAuditRoutes2 } = await Promise.resolve().then(() => (init_open_audit(), open_audit_exports));
+      const { registerOpenExposureRoutes: registerOpenExposureRoutes2 } = await Promise.resolve().then(() => (init_open_exposure(), open_exposure_exports));
+      const { openLattice: openLattice2 } = await Promise.resolve().then(() => (init_openLattice(), openLattice_exports));
+      const { createKbProvider: createKbProvider2 } = await Promise.resolve().then(() => (init_kbProvider(), kbProvider_exports));
+      const { createOpenSandboxProvider: createOpenSandboxProvider2 } = await Promise.resolve().then(() => (init_sandboxProvider(), sandboxProvider_exports));
+      const { createAgentProvider: createAgentProvider2 } = await Promise.resolve().then(() => (init_agentProvider(), agentProvider_exports));
+      const { registerExposedPluginTools: registerExposedPluginTools2 } = await Promise.resolve().then(() => (init_registerExposedPlugins(), registerExposedPlugins_exports));
+      const { CollectionService: CollectionService2 } = await Promise.resolve().then(() => (init_collection_service(), collection_service_exports));
+      openLattice2.register(createKbProvider2(new CollectionService2()));
+      openLattice2.register(createOpenSandboxProvider2());
+      const threadStore = (0, import_core79.getStoreLattice)("default", "thread").store;
+      const assistantStore = (0, import_core79.getStoreLattice)("default", "assistant").store;
+      openLattice2.register(
+        createAgentProvider2({
+          threadStore,
+          resolveAssistant: async (tenantId, assistantId) => {
+            const assistant = await assistantStore.getAssistantById(tenantId, assistantId);
+            return assistant ? { name: assistant.name, description: assistant.description } : null;
+          }
+        })
+      );
+      await registerExposedPluginTools2();
       registerOpenRoutes2(app);
-      logger6.info("Open MCP spike routes registered");
+      registerOpenSessionRoutes2(app);
+      registerOpenCatalogRoutes2(app);
+      registerOpenFilesRoutes2(app);
+      registerOpenAuditRoutes2(app);
+      registerOpenExposureRoutes2(app);
+      logger6.info("Open API routes registered (kb + sandbox providers, session exchange)");
     } catch (err) {
-      logger6.warn("Open MCP spike routes unavailable", {
+      logger6.warn("Open API routes unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    if (!import_core70.sandboxLatticeManager.hasLattice("default")) {
-      import_core70.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+    if (!import_core79.sandboxLatticeManager.hasLattice("default")) {
+      import_core79.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
       logger6.info("Registered sandbox manager from env configuration");
     }
     try {
       const { ResourceController: ResourceController2 } = await Promise.resolve().then(() => (init_resources(), resources_exports));
-      const sharedResourceStore = (0, import_core70.getStoreLattice)("default", "sharedResource").store;
-      const cache = new import_core70.TokenCache();
+      const sharedResourceStore = (0, import_core79.getStoreLattice)("default", "sharedResource").store;
+      const cache = new import_core79.TokenCache();
       const resourceController = new ResourceController2({
         store: sharedResourceStore,
-        sandboxManager: import_core70.sandboxLatticeManager,
+        sandboxManager: import_core79.sandboxLatticeManager,
         cache,
         logger: logger6
       });
@@ -25536,7 +26991,7 @@ var start = async (config) => {
       }
     }
     if (process.env.AXIOM_RESTORE_PENDING_ON_STARTUP === "true") {
-      import_core70.agentInstanceManager.restore().then((stats) => {
+      import_core79.agentInstanceManager.restore().then((stats) => {
         logger6.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
       }).catch((error) => {
         logger6.error("Agent recovery failed", { error });