trellis 3.2.3 → 3.2.4

package/dist/{chunk-2AACZRII.js → chunk-SJWVDS5M.js}

@@ -1,6 +1,28 @@
+import {
+  McpServer,
+  StreamableMcpGateway,
+  corsEnabledForConfig,
+  corsPreflightResponse,
+  discoveryMcpGateway,
+  mcpServiceDocument,
+  oauthAuthorizationServerMetadata,
+  oauthProtectedResourceMetadata,
+  withCors
+} from "./chunk-53PDCTJ3.js";
+import {
+  McpRateLimitError,
+  UsageMeter,
+  assertMcpBudget,
+  collectionSlugFromMetaId,
+  resolveCollectionId,
+  resolveMcpTenantId,
+  resolveUsageTenantId,
+  verifyAdminKey,
+  writeContext
+} from "./chunk-CMSFD6OV.js";
 import {
   DEFAULT_TENANT
-} from "./chunk-JHHEXEDM.js";
+} from "./chunk-GCQF75T4.js";
 import {
   rel
 } from "./chunk-44FFQKQX.js";
@@ -14,8 +36,8 @@ import {
 } from "./chunk-X5FLTRUB.js";
 
 // src/server/server.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { dirname, join as join2 } from "path";
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 
 // src/server/auth.ts
@@ -370,114 +392,6 @@ async function hydrateAndResolve(kernel, bindings, entityType, resolve) {
   });
 }
 
-// src/server/usage-meter.ts
-import { existsSync, readdirSync, statSync } from "fs";
-import { join } from "path";
-var EMPTY_BUCKET = () => ({
-  graph_io: 0,
-  storage_bytes: 0,
-  egress_bytes: 0
-});
-function resolveUsageTenantId(tenantId) {
-  return tenantId ?? DEFAULT_TENANT;
-}
-function dayKey(date) {
-  return date.toISOString().slice(0, 10);
-}
-function dirSize(dir) {
-  let total = 0;
-  for (const ent of readdirSync(dir, { withFileTypes: true })) {
-    const p = join(dir, ent.name);
-    if (ent.isDirectory()) total += dirSize(p);
-    else if (ent.isFile()) total += statSync(p).size;
-  }
-  return total;
-}
-function sampleTenantStorage(pool, tenantId) {
-  let total = 0;
-  const sqlitePath = pool.dbFilePath(tenantId);
-  if (existsSync(sqlitePath)) {
-    total += statSync(sqlitePath).size;
-  }
-  const blobDir = join(pool.dataPath(), "blobs");
-  if (existsSync(blobDir)) {
-    total += dirSize(blobDir);
-  }
-  return total;
-}
-function verifyAdminKey(req) {
-  const expected = process.env.TURTLEDB_ADMIN_KEY;
-  if (!expected) return false;
-  const auth = req.headers.get("authorization");
-  if (auth?.startsWith("Bearer ")) {
-    return auth.slice("Bearer ".length) === expected;
-  }
-  return req.headers.get("x-turtledb-admin-key") === expected;
-}
-var UsageMeter = class {
-  buckets = /* @__PURE__ */ new Map();
-  storageSampledAt = /* @__PURE__ */ new Map();
-  now;
-  constructor(opts = {}) {
-    this.now = opts.now ?? (() => /* @__PURE__ */ new Date());
-  }
-  recordGraphIo(tenantId, count = 1) {
-    if (count <= 0) return;
-    const bucket = this._bucket(tenantId);
-    bucket.graph_io += count;
-  }
-  recordEgress(tenantId, bytes) {
-    if (bytes <= 0) return;
-    const bucket = this._bucket(tenantId);
-    bucket.egress_bytes += bytes;
-  }
-  /** Set storage gauge for the current day (from sampler, not incremental). */
-  recordStorage(tenantId, bytes) {
-    const bucket = this._bucket(tenantId);
-    bucket.storage_bytes = bytes;
-    this.storageSampledAt.set(`${tenantId}:${this._today()}`, this.now().toISOString());
-  }
-  sampleStorage(pool, tenantId) {
-    const id = resolveUsageTenantId(tenantId);
-    const bytes = sampleTenantStorage(pool, id);
-    this.recordStorage(id, bytes);
-    return bytes;
-  }
-  getUsage(tenantId, day) {
-    const d = day ?? this._today();
-    const tenantBuckets = this.buckets.get(tenantId);
-    const meters = tenantBuckets?.get(d) ?? EMPTY_BUCKET();
-    const sampledAt = this.storageSampledAt.get(`${tenantId}:${d}`);
-    return {
-      tenantId,
-      day: d,
-      meters: { ...meters },
-      ...sampledAt ? { storageSampledAt: sampledAt } : {}
-    };
-  }
-  /** All day keys recorded for a tenant (sorted ascending). */
-  listDays(tenantId) {
-    const tenantBuckets = this.buckets.get(tenantId);
-    if (!tenantBuckets) return [];
-    return Array.from(tenantBuckets.keys()).sort();
-  }
-  _today() {
-    return dayKey(this.now());
-  }
-  _bucket(tenantId) {
-    const id = resolveUsageTenantId(tenantId);
-    const d = this._today();
-    if (!this.buckets.has(id)) {
-      this.buckets.set(id, /* @__PURE__ */ new Map());
-    }
-    const tenantBuckets = this.buckets.get(id);
-    if (!tenantBuckets.has(d)) {
-      tenantBuckets.set(d, EMPTY_BUCKET());
-    }
-    return tenantBuckets.get(d);
-  }
-};
-
 // src/server/realtime.ts
 var SubscriptionManager = class {
   clients = /* @__PURE__ */ new Map();
@@ -549,7 +463,6 @@ var SubscriptionManager = class {
         dead.push(clientId);
         continue;
       }
-      if (client.tenantId !== tid) continue;
       for (const [subId, sub] of client.subscriptions) {
         if (sub.tenantId !== tid) continue;
         await this._pushUpdate(client, sub);
@@ -606,6 +519,9 @@ var SubscriptionManager = class {
       resolve: opts.resolve
     };
     client.subscriptions.set(subId, sub);
+    if (tid !== null && client.tenantId !== tid) {
+      client.tenantId = tid;
+    }
     this._send(client, { type: "subscribed", id: subId });
     this._send(client, {
       type: "data",
@@ -682,55 +598,641 @@ function computeDiff(prev, next) {
   return { added, updated, removed };
 }
 
-// src/server/cors.ts
-var DEFAULT_METHODS = "GET, POST, PUT, DELETE, OPTIONS";
-var DEFAULT_HEADERS = "Content-Type, Authorization";
-function corsEnabledForConfig(apiKey) {
-  return Boolean(process.env.TRELLIS_CORS_ORIGINS) || Boolean(apiKey);
+// src/mcp/room.ts
+import { z as z2 } from "zod";
+
+// src/mcp/graph-summary.ts
+var SKIP_ATTRS = /* @__PURE__ */ new Set(["@id", "@type", "id", "type"]);
+function buildRoomGraphSummary(kernel, tenantId, opts = {}) {
+  const limit = opts.limit ?? 10;
+  const store = kernel.getStore();
+  let factCount = 0;
+  for (const _ of store.getAllFacts()) factCount++;
+  let linkCount = 0;
+  for (const _ of store.getAllLinks()) linkCount++;
+  const typeCounts = {};
+  const entityIds = /* @__PURE__ */ new Set();
+  for (const fact of store.getAllFacts()) {
+    if (fact.a === "type") {
+      const type = String(fact.v);
+      typeCounts[type] = (typeCounts[type] ?? 0) + 1;
+      entityIds.add(fact.e);
+    }
+  }
+  const entityTypes = Object.entries(typeCounts).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([type, count]) => ({ type, count }));
+  const systemOntologies = [];
+  const userOntologies = [];
+  for (const schema of kernel.listOntologies()) {
+    const shortId = schema["@id"].replace(/^(trellis:schema\/|core:)/, "");
+    if (schema.tier === "user") {
+      userOntologies.push(shortId);
+    } else if (schema.tier !== "core") {
+      systemOntologies.push(shortId);
+    }
+  }
+  const topAttributes = store.getCatalog().filter((c) => !SKIP_ATTRS.has(c.attribute)).sort((a, b) => b.distinctCount - a.distinctCount).slice(0, limit).map((c) => ({
+    attribute: c.attribute,
+    distinctCount: c.distinctCount,
+    cardinality: c.cardinality
+  }));
+  const relations = /* @__PURE__ */ new Set();
+  for (const link of store.getAllLinks()) relations.add(link.a);
+  const recentMutations = kernel.readAllOps().slice(-limit).reverse().map((op) => ({
+    kind: op.kind,
+    agentId: op.agentId,
+    timestamp: op.timestamp,
+    entityId: inferEntityIdFromOp(op)
+  }));
+  return {
+    health: {
+      status: "ok",
+      factCount,
+      linkCount,
+      entityCount: entityIds.size,
+      ops: kernel.readAllOps().length,
+      tenantId
+    },
+    entityTypes,
+    ontologies: {
+      total: kernel.listOntologies().length,
+      system: systemOntologies.slice(0, limit),
+      user: userOntologies.slice(0, limit)
+    },
+    topAttributes,
+    links: { total: linkCount, relations: [...relations].sort().slice(0, limit) },
+    recentMutations
+  };
 }
-function allowedOrigins() {
-  const raw = process.env.TRELLIS_CORS_ORIGINS?.trim();
-  if (!raw || raw === "*") return "*";
-  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+function inferEntityIdFromOp(op) {
+  const facts = op.facts ?? op.deleteFacts;
+  if (!facts?.length) return void 0;
+  const typeFact = facts.find((f) => "a" in f && f.a === "type");
+  return typeFact?.e ?? facts[0]?.e;
 }
-function corsHeaders(req) {
-  const origins = allowedOrigins();
-  const requestOrigin = req.headers.get("Origin");
-  let allowOrigin = "*";
-  if (origins !== "*") {
-    if (requestOrigin && origins.includes(requestOrigin)) {
-      allowOrigin = requestOrigin;
-    } else if (origins.length === 1) {
-      allowOrigin = origins[0];
+
+// src/mcp/room-audit.ts
+function sanitizeInput(params) {
+  const out = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value === "string" && value.length > 2e3) {
+      out[key] = value.slice(0, 2e3) + "\u2026";
     } else {
-      allowOrigin = origins[0] ?? "*";
+      out[key] = value;
     }
   }
-  return {
-    "Access-Control-Allow-Origin": allowOrigin,
-    "Access-Control-Allow-Methods": DEFAULT_METHODS,
-    "Access-Control-Allow-Headers": DEFAULT_HEADERS,
-    Vary: "Origin"
-  };
+  return out;
+}
+function summarizeText(text2, max = 500) {
+  return text2.length > max ? text2.slice(0, max) + "\u2026" : text2;
 }
-function withCors(req, res) {
-  const headers = new Headers(res.headers);
-  for (const [key, value] of Object.entries(corsHeaders(req))) {
-    headers.set(key, value);
-  }
-  return new Response(res.body, {
-    status: res.status,
-    statusText: res.statusText,
-    headers
+async function recordRoomMcpAudit(kernel, agentId, toolName, params, resultText, wctx, relatedEntities = []) {
+  try {
+    const id = `decision:mcp-${crypto.randomUUID().slice(0, 8)}`;
+    const links = relatedEntities.map((targetEntityId) => ({
+      attribute: "relatedTo",
+      targetEntityId
+    }));
+    await kernel.createEntity(
+      id,
+      "Decision",
+      {
+        title: `MCP ${toolName}`,
+        toolName,
+        input: JSON.stringify(sanitizeInput(params)),
+        outputSummary: summarizeText(resultText),
+        createdBy: agentId,
+        source: "room-mcp"
+      },
+      links.length > 0 ? links : void 0,
+      wctx
+    );
+    return id;
+  } catch {
+    return null;
+  }
+}
+function scheduleRoomMcpAudit(kernelPromise, agentId, toolName, params, resultText, wctx, relatedEntities) {
+  void kernelPromise.then(
+    (kernel) => recordRoomMcpAudit(
+      kernel,
+      agentId,
+      toolName,
+      params,
+      resultText,
+      wctx,
+      relatedEntities
+    )
+  );
+}
+
+// src/mcp/room.ts
+var laneSchema = z2.string().optional().describe(
+  "Draft lane for op attribution (e.g. agent:cursor). Defaults to authenticated user or agent:room-mcp."
+);
+var tenantIdSchema = z2.string().optional().describe(
+  "Tenant id (e.g. embed-design-review). Overrides session default. Use for Playground multi-tenant rooms."
+);
+var roomSchema = z2.string().optional().describe(
+  "Playground ?room= slug \u2014 resolves to tenant embed-{slug} (same as playground.trellis.computer session rooms)."
+);
+function resolveToolTenant(ctx, args) {
+  return resolveMcpTenantId({
+    defaultTenantId: ctx.tenantId,
+    headerTenant: ctx.headerTenant,
+    toolTenantId: args.tenantId,
+    roomSlug: args.room
   });
 }
-function corsPreflightResponse(req) {
-  return new Response(null, {
-    status: 204,
-    headers: corsHeaders(req)
+function text(content) {
+  return { content: [{ type: "text", text: content }] };
+}
+function jsonText(data) {
+  return text(JSON.stringify(data, null, 2));
+}
+function toolError(err) {
+  if (err instanceof PermissionError || err instanceof McpRateLimitError) {
+    return text(err.message);
+  }
+  return text(err instanceof Error ? err.message : String(err));
+}
+async function withMcpIo(ctx, tenantId, fn) {
+  assertMcpBudget(ctx.meter, tenantId);
+  const result = await fn();
+  ctx.meter?.recordGraphIo(resolveUsageTenantId(tenantId));
+  return result;
+}
+function auditWrite(kernel, wctx, toolName, params, payload, relatedEntities = []) {
+  const agentId = wctx.agentId ?? "agent:room-mcp";
+  const resultText = typeof payload === "string" ? payload : JSON.stringify(payload);
+  scheduleRoomMcpAudit(
+    Promise.resolve(kernel),
+    agentId,
+    toolName,
+    params,
+    resultText,
+    wctx,
+    relatedEntities
+  );
+}
+function createRoomMcpServer(ctx) {
+  const server = new McpServer({
+    name: "trellis-room",
+    version: "0.2.0"
   });
+  server.registerTool(
+    "get_graph_summary",
+    {
+      description: "Compact graph overview \u2014 health, entity types, ontologies, top attributes, links, recent ops. Call first.",
+      inputSchema: {
+        limit: z2.number().optional().describe("Max items per section (default: 10)"),
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ limit, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          return jsonText(
+            buildRoomGraphSummary(kernel, effectiveTenant, { limit })
+          );
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "graph_health",
+    {
+      description: "Quick liveness check for the Trellis room graph (ops + entity counts).",
+      inputSchema: {
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const entities = kernel.listEntities();
+          const byType = {};
+          for (const e of entities) {
+            byType[e.type] = (byType[e.type] ?? 0) + 1;
+          }
+          return jsonText({
+            status: "ok",
+            ops: kernel.readAllOps().length,
+            entities: entities.length,
+            byType,
+            tenantId: effectiveTenant
+          });
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "query_graph",
+    {
+      description: "Run an EQL-S query against the room graph.",
+      inputSchema: {
+        query: z2.string().describe("EQL-S query string"),
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ query, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const parsed = parseSimple(query);
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const result = await kernel.query(parsed);
+          const bindings = hydrateBindings(
+            kernel,
+            result.bindings
+          );
+          return jsonText({
+            bindings,
+            executionTime: result.executionTime
+          });
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "get_node",
+    {
+      description: "Read a single entity by ID.",
+      inputSchema: {
+        id: z2.string().describe("Entity ID"),
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ id, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const entity = kernel.getEntity(id);
+          if (!entity) return text(`Not found: ${id}`);
+          ctx.permissions?.assert(ctx.auth, entity.type, "read", entity);
+          return jsonText(entityRecordToPlain(entity));
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "create_node",
+    {
+      description: "Create a new entity in the room graph. Optionally pass links for relations.",
+      inputSchema: {
+        type: z2.string().describe("Entity type name"),
+        id: z2.string().optional().describe("Optional explicit entity ID"),
+        attributes: z2.record(z2.string(), z2.unknown()).optional().describe("Entity attributes"),
+        links: z2.array(
+          z2.object({
+            attribute: z2.string(),
+            targetEntityId: z2.string()
+          })
+        ).optional().describe("Relation links to create with the entity"),
+        lane: laneSchema,
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ type, id, attributes, links, lane, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        ctx.permissions?.assert(ctx.auth, type, "create");
+        const wctx = writeContext(lane, ctx.auth, ctx.headerLane);
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const entityId2 = id ?? `${type.toLowerCase()}:${crypto.randomUUID()}`;
+          const attrs = { ...attributes ?? {} };
+          if (ctx.auth.userId) attrs.createdBy = ctx.auth.userId;
+          if (effectiveTenant) attrs.tenantId = effectiveTenant;
+          attrs.laneId = wctx.agentId;
+          const result = await kernel.createEntity(
+            entityId2,
+            type,
+            attrs,
+            links,
+            wctx
+          );
+          await ctx.subs.notify(effectiveTenant);
+          const payload = {
+            id: entityId2,
+            op: result.op.hash,
+            lane: wctx.agentId,
+            tenantId: effectiveTenant
+          };
+          auditWrite(
+            kernel,
+            wctx,
+            "create_node",
+            { type, id, attributes, links, lane, tenantId, room },
+            payload,
+            [entityId2]
+          );
+          return jsonText(payload);
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "update_node",
+    {
+      description: "Partial update of an entity attributes.",
+      inputSchema: {
+        id: z2.string().describe("Entity ID"),
+        attributes: z2.record(z2.string(), z2.unknown()).describe("Attributes to merge"),
+        lane: laneSchema,
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ id, attributes, lane, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        const wctx = writeContext(lane, ctx.auth, ctx.headerLane);
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const entity = kernel.getEntity(id);
+          if (!entity) return text(`Not found: ${id}`);
+          ctx.permissions?.assert(ctx.auth, entity.type, "update", entity);
+          await kernel.updateEntity(id, attributes, wctx);
+          await ctx.subs.notify(effectiveTenant);
+          const payload = {
+            id,
+            updated: true,
+            lane: wctx.agentId,
+            tenantId: effectiveTenant
+          };
+          auditWrite(
+            kernel,
+            wctx,
+            "update_node",
+            { id, attributes, lane, tenantId, room },
+            payload,
+            [id]
+          );
+          return jsonText(payload);
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "delete_node",
+    {
+      description: "Delete an entity by ID.",
+      inputSchema: {
+        id: z2.string().describe("Entity ID"),
+        lane: laneSchema,
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ id, lane, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        const wctx = writeContext(lane, ctx.auth, ctx.headerLane);
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const entity = kernel.getEntity(id);
+          if (!entity) return text(`Not found: ${id}`);
+          ctx.permissions?.assert(ctx.auth, entity.type, "delete", entity);
+          await kernel.deleteEntity(id, wctx);
+          await ctx.subs.notify(effectiveTenant);
+          const payload = {
+            id,
+            deleted: true,
+            lane: wctx.agentId,
+            tenantId: effectiveTenant
+          };
+          auditWrite(
+            kernel,
+            wctx,
+            "delete_node",
+            { id, lane, tenantId, room },
+            payload,
+            [id]
+          );
+          return jsonText(payload);
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "create_collection_record",
+    {
+      description: "Create a Playground CollectionRecord row (shows in Collections UI). Sets collectionId to collectionMeta:<slug> so recordBelongsToCollection matches. Optionally ensureCollection to create CollectionMeta when the collection is missing.",
+      inputSchema: {
+        collectionSlug: z2.string().optional().describe("Collection slug (e.g. people, ideas). Required unless collectionId is set."),
+        collectionId: z2.string().optional().describe("Explicit collection id (e.g. collectionMeta:people). Overrides slug."),
+        title: z2.string().min(1).describe("Record title shown in the collection"),
+        body: z2.string().optional().describe("Optional record body / notes"),
+        sortOrder: z2.number().int().optional().describe("Row sort order within the collection"),
+        attributes: z2.record(z2.string(), z2.unknown()).optional().describe("Extra typed fields (status, tags, etc.) merged into the record"),
+        ensureCollection: z2.boolean().optional().describe(
+          "When true, create CollectionMeta with stable id collectionMeta:<slug> if missing."
+        ),
+        collectionTitle: z2.string().optional().describe("Title for CollectionMeta when ensureCollection creates it"),
+        lane: laneSchema,
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({
+      collectionSlug,
+      collectionId,
+      title,
+      body,
+      sortOrder,
+      attributes,
+      ensureCollection,
+      collectionTitle,
+      lane,
+      tenantId,
+      room
+    }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        ctx.permissions?.assert(ctx.auth, "CollectionRecord", "create");
+        const wctx = writeContext(lane, ctx.auth, ctx.headerLane);
+        const resolvedCollectionId = resolveCollectionId({
+          collectionSlug,
+          collectionId
+        });
+        const slug = collectionSlug?.trim() || collectionSlugFromMetaId(resolvedCollectionId) || resolvedCollectionId;
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          let collectionCreated = false;
+          if (ensureCollection) {
+            const existingMeta = kernel.getEntity(resolvedCollectionId);
+            if (!existingMeta) {
+              ctx.permissions?.assert(ctx.auth, "CollectionMeta", "create");
+              const metaAttrs = {
+                title: collectionTitle?.trim() || slug,
+                slug,
+                sortOrder: 0
+              };
+              if (ctx.auth.userId) metaAttrs.createdBy = ctx.auth.userId;
+              if (effectiveTenant) metaAttrs.tenantId = effectiveTenant;
+              metaAttrs.laneId = wctx.agentId;
+              await kernel.createEntity(
+                resolvedCollectionId,
+                "CollectionMeta",
+                metaAttrs,
+                void 0,
+                wctx
+              );
+              collectionCreated = true;
+            }
+          }
+          const recordId = `collectionRecord:${crypto.randomUUID()}`;
+          const recordAttrs = {
+            ...attributes ?? {},
+            collectionId: resolvedCollectionId,
+            title
+          };
+          if (body !== void 0) recordAttrs.body = body;
+          if (sortOrder !== void 0) recordAttrs.sortOrder = sortOrder;
+          if (ctx.auth.userId) recordAttrs.createdBy = ctx.auth.userId;
+          if (effectiveTenant) recordAttrs.tenantId = effectiveTenant;
+          recordAttrs.laneId = wctx.agentId;
+          const result = await kernel.createEntity(
+            recordId,
+            "CollectionRecord",
+            recordAttrs,
+            void 0,
+            wctx
+          );
+          await ctx.subs.notify(effectiveTenant);
+          const payload = {
+            id: recordId,
+            collectionId: resolvedCollectionId,
+            collectionCreated,
+            op: result.op.hash,
+            lane: wctx.agentId,
+            tenantId: effectiveTenant
+          };
+          auditWrite(
+            kernel,
+            wctx,
+            "create_collection_record",
+            {
+              collectionSlug,
+              collectionId,
+              title,
+              body,
+              sortOrder,
+              attributes,
+              ensureCollection,
+              collectionTitle,
+              lane,
+              tenantId,
+              room
+            },
+            payload,
+            collectionCreated ? [recordId, resolvedCollectionId] : [recordId]
+          );
+          return jsonText(payload);
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "link_nodes",
+    {
+      description: "Create a semantic link between two entities (assignedTo, belongsTo, references, dependsOn, \u2026).",
+      inputSchema: {
+        e1: z2.string().describe("Source entity ID"),
+        relation: z2.string().describe("Relation attribute name"),
+        e2: z2.string().describe("Target entity ID"),
+        lane: laneSchema,
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ e1, relation, e2, lane, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        const wctx = writeContext(lane, ctx.auth, ctx.headerLane);
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const source = kernel.getEntity(e1);
+          const target = kernel.getEntity(e2);
+          if (!source) return text(`Not found: ${e1}`);
+          if (!target) return text(`Not found: ${e2}`);
+          ctx.permissions?.assert(ctx.auth, source.type, "update", source);
+          const result = await kernel.addLink(e1, relation, e2, wctx);
+          await ctx.subs.notify(effectiveTenant);
+          const payload = {
+            e1,
+            relation,
+            e2,
+            op: result.op.hash,
+            lane: wctx.agentId,
+            tenantId: effectiveTenant
+          };
+          auditWrite(
+            kernel,
+            wctx,
+            "link_nodes",
+            { e1, relation, e2, lane, tenantId, room },
+            payload,
+            [e1, e2]
+          );
+          return jsonText(payload);
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  return server;
 }
 
+// src/server/mcp-gateway.ts
+var RoomMcpGateway = class {
+  gateway = new StreamableMcpGateway();
+  async handle(req, ctx, auth, tenantId) {
+    const roomCtx = {
+      pool: ctx.pool,
+      permissions: ctx.permissions,
+      subs: ctx.subs,
+      meter: ctx.meter,
+      auth,
+      tenantId,
+      headerLane: req.headers.get("x-trellis-lane"),
+      headerTenant: req.headers.get("x-trellis-tenant")
+    };
+    return this.gateway.handle(req, () => createRoomMcpServer(roomCtx));
+  }
+  async close() {
+    await this.gateway.close();
+  }
+};
+var roomMcpGateway = new RoomMcpGateway();
+
 // src/server/server.ts
 var __moduleDir = import.meta.dir ?? dirname(fileURLToPath(import.meta.url));
 async function startServer(opts) {
@@ -803,6 +1305,7 @@ async function startServerNode(opts) {
   return startNodeServer({
     port,
     fetch: handleHttp,
+    attachPresenceRelay: opts.presenceRelay,
     websocket: {
       open(ws) {
         const id = crypto.randomUUID();
@@ -841,13 +1344,13 @@ async function route(req, url, path, auth, tenantId, ctx) {
   const method = req.method.toUpperCase();
   if (method === "GET" && path === "/__trellis/inspector.js") {
     const candidates = [
-      join2(__moduleDir, "db", "inspector.js"),
+      join(__moduleDir, "db", "inspector.js"),
       // chunk lives in dist/, inspector in dist/db/
-      join2(__moduleDir, "inspector.js")
+      join(__moduleDir, "inspector.js")
       // chunk lives in dist/db/, inspector alongside
     ];
     for (const p of candidates) {
-      if (existsSync2(p)) {
+      if (existsSync(p)) {
         return new Response(readFileSync(p, "utf-8"), {
           headers: { "Content-Type": "application/javascript; charset=utf-8" }
         });
@@ -862,11 +1365,11 @@ async function route(req, url, path, auth, tenantId, ctx) {
   }
   if (method === "GET" && path === "/__trellis/trellis.css") {
     const candidates = [
-      join2(__moduleDir, "db", "trellis.css"),
-      join2(__moduleDir, "trellis.css")
+      join(__moduleDir, "db", "trellis.css"),
+      join(__moduleDir, "trellis.css")
     ];
     for (const p of candidates) {
-      if (existsSync2(p)) {
+      if (existsSync(p)) {
         return new Response(readFileSync(p, "utf-8"), {
           headers: { "Content-Type": "text/css; charset=utf-8" }
         });
@@ -893,13 +1396,38 @@ async function route(req, url, path, auth, tenantId, ctx) {
       headers: { "Content-Type": "text/html; charset=utf-8" }
     });
   }
+  if (path === "/mcp" || path === "/mcp/" || path === "/trellis/mcp" || path === "/trellis/mcp/") {
+    return roomMcpGateway.handle(req, ctx, auth, tenantId);
+  }
+  if (path === "/gateway/mcp" || path === "/gateway/mcp/") {
+    return discoveryMcpGateway.handle(req, {
+      configDir: ".",
+      origin: url.origin
+    });
+  }
+  if (method === "GET" && path === "/.well-known/oauth-protected-resource") {
+    return json(oauthProtectedResourceMetadata(url.origin));
+  }
+  if (method === "GET" && path === "/.well-known/oauth-authorization-server") {
+    return json(oauthAuthorizationServerMetadata(url.origin));
+  }
+  if (method === "GET" && path === "/.well-known/trellis-mcp") {
+    return json(mcpServiceDocument(url.origin, ctx.authConfig));
+  }
   if (method === "GET" && path === "/health") {
     const kernel = await ctx.pool.preload(tenantId);
     const ops = kernel.readAllOps().length;
     return json({
       status: "ok",
       ops,
-      tenants: ctx.pool.activeTenants().length
+      tenants: ctx.pool.activeTenants().length,
+      mcp: "/mcp",
+      mcpSprites: "/trellis/mcp",
+      mcpGateway: "/gateway/mcp",
+      oauth: {
+        protectedResource: "/.well-known/oauth-protected-resource",
+        authorizationServer: "/.well-known/oauth-authorization-server"
+      }
     });
   }
   if (method === "GET" && path === "/admin/usage") {
@@ -917,12 +1445,20 @@ async function route(req, url, path, auth, tenantId, ctx) {
       return handleUpdate(req, id, auth, tenantId, ctx);
     if (method === "DELETE") return handleDelete(id, auth, tenantId, ctx);
   }
+  if (method === "GET" && (path === "/ops" || path === "/ops/")) {
+    return handleListOps(url, tenantId, ctx);
+  }
   if (method === "POST" && path === "/query") {
     return handleQuery(req, auth, tenantId, ctx);
   }
   if (method === "POST" && (path === "/ontologies" || path === "/ontologies/")) {
     return handleCreateOntology(req, auth, tenantId, ctx);
   }
+  const ontologyMatch = path.match(/^\/ontologies\/(.+)$/);
+  if (ontologyMatch && (method === "PATCH" || method === "PUT")) {
+    const id = decodeURIComponent(ontologyMatch[1]);
+    return handleUpdateOntology(req, id, auth, tenantId, ctx);
+  }
   if (method === "POST" && path === "/upload") {
     return handleUpload(req, auth, tenantId, ctx);
   }
@@ -995,6 +1531,42 @@ async function handleDelete(id, auth, tenantId, ctx) {
   await ctx.subs.notify(tenantId);
   return json({ id, deleted: true });
 }
+async function handleListOps(url, tenantId, ctx) {
+  const kind = url.searchParams.get("kind") ?? void 0;
+  const limit = Math.min(parseInt(url.searchParams.get("limit") ?? "100", 10), 500);
+  const offset = parseInt(url.searchParams.get("offset") ?? "0", 10);
+  const kernel = await ctx.pool.preload(tenantId);
+  let ops = kernel.readAllOps();
+  if (kind) {
+    ops = ops.filter((op) => op.kind === kind);
+  }
+  const total = ops.length;
+  const page = ops.slice(offset, offset + limit);
+  return json({
+    data: page.map((op, index) => summarizeKernelOp(op, offset + index)),
+    total,
+    limit,
+    offset
+  });
+}
+function summarizeKernelOp(op, index) {
+  const entityIds = /* @__PURE__ */ new Set();
+  for (const fact of op.facts ?? []) entityIds.add(fact.e);
+  for (const fact of op.deleteFacts ?? []) entityIds.add(fact.e);
+  return {
+    index,
+    hash: op.hash,
+    kind: op.kind,
+    timestamp: op.timestamp,
+    agentId: op.agentId,
+    previousHash: op.previousHash,
+    factCount: op.facts?.length ?? 0,
+    linkCount: op.links?.length ?? 0,
+    deleteFactCount: op.deleteFacts?.length ?? 0,
+    deleteLinkCount: op.deleteLinks?.length ?? 0,
+    entityCount: entityIds.size
+  };
+}
 async function handleList(url, auth, tenantId, ctx) {
   const type = url.searchParams.get("type") ?? void 0;
   const limit = parseInt(url.searchParams.get("limit") ?? "100");
@@ -1111,6 +1683,28 @@ async function handleCreateOntology(req, auth, tenantId, ctx) {
   }
   return json({ id: schema["@id"], registered: true }, 201);
 }
+async function handleUpdateOntology(req, id, auth, tenantId, ctx) {
+  const parsed = await readJsonObject(req, "/ontologies");
+  if (!parsed.ok) return parsed.response;
+  const updates = parsed.data;
+  const kernel = await ctx.pool.preload(tenantId);
+  const existing = kernel.getOntology(id);
+  if (!existing) {
+    return json({ error: `Ontology ${id} not found` }, 404);
+  }
+  if ((existing.tier ?? "user") === "core") {
+    return json({ error: "Core ontologies are immutable" }, 403);
+  }
+  try {
+    kernel.updateOntology(id, updates);
+    recordGraphIo(ctx, tenantId);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return json({ error: "Could not update schema", message: msg }, 400);
+  }
+  const updated = kernel.getOntology(id);
+  return json(updated ?? { id, updated: true });
+}
 async function handleUpload(req, auth, tenantId, ctx) {
   if (!auth.authenticated && ctx.config.apiKey) {
     return json({ error: "Unauthorized" }, 401);
@@ -1348,11 +1942,6 @@ export {
   FULLY_PUBLIC,
   OWNER_ONLY,
   ADMIN_ONLY,
-  resolveUsageTenantId,
-  dayKey,
-  sampleTenantStorage,
-  verifyAdminKey,
-  UsageMeter,
   SubscriptionManager,
   startServer,
   startServerCrossRuntime