@remnic/core 9.22.0 → 9.22.2

package/src/orchestration/workspace-ops.ts

@@ -31,12 +31,23 @@ import type { NamespaceMaintenanceSummary } from "../maintenance/namespace-plann
 import { type PatternReinforcementResult, runPatternReinforcement } from "../maintenance/pattern-reinforcement.js";
 import { evaluateMemoryActionPolicy } from "../memory-action-policy.js";
 import { NamespaceStorageRouter } from "../namespaces/storage.js";
+import { namespaceCollectionName } from "../namespaces/search.js";
 import { parseMemoryActionEligibilityContext } from "../schemas.js";
 import type { SearchBackend } from "../search/port.js";
 import { type AccessTrackingEntry, type MemoryActionEvent, type MemoryFile, type PluginConfig, confidenceTier } from "../types.js";
 import { RECALL_FALLBACK_DIRS } from "../utils/category-dir.js";
 import { assertPathInsideRoot } from "../utils/path-containment.js";
 import { WearablesService } from "../wearables/service.js";
+import { ActivityStore } from "../activity/store.js";
+import { MeetingsBuilder } from "../meetings/build.js";
+import { createMeetingMemoryGenerator, createMeetingMemoryWriter } from "../meetings/memory-gen.js";
+import { createMeetingSummaryDeps } from "../meetings/summary-extractor.js";
+import {
+  ActivityWearablesMeetingsDaySource,
+  storageWearableDayReader,
+  type MeetingsActivityReader,
+} from "../meetings/day-source.js";
+import { MeetingsService } from "../meetings/service.js";
 import { qmdCollectionPathParts, qmdResultPathCandidates } from "./qmd-result-resolver.js";
 import {
   Orchestrator,
@@ -48,6 +59,13 @@ import {
   type DaySummaryGatherOptions,
 } from "../orchestrator.js";
 
+/**
+ * Trailing-edge coalescing window for post-sync meeting rebuilds (issue #1900).
+ * An activity tick and a wearable window sync often land within seconds; this
+ * folds the burst into one build per day.
+ */
+const MEETINGS_BUILD_DEBOUNCE_MS = 5_000;
+
 export interface WorkspaceOpsDeps {
   readonly accessTrackingBuffer: Map<
     string,
@@ -95,7 +113,8 @@ export interface WorkspaceOpsDeps {
   }>;
   readonly storage: StorageManager;
   readonly storageRouter: NamespaceStorageRouter;
-  wearablesServiceInstance: WearablesService | null;
+  readonly wearablesServiceByNamespace: Map<string, WearablesService>;
+  readonly meetingsServiceByNamespace: Map<string, MeetingsService>;
 }
 
 function matchesMemoryPath(candidatePath: string, requestedPath: string, memoryDir: string): boolean {
@@ -635,12 +654,12 @@ export class WorkspaceOpsCoordinator {
    * memory writes stay consistent. Writes are pinned to the same
    * deterministic namespace bulk-import uses.
    */
-  getWearablesService(): WearablesService {
-    if (!this.deps.wearablesServiceInstance) {
-      this.deps.wearablesServiceInstance = new WearablesService({
+  getWearablesService(namespace: string): WearablesService {
+    let service = this.deps.wearablesServiceByNamespace.get(namespace);
+    if (!service) {
+      service = new WearablesService({
         config: this.deps.config.wearables,
-        getStorage: async () =>
-          await this.deps.getStorageForNamespace(this.deps.bulkImportWriteNamespace()),
+        getStorage: async () => await this.deps.getStorageForNamespace(namespace),
         extract: (turns) => this.deps.extraction.extract(turns),
         // Smart memoryMode runs candidates through the SAME extraction
         // judge (cache + defer counters included) the live extraction
@@ -662,7 +681,23 @@ export class WorkspaceOpsCoordinator {
           search: async (query, maxResults) => {
             if (!this.deps.qmd.isAvailable()) return null;
             try {
-              const results = await this.deps.qmd.search(query, undefined, maxResults);
+              // Scope the indexed search to the CALLER namespace's collection so a
+              // non-default caller's transcript_search never returns root or
+              // other-namespace transcripts (#2123). Namespaces off, or the
+              // default/machine-owner namespace rooted at memoryDir, resolve to the
+              // base collection (unchanged); every other namespace to its own.
+              let collection: string | undefined;
+              if (resolveNamespaceCapabilities(this.deps.config).namespaces === true) {
+                const storage = await this.deps.getStorageForNamespace(namespace);
+                const useLegacy =
+                  namespace === this.deps.config.defaultNamespace &&
+                  storage.dir === this.deps.config.memoryDir;
+                collection = namespaceCollectionName(this.deps.config.qmdCollection, namespace, {
+                  defaultNamespace: this.deps.config.defaultNamespace,
+                  useLegacyDefaultCollection: useLegacy,
+                });
+              }
+              const results = await this.deps.qmd.search(query, collection, maxResults);
               return results.map((result) => ({
                 path: result.path,
                 score: result.score,
@@ -683,9 +718,138 @@ export class WorkspaceOpsCoordinator {
           // (#1904, Codex).
           await this.deps.qmd.update();
         },
+        // Meeting tail-step (issue #1900): schedule a debounced meeting rebuild
+        // for every day a wearable sync touched. Wired on the shared service so
+        // BOTH the auto-sync adapter and the manual HTTP/MCP/CLI sync path
+        // (EngramAccessService.wearablesSync -> getWearablesService().sync)
+        // rebuild affected meetings. Gated on meetings.enabled so a sync of
+        // other signals never spins up meeting building; a failure never fails
+        // the sync.
+        onDaysSynced: async (days) => {
+          if (!this.deps.config.meetings.enabled) return;
+          try {
+            const meetings = await this.getMeetingsService(namespace);
+            for (const day of days) meetings.requestBuild(day);
+          } catch (err) {
+            log.warn(
+              `meetings: failed to schedule post-wearable-sync build: ${
+                err instanceof Error ? err.message : String(err)
+              }`,
+            );
+          }
+        },
+      });
+      this.deps.wearablesServiceByNamespace.set(namespace, service);
+    }
+    return service;
+  }
+
+  /**
+   * Lazily-constructed meetings service (issue #1900). Owns the record store,
+   * the store-backed builder (fed by the concrete activity + wearable day
+   * source), and the debounced post-sync build scheduler. Every meeting surface
+   * — CLI, MCP tools, HTTP routes — shares this one instance. Writes are pinned
+   * to the same deterministic namespace bulk-import uses, so meeting records and
+   * episode memories land beside wearable/activity artifacts. Constructing it
+   * touches no disk while `meetings.enabled` is off — every entrypoint gates.
+   */
+  async getMeetingsService(namespace: string): Promise<MeetingsService> {
+    let service = this.deps.meetingsServiceByNamespace.get(namespace);
+    if (!service) {
+      const config = this.deps.config.meetings;
+      const memoryDir = this.deps.config.memoryDir;
+      const storage = await this.deps.getStorageForNamespace(namespace);
+      const store = storage.meetingRecordStore();
+      // Activity is machine-scoped (<memoryDir>/state/activity.sqlite) and is
+      // consumed ONLY by the machine-owner (default) namespace; every other
+      // caller namespace runs audio-only with no activity reader (issue #2123).
+      // A missing/unavailable store degrades to no screen context, never a fail.
+      const activity: MeetingsActivityReader | undefined =
+        namespace !== this.deps.config.defaultNamespace
+          ? undefined
+          : {
+        listSnapshotsForDay: (machine, startUtc, endUtc) => {
+          let activityStore: ActivityStore | undefined;
+          try {
+            activityStore = ActivityStore.open(memoryDir);
+            return activityStore.listSnapshotsForDay(machine, startUtc, endUtc);
+          } catch (err) {
+            log.warn(
+              `meetings: activity snapshots unavailable (${
+                err instanceof Error ? err.message : String(err)
+              }); building without screen context`,
+            );
+            return [];
+          } finally {
+            activityStore?.close();
+          }
+        },
+          };
+      const source = new ActivityWearablesMeetingsDaySource({
+        activity,
+        wearables: storageWearableDayReader(storage),
+        config,
+        timezone: this.deps.config.activity.timezone,
+      });
+      // Production trust-gated summary/fact deps (issue #1900). Built from the
+      // shared LLM clients + the SAME durability-judge closure the wearables
+      // service passes (verdict cache + defer counters included), so meeting
+      // facts inherit identical judge gating — no forked trust/judge/LLM path.
+      // Pure construction (no disk/network); the builder gates on summaryMode.
+      const fallbackLlm = new FallbackLlmClient(
+        this.deps.config.gatewayConfig,
+        fallbackLlmRuntimeContextFromConfig(this.deps.config),
+      );
+      const summary = createMeetingSummaryDeps({
+        localLlm: this.deps.localLlm,
+        fallbackLlm,
+        judgeFacts: (candidates) =>
+          judgeFactDurability(
+            candidates,
+            this.deps.config,
+            this.deps.localLlm,
+            fallbackLlm,
+            this.deps.judgeVerdictCache,
+            this.deps.judgeDeferCounts,
+          ),
+      });
+      const builder = new MeetingsBuilder({
+        source,
+        store,
+        config,
+        hooks: {
+          reindex: async () => {
+            // Meeting records live in the QMD collection root; reindex on change
+            // so `show`/search find them immediately (qmd.update clears its own
+            // result caches). Fired only when records changed; a failure is
+            // surfaced as a build warning, not a hard failure.
+            await this.deps.qmd.update();
+          },
+        },
+        // Memory generation behind the builder seam (issue #1900 decouple): the
+        // deterministic engine depends only on MeetingMemoryGenerator, never on
+        // memory-gen. The generator wraps the same sealed write path the wearables
+        // generator uses — createMeetingMemoryWriter adds the source-scoped
+        // dedup/retire the raw StorageManager lacks — plus the trust-gated
+        // summary/facts layer (extractor + shared durability judge). It gates on
+        // summaryMode internally, so `off` never invokes the extractor.
+        memoryGenerator: createMeetingMemoryGenerator(createMeetingMemoryWriter(storage), config, summary),
+      });
+      service = new MeetingsService({
+        config,
+        store,
+        builder,
+        buildDebounceMs: MEETINGS_BUILD_DEBOUNCE_MS,
+        onBuildError: (date, err) =>
+          log.warn(
+            `meetings: tail-step build for ${date} failed: ${
+              err instanceof Error ? err.message : String(err)
+            }`,
+          ),
       });
+      this.deps.meetingsServiceByNamespace.set(namespace, service);
     }
-    return this.deps.wearablesServiceInstance;
+    return service;
   }
 
   async autoConsolidateIdentity(): Promise<void> {

package/src/orchestrator.ts

@@ -404,6 +404,7 @@ import {
 import { normalizeReplaySessionKey, type ReplayTurn } from "./replay/types.js";
 import type { ImportTurn } from "./bulk-import/types.js";
 import { WearablesService } from "./wearables/service.js";
+import { MeetingsService } from "./meetings/service.js";
 import {
   type AgentPersonaModelConfig,
   confidenceTier,
@@ -875,7 +876,8 @@ export class Orchestrator {
   private readonly consolidationObservers = new Set<
     (observation: ConsolidationObservation) => Promise<void> | void
   >();
-  private wearablesServiceInstance: WearablesService | null = null;
+  private readonly wearablesServiceByNamespace = new Map<string, WearablesService>();
+  private readonly meetingsServiceByNamespace = new Map<string, MeetingsService>();
   private wearablesAutoSyncHandle: { stop(): Promise<void> } | null = null;
   private lastQmdReprobeAtMs = 0;
   private lastFileHygieneRunAtMs = 0;
@@ -955,6 +957,7 @@ export class Orchestrator {
       await this.wearablesAutoSyncHandle.stop();
       this.wearablesAutoSyncHandle = null;
     }
+    for (const svc of this.meetingsServiceByNamespace.values()) svc.dispose();
     await this.maintenanceScheduler.dispose();
     await drainRecallWrites(this);
     // PR #2016 finding 3: drain any deferred lock-timeout hash-index retries so a
@@ -1486,6 +1489,7 @@ export class Orchestrator {
       namespaceSearchRouter: this.namespaceSearchRouter,
       namespaceCatalog: this.namespaceCatalog,
       getStorage: () => this.storage, storageForNamespace: (namespace) => this.storageRouter.storageFor(namespace),
+      onActivitySynced: (summary) => { if (!this.config.meetings.enabled) return; void this.getMeetingsService().then((s) => s.requestBuildForActivitySync(summary.ranAt, this.config.activity.timezone, summary.touchedDates)).catch((err) => log.warn(`meetings: activity tail-step build failed to schedule: ${err instanceof Error ? err.message : String(err)}`)); },
     });
     // Issue #1526: background extraction queue lives on its own coordinator.
     this.extractionQueueCoordinator = new ExtractionQueueCoordinator();
@@ -2091,8 +2095,7 @@ export class Orchestrator {
   }
 
   async maybeRunFileHygiene(): Promise<void> {
-    return this.workspaceOpsCoordinator.maybeRunFileHygiene(
-    );
+    return this.workspaceOpsCoordinator.maybeRunFileHygiene();
   }
 
   async runBootstrap(options: BootstrapOptions): Promise<BootstrapResult> {
@@ -2270,8 +2273,7 @@ export class Orchestrator {
   }
 
   private async validateLocalLlmModel(): Promise<void> {
-    return this.workspaceOpsCoordinator.validateLocalLlmModel(
-    );
+    return this.workspaceOpsCoordinator.validateLocalLlmModel();
   }
 
   private invokeRecall(
@@ -2996,10 +2998,9 @@ export class Orchestrator {
     return this.config.defaultNamespace;
   }
 
-  getWearablesService(): WearablesService {
-    return this.workspaceOpsCoordinator.getWearablesService(
-    );
-  }
+  getWearablesService(namespace: string = this.config.defaultNamespace): WearablesService { return this.workspaceOpsCoordinator.getWearablesService(namespace); }
+
+  getMeetingsService(namespace: string = this.config.defaultNamespace): Promise<MeetingsService> { return this.workspaceOpsCoordinator.getMeetingsService(namespace); }
 
   async ingestBulkImportBatch(
     turns: ImportTurn[],
@@ -3303,8 +3304,7 @@ export class Orchestrator {
   static readonly IDENTITY_CONSOLIDATE_THRESHOLD = 8_000;
 
   private async autoConsolidateIdentity(): Promise<void> {
-    return this.workspaceOpsCoordinator.autoConsolidateIdentity(
-    );
+    return this.workspaceOpsCoordinator.autoConsolidateIdentity();
   }
 
   // Issue #1526: recall result formatting moved to RecallResultFormatter. Thin
@@ -3683,8 +3683,7 @@ export class Orchestrator {
   }
 
   async flushAccessTracking(): Promise<void> {
-    return this.workspaceOpsCoordinator.flushAccessTracking(
-    );
+    return this.workspaceOpsCoordinator.flushAccessTracking();
   }
 
   private async loadSearchResultMemoryMap(

package/src/storage.ts

@@ -75,6 +75,7 @@ import { serializeFaithfulnessFields, parseFaithfulnessField } from "./extractio
 import { createVersion as createPageVersion, type VersioningConfig, type VersionTrigger } from "./page-versioning.js";
 import { isValidTranscriptDate, WEARABLES_DIR_NAME } from "./wearables/day-store.js";
 import { FusionArtifactStore } from "./wearables/fusion/index.js";
+import { MeetingRecordStore } from "./meetings/store.js";
 import {
   SecureStoreLockedError,
   MAGIC_HEADER_SIZE,
@@ -2632,6 +2633,26 @@ export class StorageManager {
     }));
   }
 
+  private _meetingRecordStore?: MeetingRecordStore;
+
+  /**
+   * Meeting record IO (issue #1900). Records live under `<baseDir>/meetings/`
+   * — inside the QMD collection root (full-text searchable) but outside the
+   * memory scan roots — and inherit the same encrypted-at-rest + atomic-write +
+   * symlink-containment semantics as memories via the shared secure IO port.
+   */
+  meetingRecordStore(): MeetingRecordStore {
+    if (this._meetingRecordStore) return this._meetingRecordStore;
+    return (this._meetingRecordStore = new MeetingRecordStore(this.baseDir, {
+      writeFile: (p, c) => this.writeStorageSecureFile(p, c),
+      readFile: (p) => readMaybeEncryptedFile(p, this._secureStoreKey, this.baseDir),
+      readDir: (d) => readdir(d),
+      deleteFile: (p) => unlink(p),
+      realpath: (p) => realpath(p),
+      lstat: (p) => lstat(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() })),
+    }));
+  }
+
   /**
    * Locate a wearable-sourced memory by exact (trimmed) content,
    * ignoring the "[Attributes: ...]" suffix writeMemory appends for

package/src/testing/subjects/meetings-namespace-harness.ts

@@ -0,0 +1,159 @@
+/**
+ * Shared harness for the caller-derived namespace-symmetry surface tests
+ * (issue #2123). Builds a real Orchestrator + EngramAccessService with
+ * namespaces enabled and a fake wearable connector, so wearablesSync +
+ * meetingsBuild exercise the full source-transcript -> detect -> record ->
+ * episode-memory path against per-namespace storage roots.
+ *
+ * Test-only: lives under testing/ so tsup (which entry-points only top-level
+ * src/*.ts) never bundles it. Imported by the two-principal isolation test and
+ * the meetings-namespace lifecycle-matrix subject.
+ */
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { parseConfig } from "../../config.js";
+import { Orchestrator } from "../../orchestrator.js";
+import { EngramAccessService } from "../../access-service.js";
+import { ActivityStore } from "../../activity/store.js";
+import {
+  clearWearableConnectors,
+  registerWearableConnector,
+} from "../../wearables/registry.js";
+import type { WearableSourceConnector } from "../../wearables/types.js";
+
+/** Connector id every harness meeting is sourced from. */
+export const FAKE_WEARABLE_SOURCE = "faketest";
+
+/**
+ * Register a deterministic fake wearable connector that returns one 30-minute
+ * conversation with two distinct non-wearer speakers for whatever day is
+ * requested — enough to fire audio-only meeting detection
+ * (>= audioOnlyMinMinutes, >= 2 distinct non-wearer speakers). Clears the
+ * registry first so repeated harness builds in one test process never collide.
+ */
+export function registerFakeWearableConnector(): void {
+  clearWearableConnectors();
+  registerWearableConnector({
+    id: FAKE_WEARABLE_SOURCE,
+    displayName: "Fake Test Wearable",
+    factory: (): WearableSourceConnector => ({
+      id: FAKE_WEARABLE_SOURCE,
+      displayName: "Fake Test Wearable",
+      async verifyAuth() {
+        return { ok: true };
+      },
+      async fetchConversations(opts) {
+        const day = opts.date;
+        return {
+          conversations: [
+            {
+              id: `conv-${day}`,
+              source: FAKE_WEARABLE_SOURCE,
+              title: "Planning sync",
+              startIso: `${day}T14:00:00.000Z`,
+              endIso: `${day}T14:30:00.000Z`,
+              segments: [
+                { text: "hi team", speakerKey: "me", speakerName: "Me", isWearer: true, startIso: `${day}T14:00:00.000Z`, endIso: `${day}T14:00:30.000Z` },
+                { text: "the quarterly numbers look strong", speakerKey: "alice", speakerName: "Alice", isWearer: false, startIso: `${day}T14:05:00.000Z`, endIso: `${day}T14:06:00.000Z` },
+                { text: "agreed, let us ship it next week", speakerKey: "bob", speakerName: "Bob", isWearer: false, startIso: `${day}T14:20:00.000Z`, endIso: `${day}T14:21:00.000Z` },
+                { text: "sounds good to me", speakerKey: "alice", speakerName: "Alice", isWearer: false, startIso: `${day}T14:29:00.000Z`, endIso: `${day}T14:29:30.000Z` },
+              ],
+            },
+          ],
+          nextCursor: null,
+        };
+      },
+    }),
+  });
+}
+
+/** Namespaces enabled; `pA` owns `nsA`, `pB` owns `nsB` (both NON-default) with
+ *  full read+write; `pWO` can WRITE `nsWO` but is omitted from its readPrincipals
+ *  (write-only, for the meetingsBuild read-authorization regression, #2123); the
+ *  default namespace is writable/readable by any authenticated principal, so
+ *  `op` acts as the machine owner. */
+function makeConfig(memoryDir: string): ReturnType<typeof parseConfig> {
+  return parseConfig({
+    openaiApiKey: "sk-test",
+    memoryDir,
+    workspaceDir: path.join(memoryDir, "workspace"),
+    qmdEnabled: false,
+    embeddingFallbackEnabled: false,
+    chunkingEnabled: false,
+    namespacesEnabled: true,
+    defaultNamespace: "default",
+    namespacePolicies: [
+      { name: "nsA", readPrincipals: ["pA"], writePrincipals: ["pA"] },
+      { name: "nsB", readPrincipals: ["pB"], writePrincipals: ["pB"] },
+      { name: "nsWO", readPrincipals: [], writePrincipals: ["pWO"] },
+    ],
+    wearables: {
+      enabled: true,
+      autoSyncEnabled: false,
+      sources: { [FAKE_WEARABLE_SOURCE]: { enabled: true, memoryMode: "off" } },
+    },
+    meetings: { enabled: true },
+  });
+}
+
+export interface MeetingsNamespaceHarness {
+  readonly orchestrator: Orchestrator;
+  readonly service: EngramAccessService;
+  readonly memoryDir: string;
+  /** Namespace-root storage (records/memories/transcripts live under `.dir`).
+   *  Typed via ReturnType to avoid a direct storage.ts import (ratchet #1533). */
+  storageForNs(namespace: string): ReturnType<Orchestrator["getStorage"]>;
+  /** Seed the machine-global activity store (<memoryDir>/state/activity.sqlite). */
+  seedGlobalActivity(day: string): void;
+  /**
+   * Simulate a restart: tear down the live orchestrator and open a FRESH
+   * Orchestrator + EngramAccessService over the same on-disk memoryDir. Returns
+   * the new service; subsequent `storageForNs`/`cleanup` target the reopened
+   * instance.
+   */
+  reopen(): Promise<EngramAccessService>;
+  cleanup(): Promise<void>;
+}
+
+export async function buildMeetingsNamespaceHarness(): Promise<MeetingsNamespaceHarness> {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-mtg-ns-"));
+  registerFakeWearableConnector();
+  let orchestrator = new Orchestrator(makeConfig(memoryDir));
+  let service = new EngramAccessService(orchestrator);
+  const harness: MeetingsNamespaceHarness = {
+    get orchestrator() {
+      return orchestrator;
+    },
+    get service() {
+      return service;
+    },
+    memoryDir,
+    storageForNs: (namespace) => orchestrator.getStorage(namespace),
+    seedGlobalActivity(day: string): void {
+      const store = ActivityStore.open(memoryDir);
+      try {
+        store.insertSnapshot({ machine: "m1", capturedAtUtc: `${day}T14:10:00.000Z`, app: "zoom.us", windowTitle: "Planning", text: "roadmap review", textSource: "ax", contentHash: `h-${day}-1` });
+        store.insertSnapshot({ machine: "m1", capturedAtUtc: `${day}T14:20:00.000Z`, app: "zoom.us", windowTitle: "Planning", text: "roadmap review 2", textSource: "ax", contentHash: `h-${day}-2` });
+      } finally {
+        store.close();
+      }
+    },
+    async reopen(): Promise<EngramAccessService> {
+      await orchestrator.destroy();
+      registerFakeWearableConnector();
+      orchestrator = new Orchestrator(makeConfig(memoryDir));
+      service = new EngramAccessService(orchestrator);
+      return service;
+    },
+    async cleanup(): Promise<void> {
+      await orchestrator.destroy();
+      clearWearableConnectors();
+      // maxRetries absorbs a rare ENOTEMPTY when a background flush writes a
+      // state file as the recursive walk removes the tree (issue #2123 test).
+      await rm(memoryDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+    },
+  };
+  return harness;
+}

package/src/testing/subjects/meetings-namespace.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Meetings caller-namespace subject for the scenario-matrix harness (issue
+ * #2123). Exercises the caller-derived namespace meeting build/read path: a
+ * principal on a NON-default namespace syncs wearables and builds meetings, and
+ * the record must be readable in that caller namespace while a different
+ * namespace stays empty.
+ *
+ * Most canonical rows probe session/provider-identity/compaction/dedupe
+ * dimensions the meetings-namespace path has no honest analogue for — those are
+ * skipped via `appliesTo` (never faked). The two realized rows map cleanly:
+ *   - explicit-provider-identity → a straight caller-namespace build;
+ *   - restart-reload-recovery    → reopen a fresh service over the same on-disk
+ *     memoryDir and re-read the persisted caller-namespace record.
+ */
+import assert from "node:assert/strict";
+
+import {
+  buildMeetingsNamespaceHarness,
+  type MeetingsNamespaceHarness,
+} from "./meetings-namespace-harness.js";
+import {
+  type LifecycleSubject,
+  type MatrixRow,
+  runLifecycleMatrix,
+} from "../lifecycle-matrix.js";
+
+interface MeetingsNamespaceState {
+  harness: MeetingsNamespaceHarness;
+  date: string;
+}
+
+const CALLER = { namespace: "nsA", authenticatedPrincipal: "pA" } as const;
+const OTHER = { namespace: "nsB", authenticatedPrincipal: "pB" } as const;
+
+async function meetingCountFor(
+  harness: MeetingsNamespaceHarness,
+  scope: { namespace: string; authenticatedPrincipal: string },
+  date: string,
+): Promise<number> {
+  const list = await harness.service.meetingsList(date, scope);
+  return list.days[0]?.meetings.length ?? 0;
+}
+
+const subject: LifecycleSubject<MeetingsNamespaceState> = {
+  appliesTo(row: MatrixRow): boolean | string {
+    if (row.id === "explicit-provider-identity" || row.id === "restart-reload-recovery") {
+      return true;
+    }
+    return `meetings caller-namespace build has no ${row.id} semantics to realize`;
+  },
+
+  async setup(): Promise<MeetingsNamespaceState> {
+    const harness = await buildMeetingsNamespaceHarness();
+    return { harness, date: "2026-06-09" };
+  },
+
+  async exercise(state, row): Promise<void> {
+    await state.harness.service.wearablesSync({ date: state.date, ...CALLER });
+    const build = await state.harness.service.meetingsBuild(state.date, CALLER);
+    assert.equal(build.meetings.length, 1, "caller namespace detects one audio meeting");
+    // restart/reload row: reopen a fresh service over the same on-disk state.
+    if (row.dimensions.restart) {
+      await state.harness.reopen();
+    }
+  },
+
+  async invariants(state): Promise<void> {
+    // Caller namespace still reads its record (survives a restart when reopened).
+    assert.equal(
+      await meetingCountFor(state.harness, CALLER, state.date),
+      1,
+      "caller namespace reads its own meeting record",
+    );
+    // A different namespace never observes the caller's meeting.
+    assert.equal(
+      await meetingCountFor(state.harness, OTHER, state.date),
+      0,
+      "a different namespace stays isolated from the caller's meeting",
+    );
+    const storageOther = await state.harness.storageForNs("nsB");
+    assert.deepEqual(
+      await storageOther.meetingRecordStore().listMeetingDates(),
+      [],
+      "no meeting record physically under the other namespace root",
+    );
+  },
+
+  async teardown(state): Promise<void> {
+    await state.harness.cleanup();
+  },
+};
+
+runLifecycleMatrix("meetings-namespace", subject);

package/src/types.ts

@@ -1218,8 +1218,7 @@ export interface PluginConfig extends BoundedJsonlStateConfig {
    */
   wearables: WearablesConfig;
   activity: ActivityConfig;
-  /**
-   * Retrospective meeting intelligence (issue #1900): detect + fuse meetings
+  /** Retrospective meeting intelligence (issue #1900): detect + fuse meetings
    * from already-ingested audio + screen activity. Disabled by default.
    */
   meetings: MeetingsConfig;

package/src/wearables/cli.ts

@@ -9,6 +9,7 @@
  */
 
 import { WearablesInputError } from "./errors.js";
+import { builtInConnectorPackageSpecifier } from "./registry.js";
 import type { WearablesService } from "./service.js";
 import type { WearableSyncSummary } from "./types.js";
 
@@ -182,7 +183,7 @@ export async function runWearablesCliCommand(
         for (const source of status.sources) {
           io.stdout.write(
             `  ${source.source} (${source.displayName}): ${source.enabled ? "enabled" : "disabled"}, ` +
-              `connector ${source.connectorInstalled ? "installed" : `MISSING — npm install @remnic/connector-${source.source}`}, ` +
+              `connector ${source.connectorInstalled ? "installed" : `MISSING — npm install ${builtInConnectorPackageSpecifier(source.source)}`}, ` +
               `memoryMode ${source.memoryMode}, ` +
               `${source.transcriptDays} transcript day${source.transcriptDays === 1 ? "" : "s"}, ` +
               `last sync ${source.lastSyncAt ?? "never"}\n`,

package/src/wearables/index.ts

@@ -16,6 +16,7 @@ export {
   parseWearablesConfig,
 } from "./config.js";
 export {
+  builtInConnectorPackageSpecifier,
   registerWearableConnector,
   getWearableConnector,
   listWearableConnectors,