@remnic/core 9.21.0 → 9.22.1

package/src/access-mcp.ts

@@ -1,4 +1,8 @@
 import { randomUUID } from "node:crypto";
+import {
+  MCP_ADMIN_OPS_TOOLS,
+  MCP_GIT_CONTEXT_SCHEMA_PROPS_IGNORED,
+} from "./access-mcp-admin-tools.js";
 import { readFile } from "node:fs/promises";
 import type { Readable, Writable } from "node:stream";
 // Importing access-operations registers the pilot boundary operations
@@ -39,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;
 
@@ -78,7 +82,7 @@ type McpRequestOptions = {
   abortSignal?: AbortSignal;
 };
 
-type McpTool = {
+export type McpTool = {
   name: string;
   title?: string;
   description: string;
@@ -184,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",
@@ -192,6 +196,7 @@ const MCP_MIGRATED_OPERATIONS: Readonly<Record<string, OperationName>> = {
   "engram.capsule_import": "capsule_import",
   "engram.capsule_list": "capsule_list",
   "engram.memory_governance_run": "memory_governance_run",
+  "engram.entity_synthesis_run": "entity_synthesis_run",
   "engram.procedure_mining_run": "procedure_mining_run",
   "engram.pattern_reinforcement_run": "pattern_reinforcement_run",
   "engram.procedural_stats": "procedural_stats",
@@ -333,16 +338,6 @@ const MCP_GIT_CONTEXT_SCHEMA_PROPS_SCOPED: Record<string, unknown> = {
       "Optional project tag for non-git project scoping. When no explicit namespace is given, routes this write to the tagged project namespace.",
   },
 };
-const MCP_GIT_CONTEXT_SCHEMA_PROPS_IGNORED: Record<string, unknown> = {
-  cwd: {
-    type: "string",
-    description: "Accepted for MCP client compatibility (git-context auto-injection); ignored by this tool.",
-  },
-  projectTag: {
-    type: "string",
-    description: "Accepted for MCP client compatibility; ignored by this tool.",
-  },
-};
 
 function parseMcpRequest<N extends SchemaName>(schemaName: N, args: Record<string, unknown>): SchemaTypeFor<N> {
   const allowedKeys = STRICT_MCP_SCHEMA_KEYS[schemaName];
@@ -687,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:
@@ -976,137 +854,7 @@ export class EngramMcpServer {
           additionalProperties: false,
         },
       },
-      {
-        name: "engram.capsule_export",
-        description: "Export a portable Remnic capsule archive from the namespace-scoped memory store.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            name: {
-              type: "string",
-              description: "Capsule id (alphanumeric with single dashes, max 64 characters).",
-            },
-            namespace: { type: "string" },
-            since: {
-              type: "string",
-              description: "Only include files modified on or after this ISO 8601 timestamp.",
-            },
-            includeKinds: {
-              type: "array",
-              items: { type: "string" },
-              description: "Optional top-level directory allow-list.",
-            },
-            peerIds: {
-              type: "array",
-              items: { type: "string" },
-              description: "Optional peer id allow-list for the peers/ subtree.",
-            },
-            includeTranscripts: { type: "boolean" },
-            encrypt: { type: "boolean" },
-            ...MCP_GIT_CONTEXT_SCHEMA_PROPS_IGNORED,
-          },
-          required: ["name"],
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.capsule_import",
-        description: "Import a Remnic capsule archive into the namespace-scoped memory store.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            archivePath: {
-              type: "string",
-              description: "Path to a .capsule.json.gz or .capsule.json.gz.enc archive.",
-            },
-            namespace: { type: "string" },
-            mode: {
-              type: "string",
-              enum: ["skip", "overwrite", "fork"],
-              description: "Conflict handling mode. Defaults to skip.",
-            },
-            passphrase: {
-              type: "string",
-              description: "Passphrase for encrypted capsule archives.",
-            },
-            ...MCP_GIT_CONTEXT_SCHEMA_PROPS_IGNORED,
-          },
-          required: ["archivePath"],
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.capsule_list",
-        description: "List capsule archives in the namespace-scoped capsule store.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            namespace: { type: "string" },
-            sessionKey: {
-              type: "string",
-              description:
-                "Optional session key used to derive namespace principal when no trusted transport principal is present.",
-            },
-            ...MCP_GIT_CONTEXT_SCHEMA_PROPS_IGNORED,
-          },
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.memory_governance_run",
-        description: "Run Remnic memory governance in a bounded shadow/apply pass.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            namespace: { type: "string" },
-            mode: { type: "string", enum: ["shadow", "apply"] },
-            recentDays: { type: "number" },
-            maxMemories: { type: "number" },
-            batchSize: { type: "number" },
-          },
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.procedure_mining_run",
-        description:
-          "Run procedural memory mining from causal trajectories (issue #519). Respects procedural.enabled; writes under procedures/ when clusters qualify.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            namespace: { type: "string" },
-          },
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.pattern_reinforcement_run",
-        description:
-          "Run the pattern-reinforcement maintenance job (issue #687 PR 2/4). Clusters duplicate non-procedural memories by normalized content, promotes the most-recent member to canonical, and supersedes the older duplicates. Gated on patternReinforcementEnabled and the patternReinforcementCadenceMs floor — pass force=true to bypass the cadence for an ad-hoc operator run.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            namespace: { type: "string" },
-            force: { type: "boolean" },
-          },
-          additionalProperties: false,
-        },
-      },
-      {
-        // The canonical `remnic.procedural_stats` alias is added automatically
-        // by `withToolAliases` — the dual-naming invariant keeps both names
-        // alive for the legacy surface.
-        name: "engram.procedural_stats",
-        description:
-          "Procedural memory stats (issue #567): counts by status, recent write activity, and the active procedural.* config. Read-only, namespace-scoped.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            namespace: { type: "string" },
-          },
-          additionalProperties: false,
-        },
-      },
+      ...MCP_ADMIN_OPS_TOOLS,
       {
         name: "engram.memory_get",
         description: "Fetch one Remnic memory by id.",

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) }; } });
@@ -175,6 +180,7 @@ defineOperation({ name: "capsule_list", description: "List capsules.", schema: s
 
 // === GOVERNANCE ===
 defineOperation({ name: "memory_governance_run", description: "Run governance.", schema: strictSchema({ namespace: S.str, mode: S.str, recentDays: S.num, maxMemories: S.num, batchSize: S.num }), handler: async (input, ctx) => ({ result: await ctx.service.governanceRun({ namespace: optStr(input.namespace), mode: optStr(input.mode) === "apply" ? "apply" : "shadow", recentDays: optNum(input.recentDays), maxMemories: optNum(input.maxMemories), batchSize: optNum(input.batchSize), authenticatedPrincipal: ctx.authenticatedPrincipal }, ctx.authenticatedPrincipal) }) });
+defineOperation({ name: "entity_synthesis_run", description: "Bulk-drain the entity synthesis queue (issue #2136).", schema: strictSchema({ namespace: S.str, maxEntities: S.num }), handler: async (input, ctx) => ({ result: await ctx.service.entitySynthesisRun({ namespace: optStr(input.namespace), maxEntities: input.maxEntities === undefined ? undefined : (input.maxEntities as number), authenticatedPrincipal: ctx.authenticatedPrincipal }, ctx.authenticatedPrincipal) }) });
 defineOperation({ name: "procedure_mining_run", description: "Run procedure mining.", schema: strictSchema({ namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.procedureMiningRun({ namespace: optStr(input.namespace), authenticatedPrincipal: ctx.authenticatedPrincipal }, ctx.authenticatedPrincipal) }) });
 defineOperation({ name: "pattern_reinforcement_run", description: "Run pattern reinforcement.", schema: strictSchema({ namespace: S.str, force: S.bool }), handler: async (input, ctx) => ({ result: await ctx.service.patternReinforcementRun({ namespace: optStr(input.namespace), force: input.force === true, authenticatedPrincipal: ctx.authenticatedPrincipal }, ctx.authenticatedPrincipal) }) });
 defineOperation({ name: "procedural_stats", description: "Procedural stats.", schema: strictSchema({ namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.procedureStats({ namespace: optStr(input.namespace) }, ctx.authenticatedPrincipal) }) });

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,
@@ -3622,6 +3628,22 @@ export class EngramAccessService {
     );
   }
 
+  async entitySynthesisRun(
+    request: {
+      namespace?: string;
+      maxEntities?: number;
+      authenticatedPrincipal?: string;
+    },
+    principal?: string,
+  ): Promise<{
+    namespace: string;
+    requested: number;
+    processed: number;
+    remaining: number;
+  }> {
+    return this.accessAdminOpsSurface.entitySynthesisRun(request, principal);
+  }
+
   async procedureMiningRun(
     request: {
       namespace?: string;
@@ -5729,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" },
@@ -66,6 +69,7 @@ export const MCP_TOOLS: readonly McpToolEntry[] = [
   { tool: "capsule_import", operation: "capsule_import" },
   { tool: "capsule_list", operation: "capsule_list" },
   { tool: "memory_governance_run", operation: "memory_governance_run" },
+  { tool: "entity_synthesis_run", operation: "entity_synthesis_run" },
   { tool: "procedure_mining_run", operation: "procedure_mining_run" },
   { tool: "pattern_reinforcement_run", operation: "pattern_reinforcement_run" },
   { tool: "procedural_stats", operation: "procedural_stats" },
@@ -189,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" },

package/src/access-wearables-meetings-surface.ts

@@ -0,0 +1,139 @@
+import type { WearablesService } from "./wearables/service.js";
+import type { MeetingsService, MeetingsGetResult, MeetingsListResult } from "./meetings/service.js";
+import type { MeetingsDayBuildSummary } from "./meetings/build.js";
+
+/**
+ * Caller scope threaded into the wearables + meetings access ops so reads and
+ * writes resolve to the CALLER namespace (caller-derived namespace symmetry,
+ * issue #2123), not a machine-wide default. Every field is optional; omitting
+ * all three preserves the operator/CLI default-namespace behavior.
+ */
+export type WearablesMeetingsScope = {
+  sessionKey?: string;
+  authenticatedPrincipal?: string;
+  namespace?: string;
+};
+
+/**
+ * The access-service capabilities the wearables + meetings surface needs.
+ * A structural host (not the class itself) so these ops stay pure delegators
+ * while EngramAccessService keeps its namespace/principal resolvers private.
+ */
+export interface WearablesMeetingsHost {
+  readonly orchestrator: {
+    getWearablesService(namespace: string): WearablesService;
+    getMeetingsService(namespace: string): Promise<MeetingsService>;
+    readonly config: { readonly meetings: { readonly enabled: boolean } };
+  };
+  resolveReadableNamespace(namespace: string | undefined, principal?: string): string;
+  writableNamespaceFor(
+    namespace: string | undefined,
+    sessionKey: string | undefined,
+    authenticatedPrincipal?: string,
+  ): string;
+  resolveRequestPrincipal(sessionKey: string | undefined, authenticatedPrincipal?: string): string | undefined;
+}
+
+/**
+ * Wearables reads resolve to the CALLER namespace via resolveReadableNamespace;
+ * sync writes via writableNamespaceFor; build needs BOTH — it reads
+ * transcripts/records to derive, then writes episodes. Non-default callers are
+ * strictly isolated: no default-ns wearable fallback, no machine-global
+ * activity (machine-scoped, consumed only by the default ns).
+ */
+function wearablesReadService(host: WearablesMeetingsHost, scope?: WearablesMeetingsScope): WearablesService {
+  return host.orchestrator.getWearablesService(
+    host.resolveReadableNamespace(scope?.namespace, host.resolveRequestPrincipal(scope?.sessionKey, scope?.authenticatedPrincipal)),
+  );
+}
+
+export function wearablesStatus(
+  host: WearablesMeetingsHost,
+  scope?: WearablesMeetingsScope,
+): Promise<Awaited<ReturnType<WearablesService["status"]>>> {
+  return wearablesReadService(host, scope).status();
+}
+
+export async function wearablesSync(
+  host: WearablesMeetingsHost,
+  request: { source?: string; date?: string; days?: number; forceMemories?: boolean } & WearablesMeetingsScope,
+): Promise<Awaited<ReturnType<WearablesService["sync"]>>> {
+  const namespace = host.writableNamespaceFor(request.namespace, request.sessionKey, request.authenticatedPrincipal);
+  const summaries = await host.orchestrator
+    .getWearablesService(namespace)
+    .sync({ source: request.source, date: request.date, days: request.days, forceMemories: request.forceMemories });
+  // Manual one-shot sync (HTTP/MCP/CLI): the meeting tail-step arms a
+  // debounced, unref'd timer a short-lived caller exits before firing. Drain
+  // it now so a manual sync's meeting build actually runs before we return.
+  // The long-lived auto-sync daemon does NOT flush — it keeps coalescing.
+  if (host.orchestrator.config.meetings.enabled) {
+    await (await host.orchestrator.getMeetingsService(namespace)).flushBuilds();
+  }
+  return summaries;
+}
+
+export function wearablesTranscriptDay(
+  host: WearablesMeetingsHost,
+  request: { date: string; source?: string } & WearablesMeetingsScope,
+): Promise<Awaited<ReturnType<WearablesService["dayTranscript"]>>> {
+  return wearablesReadService(host, request).dayTranscript(request.date, request.source);
+}
+
+export function wearablesTranscriptSearch(
+  host: WearablesMeetingsHost,
+  request: { query: string; source?: string; from?: string; to?: string; limit?: number } & WearablesMeetingsScope,
+): Promise<Awaited<ReturnType<WearablesService["searchTranscripts"]>>> {
+  return wearablesReadService(host, request).searchTranscripts(request.query, {
+    source: request.source,
+    from: request.from,
+    to: request.to,
+    limit: request.limit,
+  });
+}
+
+export function wearablesTranscriptMemories(
+  host: WearablesMeetingsHost,
+  request: { source?: string; date?: string; limit?: number } & WearablesMeetingsScope,
+): Promise<Awaited<ReturnType<WearablesService["transcriptMemories"]>>> {
+  return wearablesReadService(host, request).transcriptMemories({
+    source: request.source,
+    date: request.date,
+    limit: request.limit,
+  });
+}
+
+// Meetings (issue #1900): thin delegations to the caller-ns MeetingsService.
+export async function meetingsList(
+  host: WearablesMeetingsHost,
+  date?: string,
+  scope?: WearablesMeetingsScope,
+): Promise<MeetingsListResult> {
+  return (
+    await host.orchestrator.getMeetingsService(
+      host.resolveReadableNamespace(scope?.namespace, host.resolveRequestPrincipal(scope?.sessionKey, scope?.authenticatedPrincipal)),
+    )
+  ).meetingsList(date);
+}
+
+export async function meetingsGet(
+  host: WearablesMeetingsHost,
+  id: string,
+  scope?: WearablesMeetingsScope,
+): Promise<MeetingsGetResult> {
+  return (
+    await host.orchestrator.getMeetingsService(
+      host.resolveReadableNamespace(scope?.namespace, host.resolveRequestPrincipal(scope?.sessionKey, scope?.authenticatedPrincipal)),
+    )
+  ).meetingsGet(id);
+}
+
+export async function meetingsBuild(
+  host: WearablesMeetingsHost,
+  date: string,
+  scope?: WearablesMeetingsScope,
+): Promise<MeetingsDayBuildSummary> {
+  const principal = host.resolveRequestPrincipal(scope?.sessionKey, scope?.authenticatedPrincipal);
+  const namespace = host.writableNamespaceFor(scope?.namespace, scope?.sessionKey, scope?.authenticatedPrincipal);
+  host.resolveReadableNamespace(namespace, principal);
+  return (await host.orchestrator.getMeetingsService(namespace)).meetingsBuild(date);
+}