@remnic/core 9.22.0 → 9.22.2

package/src/access-http.test.ts

@@ -2895,3 +2895,66 @@ test("HTTP namespace/writable preflight admits write-scoped tokens and rejects r
     await server.stop();
   }
 });
+
+test("HTTP meetings build enforces the per-principal write rate limit (issue #1937)", async () => {
+  let builds = 0;
+  const service = {
+    meetingsBuild: async (date: string) => {
+      builds += 1;
+      return { enabled: true, date, meetings: [] };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+    writeRateLimitMaxRequests: 1,
+  });
+  const status = await server.start();
+  try {
+    const build = () =>
+      fetch(`http://127.0.0.1:${status.port}/engram/v1/meetings/build`, {
+        method: "POST",
+        headers: { authorization: "Bearer test-token", "content-type": "application/json" },
+        body: JSON.stringify({ date: "2026-03-10" }),
+      });
+    const first = await build();
+    assert.equal(first.status, 200, "the first build is within the write quota");
+    const second = await build();
+    assert.equal(second.status, 429, "the second build exceeds the per-principal write quota");
+    const rateLimited = await second.json() as { code?: string };
+    assert.equal(rateLimited.code, "write_rate_limited");
+    assert.equal(builds, 1, "the rate-limited build never reached the service (no persist/reindex)");
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP meetings get returns 400 (not 500) for a malformed percent-encoded id (issue #1900)", async () => {
+  let called = 0;
+  const service = {
+    meetingsGet: async () => {
+      called += 1;
+      return { enabled: true, found: false, id: "x", record: null };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+  const status = await server.start();
+  try {
+    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/meetings/%E0%A4%A`, {
+      headers: { authorization: "Bearer test-token" },
+    });
+    assert.equal(response.status, 400, "a malformed id is a client error, not an internal 500");
+    const errorBody = await response.json() as { code?: string };
+    assert.equal(errorBody.code, "invalid_request");
+    assert.equal(called, 0, "the malformed id never reached the service");
+  } finally {
+    await server.stop();
+  }
+});

package/src/access-http.ts

@@ -13,11 +13,12 @@ import { EngramAccessForbiddenError } from "./access-errors.js";
 import {
   EngramAccessInputError,
   type EngramAccessService,
+  type WearablesMeetingsScope,
   type EngramAccessMemoryResponse,
   type EngramAccessWriteResponse,
 } from "./access-service.js";
 import { CorrectionContractError } from "./correction/correction-contract.js";
-import { WearablesInputError } from "./wearables/errors.js";
+import { WearablesInputError } from "./wearables/errors.js"; import { respondMeetingsList, respondMeetingsGet, respondMeetingsBuild } from "./meetings/http-glue.js";
 import { EngramMcpServer, MCP_SUPPORTED_PROTOCOL_VERSIONS } from "./access-mcp.js";
 import { validateRequest, type SchemaName, type SchemaTypeFor } from "./access-schema.js";
 import {
@@ -349,9 +350,7 @@ function decodeRelayMissionIdSegment(raw: string): string {
   try {
     return decodeURIComponent(raw);
   } catch {
-    throw new EngramAccessInputError(
-      "missionId path segment is not valid percent-encoded input",
-    );
+    throw new EngramAccessInputError("missionId path segment is not valid percent-encoded input");
   }
 }
 
@@ -713,6 +712,13 @@ export class EngramAccessHttpServer {
     return this.resolveRequestIdentity(req).principal;
   }
 
+  /** Caller scope for wearables/meetings ops (issue #2123): request principal +
+   *  gated namespace + optional sessionKey, so reads/writes resolve to the caller
+   *  namespace instead of the machine default. */
+  private wearablesScope(req: IncomingMessage, namespace?: string, sessionKey?: string): WearablesMeetingsScope {
+    return { authenticatedPrincipal: this.resolveRequestPrincipal(req), namespace: this.resolveNamespace(req, namespace), ...(sessionKey ? { sessionKey } : {}) };
+  }
+
   /** Resolve namespace: only use the explicit body value. Adapter-inferred namespace
    *  is intentionally NOT used as a fallback for REST requests — omitting namespace
    *  should default to the server's global namespace, not silently scope to an adapter. */
@@ -725,11 +731,7 @@ export class EngramAccessHttpServer {
     // and the id-loaded contradiction routes — one rule, every surface. The
     // effective namespace (explicit OR server default) must be a member; fail
     // closed. No-op for unrestricted tokens (no namespaces allow-list).
-    enforceNamespaceAllowList(
-      tokenCapabilityStore.getStore(),
-      namespace,
-      this.service.configRef?.defaultNamespace,
-    );
+    enforceNamespaceAllowList(tokenCapabilityStore.getStore(), namespace, this.service.configRef?.defaultNamespace);
     return namespace;
   }
 
@@ -1351,11 +1353,7 @@ export class EngramAccessHttpServer {
         req,
         namespaceParam && namespaceParam.length > 0 ? namespaceParam : undefined,
       );
-      const payload = await this.service.recallTierExplain(
-        sessionKey,
-        namespace,
-        this.resolveRequestPrincipal(req),
-      );
+      const payload = await this.service.recallTierExplain(sessionKey, namespace, this.resolveRequestPrincipal(req));
       this.respondJson(res, 200, payload);
       return;
     }
@@ -1493,7 +1491,7 @@ export class EngramAccessHttpServer {
       (pathname === "/engram/v1/wearables/status" || pathname === "/remnic/v1/wearables/status")
     ) {
       this.enforceTokenOp("wearables_status"); // boundary dispatch (issue #1525)
-      this.respondJson(res, 200, await this.service.wearablesStatus());
+      this.respondJson(res, 200, await this.service.wearablesStatus(this.wearablesScope(req, parsed.searchParams.get("namespace") ?? undefined, parsed.searchParams.get("sessionKey") ?? undefined)));
       return;
     }
 
@@ -1524,12 +1522,7 @@ export class EngramAccessHttpServer {
         );
       }
       try {
-        const summaries = await this.service.wearablesSync({
-          source,
-          date,
-          days,
-          forceMemories: body.forceMemories === true,
-        });
+        const summaries = await this.service.wearablesSync({ source, date, days, forceMemories: body.forceMemories === true, ...this.wearablesScope(req, optionalQueryString(body.namespace, "namespace"), optionalQueryString(body.sessionKey, "sessionKey")) });
         this.respondJson(res, 200, { summaries });
       } catch (err) {
         if (this.respondWearablesError(res, err)) return;
@@ -1551,10 +1544,7 @@ export class EngramAccessHttpServer {
       }
       const sourceParam = parsed.searchParams.get("source");
       try {
-        const transcripts = await this.service.wearablesTranscriptDay({
-          date,
-          source: sourceParam && sourceParam.length > 0 ? sourceParam : undefined,
-        });
+        const transcripts = await this.service.wearablesTranscriptDay({ date, source: sourceParam && sourceParam.length > 0 ? sourceParam : undefined, ...this.wearablesScope(req, parsed.searchParams.get("namespace") ?? undefined, parsed.searchParams.get("sessionKey") ?? undefined) });
         this.respondJson(res, 200, { transcripts });
       } catch (err) {
         if (this.respondWearablesError(res, err)) return;
@@ -1576,13 +1566,7 @@ export class EngramAccessHttpServer {
         );
       }
       try {
-        const results = await this.service.wearablesTranscriptSearch({
-          query: queryParam,
-          source: nonEmptyQueryParam(parsed.searchParams.get("source")),
-          from: nonEmptyQueryParam(parsed.searchParams.get("from")),
-          to: nonEmptyQueryParam(parsed.searchParams.get("to")),
-          limit: positiveIntQueryParam(parsed.searchParams.get("limit"), "limit"),
-        });
+        const results = await this.service.wearablesTranscriptSearch({ query: queryParam, source: nonEmptyQueryParam(parsed.searchParams.get("source")), from: nonEmptyQueryParam(parsed.searchParams.get("from")), to: nonEmptyQueryParam(parsed.searchParams.get("to")), limit: positiveIntQueryParam(parsed.searchParams.get("limit"), "limit"), ...this.wearablesScope(req, parsed.searchParams.get("namespace") ?? undefined, parsed.searchParams.get("sessionKey") ?? undefined) });
         this.respondJson(res, 200, { results });
       } catch (err) {
         if (this.respondWearablesError(res, err)) return;
@@ -1597,11 +1581,7 @@ export class EngramAccessHttpServer {
     ) {
       this.enforceTokenOp("transcript_memories"); // boundary dispatch (issue #1525)
       try {
-        const memories = await this.service.wearablesTranscriptMemories({
-          source: nonEmptyQueryParam(parsed.searchParams.get("source")),
-          date: nonEmptyQueryParam(parsed.searchParams.get("date")),
-          limit: positiveIntQueryParam(parsed.searchParams.get("limit"), "limit"),
-        });
+        const memories = await this.service.wearablesTranscriptMemories({ source: nonEmptyQueryParam(parsed.searchParams.get("source")), date: nonEmptyQueryParam(parsed.searchParams.get("date")), limit: positiveIntQueryParam(parsed.searchParams.get("limit"), "limit"), ...this.wearablesScope(req, parsed.searchParams.get("namespace") ?? undefined, parsed.searchParams.get("sessionKey") ?? undefined) });
         this.respondJson(res, 200, { memories });
       } catch (err) {
         if (this.respondWearablesError(res, err)) return;
@@ -1610,6 +1590,15 @@ export class EngramAccessHttpServer {
       return;
     }
 
+    if (req.method === "GET" && (pathname === "/engram/v1/meetings" || pathname === "/remnic/v1/meetings")) {
+      this.enforceTokenOp("meetings_list"); await respondMeetingsList(res, this.respondJson.bind(this), this.service, nonEmptyQueryParam(parsed.searchParams.get("date")), this.wearablesScope(req, parsed.searchParams.get("namespace") ?? undefined, parsed.searchParams.get("sessionKey") ?? undefined)); return; }
+    if (req.method === "POST" && (pathname === "/engram/v1/meetings/build" || pathname === "/remnic/v1/meetings/build")) {
+      this.enforceTokenOp("meetings_build"); await respondMeetingsBuild(req, res, this.respondJson.bind(this), this.readJsonBody.bind(this), this.service, { enforceQuota: () => this.ensureWriteRateLimitAvailable(req), recordHit: () => this.recordWriteRateLimitHit(req) }, (ns, sk) => this.wearablesScope(req, ns, sk)); return; }
+    const meetingGetEngram = /^\/engram\/v1\/meetings\/([^/]+)$/.exec(pathname);
+    if (req.method === "GET" && meetingGetEngram) { this.enforceTokenOp("meetings_get"); await respondMeetingsGet(res, this.respondJson.bind(this), this.service, meetingGetEngram[1] ?? "", this.wearablesScope(req, parsed.searchParams.get("namespace") ?? undefined, parsed.searchParams.get("sessionKey") ?? undefined)); return; }
+    const meetingGetRemnic = /^\/remnic\/v1\/meetings\/([^/]+)$/.exec(pathname);
+    if (req.method === "GET" && meetingGetRemnic) { this.enforceTokenOp("meetings_get"); await respondMeetingsGet(res, this.respondJson.bind(this), this.service, meetingGetRemnic[1] ?? "", this.wearablesScope(req, parsed.searchParams.get("namespace") ?? undefined, parsed.searchParams.get("sessionKey") ?? undefined)); return; }
+
     if (req.method === "POST" && pathname === "/engram/v1/observe") {
       this.enforceTokenOp("observe"); // boundary dispatch (issue #1525)
       const body = await this.readValidatedBody(req, "observe");

package/src/access-mcp-output-schemas.ts

@@ -56,6 +56,16 @@ const TOOL_OUTPUT_SCHEMAS: Readonly<Record<string, Record<string, unknown>>> = {
   transcript_day: T_ARRAY,
   transcript_search: T_ARRAY,
   transcript_memories: T_ARRAY,
+  meetings_list: objectSchema({ enabled: T_BOOLEAN, days: T_ARRAY }),
+  meetings_get: objectSchema({ enabled: T_BOOLEAN, found: T_BOOLEAN, id: T_STRING, record: T_NULLABLE_STRING }),
+  meetings_build: objectSchema({
+    date: T_STRING,
+    enabled: T_BOOLEAN,
+    meetings: T_ARRAY,
+    built: T_NUMBER,
+    skipped: T_NUMBER,
+    removed: T_ARRAY,
+  }),
   action_confidence: objectSchema({
     schemaVersion: T_NUMBER,
     decision: T_STRING,

package/src/access-mcp.ts

@@ -43,7 +43,7 @@ import type { RecallDisclosure, RecallPlanMode } from "./types.js";
 import { expandTildePath } from "./utils/path.js";
 
 import { applyToolOutputSchemas } from "./access-mcp-output-schemas.js";
-import { MCP_READ_ONLY_TOOL_SUFFIXES } from "./mcp-read-only-tools.js";
+import { MCP_READ_ONLY_TOOL_SUFFIXES } from "./mcp-read-only-tools.js";import { MEETINGS_MCP_TOOLS } from "./meetings/mcp-tools.js";import { WEARABLES_MCP_TOOLS } from "./wearables/mcp-tools.js";
 import { abortError, isAbortError } from "./abort-error.js";
 type JsonRpcId = string | number | null;
 
@@ -82,7 +82,7 @@ type McpRequestOptions = {
   abortSignal?: AbortSignal;
 };
 
-type McpTool = {
+export type McpTool = {
   name: string;
   title?: string;
   description: string;
@@ -188,7 +188,7 @@ const MCP_MIGRATED_OPERATIONS: Readonly<Record<string, OperationName>> = {
   "engram.wearables_sync": "wearables_sync",
   "engram.transcript_day": "transcript_day",
   "engram.transcript_search": "transcript_search",
-  "engram.transcript_memories": "transcript_memories",
+  "engram.transcript_memories": "transcript_memories", "engram.meetings_list": "meetings_list", "engram.meetings_get": "meetings_get", "engram.meetings_build": "meetings_build",
   "engram.action_confidence": "action_confidence",
   "engram.chatgpt_memory_inspector": "chatgpt_memory_inspector",
   "engram.day_summary": "day_summary",
@@ -682,124 +682,7 @@ export class EngramMcpServer {
           additionalProperties: false,
         },
       },
-      {
-        name: "engram.wearables_status",
-        description:
-          "Status of wearable transcript sources (Limitless / Bee / Omi): configured sources, connector availability, last sync, stored transcript days.",
-        inputSchema: {
-          type: "object",
-          properties: {},
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.wearables_sync",
-        description:
-          "Pull, clean, and store wearable transcripts for one source or all enabled sources; optionally creates trust-gated memories per the source's memoryMode.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            source: {
-              type: "string",
-              description: "Source id (e.g. limitless, bee, omi). Omit to sync every enabled source.",
-            },
-            date: {
-              type: "string",
-              description: "Sync exactly this day (YYYY-MM-DD). Overrides days.",
-            },
-            days: {
-              type: "integer",
-              minimum: 1,
-              maximum: 90,
-              description: "Lookback window in days ending today (default 2).",
-            },
-            forceMemories: {
-              type: "boolean",
-              description: "Re-run memory extraction even for unchanged days.",
-            },
-          },
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.transcript_day",
-        description:
-          "Return the full stored wearable transcript(s) for a day, across all sources or one source, with cross-source overlap hints.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            date: {
-              type: "string",
-              description: "Day to read (YYYY-MM-DD). Required.",
-            },
-            source: {
-              type: "string",
-              description: "Optional source id to scope to (e.g. limitless).",
-            },
-          },
-          required: ["date"],
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.transcript_search",
-        description:
-          "Search stored wearable transcripts. Results carry source + date so callers can pull the full day via engram.transcript_day.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            query: {
-              type: "string",
-              description: "Search query. Required; non-empty.",
-            },
-            source: {
-              type: "string",
-              description: "Optional source id filter.",
-            },
-            from: {
-              type: "string",
-              description: "Optional inclusive start date (YYYY-MM-DD).",
-            },
-            to: {
-              type: "string",
-              description: "Optional inclusive end date (YYYY-MM-DD).",
-            },
-            limit: {
-              type: "integer",
-              minimum: 1,
-              maximum: 50,
-              description: "Maximum results (default 10).",
-            },
-          },
-          required: ["query"],
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.transcript_memories",
-        description:
-          "List memories created from wearable transcripts, filterable by source and/or day. Includes pending_review candidates awaiting approval.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            source: {
-              type: "string",
-              description: "Optional source id filter (e.g. limitless).",
-            },
-            date: {
-              type: "string",
-              description: "Optional transcript day filter (YYYY-MM-DD).",
-            },
-            limit: {
-              type: "integer",
-              minimum: 1,
-              maximum: 200,
-              description: "Maximum results (default 50).",
-            },
-          },
-          additionalProperties: false,
-        },
-      },
+      ...WEARABLES_MCP_TOOLS, ...MEETINGS_MCP_TOOLS,
       {
         name: "engram.action_confidence",
         description:

package/src/access-operations-batch.ts

@@ -140,11 +140,16 @@ defineOperation({ name: "namespace_writable", description: "Read-only preflight:
 } });
 
 // === WEARABLES ===
-defineOperation({ name: "wearables_status", description: "Wearables status.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.wearablesStatus() }) });
-defineOperation({ name: "wearables_sync", description: "Sync wearables.", schema: strictSchema({ source: S.str, date: S.str, days: S.flexNum, forceMemories: S.bool }), handler: async (input, ctx) => ({ result: await ctx.service.wearablesSync({ source: optStr(input.source), date: optStr(input.date), days: typeof input.days === "number" ? input.days : typeof input.days === "string" && Number.isFinite(Number(input.days)) ? Number(input.days) : undefined, forceMemories: optBool(input.forceMemories) }) }) });
-defineOperation({ name: "transcript_day", description: "Transcript for a day.", schema: strictSchema({ date: S.str, source: S.str }), handler: async (input, ctx) => { const d = defStr(input.date, ""); if (d.trim().length === 0) throw new EngramAccessInputError("transcript_day: date is required (YYYY-MM-DD)"); return { result: await ctx.service.wearablesTranscriptDay({ date: d, source: optStr(input.source) }) }; } });
-defineOperation({ name: "transcript_search", description: "Search transcripts.", schema: strictSchema({ query: S.str, source: S.str, from: S.str, to: S.str, limit: S.flexNum }), handler: async (input, ctx) => { const q = defStr(input.query, ""); if (q.trim().length === 0) throw new EngramAccessInputError("transcript_search: query is required"); return { result: await ctx.service.wearablesTranscriptSearch({ query: q, source: optStr(input.source), from: optStr(input.from), to: optStr(input.to), limit: typeof input.limit === "number" ? input.limit : typeof input.limit === "string" && Number.isFinite(Number(input.limit)) ? Number(input.limit) : undefined }) }; } });
-defineOperation({ name: "transcript_memories", description: "Transcript memories.", schema: strictSchema({ source: S.str, date: S.str, limit: S.flexNum }), handler: async (input, ctx) => ({ result: await ctx.service.wearablesTranscriptMemories({ source: optStr(input.source), date: optStr(input.date), limit: typeof input.limit === "number" ? input.limit : typeof input.limit === "string" && Number.isFinite(Number(input.limit)) ? Number(input.limit) : undefined }) }) });
+defineOperation({ name: "wearables_status", description: "Wearables status.", schema: strictSchema({ namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.wearablesStatus({ authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey) }) }) });
+defineOperation({ name: "wearables_sync", description: "Sync wearables.", schema: strictSchema({ source: S.str, date: S.str, days: S.flexNum, forceMemories: S.bool, namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.wearablesSync({ source: optStr(input.source), date: optStr(input.date), days: typeof input.days === "number" ? input.days : typeof input.days === "string" && Number.isFinite(Number(input.days)) ? Number(input.days) : undefined, forceMemories: optBool(input.forceMemories), authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey) }) }) });
+defineOperation({ name: "transcript_day", description: "Transcript for a day.", schema: strictSchema({ date: S.str, source: S.str, namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => { const d = defStr(input.date, ""); if (d.trim().length === 0) throw new EngramAccessInputError("transcript_day: date is required (YYYY-MM-DD)"); return { result: await ctx.service.wearablesTranscriptDay({ date: d, source: optStr(input.source), authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey) }) }; } });
+defineOperation({ name: "transcript_search", description: "Search transcripts.", schema: strictSchema({ query: S.str, source: S.str, from: S.str, to: S.str, limit: S.flexNum, namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => { const q = defStr(input.query, ""); if (q.trim().length === 0) throw new EngramAccessInputError("transcript_search: query is required"); return { result: await ctx.service.wearablesTranscriptSearch({ query: q, source: optStr(input.source), from: optStr(input.from), to: optStr(input.to), limit: typeof input.limit === "number" ? input.limit : typeof input.limit === "string" && Number.isFinite(Number(input.limit)) ? Number(input.limit) : undefined, authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey) }) }; } });
+defineOperation({ name: "transcript_memories", description: "Transcript memories.", schema: strictSchema({ source: S.str, date: S.str, limit: S.flexNum, namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.wearablesTranscriptMemories({ source: optStr(input.source), date: optStr(input.date), limit: typeof input.limit === "number" ? input.limit : typeof input.limit === "string" && Number.isFinite(Number(input.limit)) ? Number(input.limit) : undefined, authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey) }) }) });
+
+// === MEETINGS (issue #1900) ===
+defineOperation({ name: "meetings_list", description: "List stored meeting records (all days, or one day).", schema: strictSchema({ date: S.str, namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => { const d = optStr(input.date); return { result: await ctx.service.meetingsList(d && d.length > 0 ? d : undefined, { authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey) }) }; } });
+defineOperation({ name: "meetings_get", description: "Get a stored meeting record by id.", schema: strictSchema({ id: S.str, namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.meetingsGet(reqStr(input.id, "id"), { authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey) }) }) });
+defineOperation({ name: "meetings_build", description: "Detect + fuse + store a day's meetings.", schema: strictSchema({ date: S.str, namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.meetingsBuild(reqStr(input.date, "date"), { authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey) }) }) });
 
 // === ACTION CONFIDENCE + INSPECTOR + CAPSULE ===
 defineOperation({ name: "action_confidence", description: "Action confidence.", schema: strictSchema({ intendedAction: S.str, confidence: S.num, risk: S.str, contextReadiness: S.str, currentContextScopes: S.strArr, userRules: z.array(z.unknown()).optional(), retrievedMemories: z.array(z.unknown()).optional() }), handler: async (input, ctx) => { const req: Record<string, unknown> = {}; if (input.intendedAction !== undefined) req.intendedAction = optStr(input.intendedAction); if (input.confidence !== undefined) req.confidence = optNum(input.confidence); if (input.risk !== undefined) req.risk = optStr(input.risk) as "low" | "medium" | "high" | "irreversible" | "restricted" | undefined; if (input.contextReadiness !== undefined) req.contextReadiness = optStr(input.contextReadiness) as "none" | "partial" | "sufficient" | undefined; if (input.currentContextScopes !== undefined) req.currentContextScopes = optStrArr(input.currentContextScopes); if (input.userRules !== undefined) req.userRules = input.userRules; if (input.retrievedMemories !== undefined) req.retrievedMemories = input.retrievedMemories; return { result: await ctx.service.actionConfidence(req) }; } });

package/src/access-service.ts

@@ -107,6 +107,12 @@ import { displayErrorDetail } from "./runtime/better-sqlite.js";
 import type { PatternReinforcementResult } from "./maintenance/pattern-reinforcement.js";
 import type { LiveConnectorsRunSummary } from "./live-connectors-runner.js";
 import type { WearablesService } from "./wearables/service.js";
+import type { MeetingsGetResult, MeetingsListResult } from "./meetings/service.js";
+import type { MeetingsDayBuildSummary } from "./meetings/build.js";
+
+import * as wearablesMeetings from "./access-wearables-meetings-surface.js";
+import type { WearablesMeetingsHost, WearablesMeetingsScope } from "./access-wearables-meetings-surface.js";
+export type { WearablesMeetingsScope };
 import {
   computeProcedureStats,
   type ProcedureStatsReport,
@@ -5745,60 +5751,51 @@ export class EngramAccessService {
   // behavior and validation (renderer-sharing rule).
   // ---------------------------------------------------------------------------
 
-  async wearablesStatus(): Promise<
-    Awaited<ReturnType<WearablesService["status"]>>
-  > {
-    return this.orchestrator.getWearablesService().status();
+  /**
+   * Structural host bound per call so the wearables + meetings ops (issue
+   * #2123) delegate to the pure surface module while the namespace/principal
+   * resolvers stay private.
+   */
+  private get wmHost(): WearablesMeetingsHost {
+    return {
+      orchestrator: this.orchestrator,
+      resolveReadableNamespace: this.resolveReadableNamespace.bind(this),
+      writableNamespaceFor: this.writableNamespaceFor.bind(this),
+      resolveRequestPrincipal: this.resolveRequestPrincipal.bind(this),
+    };
   }
 
-  async wearablesSync(request: {
-    source?: string;
-    date?: string;
-    days?: number;
-    forceMemories?: boolean;
-  }): Promise<Awaited<ReturnType<WearablesService["sync"]>>> {
-    return this.orchestrator.getWearablesService().sync({
-      source: request.source,
-      date: request.date,
-      days: request.days,
-      forceMemories: request.forceMemories,
-    });
+  async wearablesStatus(scope?: WearablesMeetingsScope): Promise<Awaited<ReturnType<WearablesService["status"]>>> {
+    return wearablesMeetings.wearablesStatus(this.wmHost, scope);
   }
 
-  async wearablesTranscriptDay(request: {
-    date: string;
-    source?: string;
-  }): Promise<Awaited<ReturnType<WearablesService["dayTranscript"]>>> {
-    return this.orchestrator
-      .getWearablesService()
-      .dayTranscript(request.date, request.source);
+  async wearablesSync(request: { source?: string; date?: string; days?: number; forceMemories?: boolean } & WearablesMeetingsScope): Promise<Awaited<ReturnType<WearablesService["sync"]>>> {
+    return wearablesMeetings.wearablesSync(this.wmHost, request);
   }
 
-  async wearablesTranscriptSearch(request: {
-    query: string;
-    source?: string;
-    from?: string;
-    to?: string;
-    limit?: number;
-  }): Promise<Awaited<ReturnType<WearablesService["searchTranscripts"]>>> {
-    return this.orchestrator.getWearablesService().searchTranscripts(request.query, {
-      source: request.source,
-      from: request.from,
-      to: request.to,
-      limit: request.limit,
-    });
+  async wearablesTranscriptDay(request: { date: string; source?: string } & WearablesMeetingsScope): Promise<Awaited<ReturnType<WearablesService["dayTranscript"]>>> {
+    return wearablesMeetings.wearablesTranscriptDay(this.wmHost, request);
   }
 
-  async wearablesTranscriptMemories(request: {
-    source?: string;
-    date?: string;
-    limit?: number;
-  }): Promise<Awaited<ReturnType<WearablesService["transcriptMemories"]>>> {
-    return this.orchestrator.getWearablesService().transcriptMemories({
-      source: request.source,
-      date: request.date,
-      limit: request.limit,
-    });
+  async wearablesTranscriptSearch(request: { query: string; source?: string; from?: string; to?: string; limit?: number } & WearablesMeetingsScope): Promise<Awaited<ReturnType<WearablesService["searchTranscripts"]>>> {
+    return wearablesMeetings.wearablesTranscriptSearch(this.wmHost, request);
+  }
+
+  async wearablesTranscriptMemories(request: { source?: string; date?: string; limit?: number } & WearablesMeetingsScope): Promise<Awaited<ReturnType<WearablesService["transcriptMemories"]>>> {
+    return wearablesMeetings.wearablesTranscriptMemories(this.wmHost, request);
+  }
+
+  // Meetings (issue #1900): thin delegations to the caller-ns MeetingsService.
+  async meetingsList(date?: string, scope?: WearablesMeetingsScope): Promise<MeetingsListResult> {
+    return wearablesMeetings.meetingsList(this.wmHost, date, scope);
+  }
+
+  async meetingsGet(id: string, scope?: WearablesMeetingsScope): Promise<MeetingsGetResult> {
+    return wearablesMeetings.meetingsGet(this.wmHost, id, scope);
+  }
+
+  async meetingsBuild(date: string, scope?: WearablesMeetingsScope): Promise<MeetingsDayBuildSummary> {
+    return wearablesMeetings.meetingsBuild(this.wmHost, date, scope);
   }
 
   // ── Admin console surfaces (issue #1502) ────────────────────────────────

package/src/access-surface-catalog.ts

@@ -59,6 +59,9 @@ export const MCP_TOOLS: readonly McpToolEntry[] = [
   { tool: "transcript_day", operation: "transcript_day" },
   { tool: "transcript_search", operation: "transcript_search" },
   { tool: "transcript_memories", operation: "transcript_memories" },
+  { tool: "meetings_list", operation: "meetings_list" },
+  { tool: "meetings_get", operation: "meetings_get" },
+  { tool: "meetings_build", operation: "meetings_build" },
   { tool: "action_confidence", operation: "action_confidence" },
   { tool: "chatgpt_memory_inspector", operation: "chatgpt_memory_inspector" },
   { tool: "day_summary", operation: "day_summary" },
@@ -190,6 +193,9 @@ export const HTTP_ROUTES: readonly HttpRouteEntry[] = [
   { method: "GET", pathname: "/engram/v1/wearables/transcript", operation: "transcript_day" },
   { method: "GET", pathname: "/engram/v1/wearables/transcripts/search", operation: "transcript_search" },
   { method: "GET", pathname: "/engram/v1/wearables/memories", operation: "transcript_memories" },
+  { method: "GET", pathname: "/engram/v1/meetings", operation: "meetings_list" },
+  { method: "POST", pathname: "/engram/v1/meetings/build", operation: "meetings_build" },
+  { method: "GET", pathname: "/engram/v1/meetings/:id", operation: "meetings_get" },
   { method: "POST", pathname: "/engram/v1/observe", operation: "observe" },
   { method: "POST", pathname: "/engram/v1/lcm/search", operation: "lcm_search" },
   { method: "POST", pathname: "/engram/v1/lcm/compaction/flush", operation: "lcm_compaction_flush" },