@remnic/core 9.22.0 → 9.22.2

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);
+}

package/src/activity/digest.ts

@@ -45,7 +45,7 @@ export function activityDigestPath(memoryDir: string, date: string): string {
 
 // ── DST-aware local-day window ──────────────────────────────────────────────
 
-function timezoneOffsetIso(instant: Date, timezone: string): string {
+export function timezoneOffsetIso(instant: Date, timezone: string): string {
   const parts = new Intl.DateTimeFormat("en-US", {
     timeZone: timezone,
     timeZoneName: "longOffset",

package/src/activity/runner.test.ts

@@ -453,3 +453,40 @@ test("an older-day failure does not starve newer dates in a multi-day window", a
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
+
+test("runActivitySyncOnce reports every local date that gained snapshots (issue #1900 backfill)", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    let calls = 0;
+    const client: ActivitySourceClient = {
+      machineLabel: "workstation-a",
+      async verify() {
+        return { ok: true };
+      },
+      async fetchSnapshots() {
+        calls += 1;
+        // Dates are processed oldest-first: day 1 = 2026-07-21, day 2 = 2026-07-22.
+        const capturedAtUtc = calls === 1 ? "2026-07-21T14:00:00.000Z" : "2026-07-22T14:00:00.000Z";
+        return { snapshots: [snapshot({ capturedAtUtc, contentHash: `hash-${calls}` })], nextCursor: null };
+      },
+    };
+
+    const summary = await runActivitySyncOnce({
+      config: enabledConfig({ syncDays: 2 }),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: () => client,
+    });
+
+    assert.deepEqual(
+      summary.touchedDates,
+      ["2026-07-21", "2026-07-22"],
+      "both days that inserted snapshots are reported so meetings rebuild the older day too",
+    );
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/activity/runner.ts

@@ -60,6 +60,12 @@ export interface ActivitySyncRunSummary {
   reindexErrorCount: number;
   totalInserted: number;
   results: ActivitySourceRunItem[];
+  /**
+   * Local dates (YYYY-MM-DD, in the sync timezone) that gained new snapshots
+   * this run — a backfill/rolling window can touch several. Meetings rebuild
+   * uses this so a change to an OLDER day rebuilds that day, not just today.
+   */
+  touchedDates: string[];
 }
 
 export interface ActivitySyncRunOptions {
@@ -148,6 +154,7 @@ export async function runActivitySyncOnce(options: ActivitySyncRunOptions): Prom
       reindexErrorCount: 0,
       totalInserted: 0,
       results: [],
+      touchedDates: [],
     };
   }
 
@@ -163,6 +170,9 @@ export async function runActivitySyncOnce(options: ActivitySyncRunOptions): Prom
   const ownStore = options.store === undefined;
   const store = options.store ?? ActivityStore.open(options.memoryDir);
   const results: ActivitySourceRunItem[] = [];
+  // Local dates that gained new snapshots this run (any source). Drives the
+  // meetings rebuild fan-out so a backfilled OLDER day is rebuilt too.
+  const touchedDates = new Set<string>();
 
   try {
     for (const sourceConfig of options.config.sources) {
@@ -191,6 +201,7 @@ export async function runActivitySyncOnce(options: ActivitySyncRunOptions): Prom
             });
             item.fetched += result.fetched;
             item.inserted += result.inserted;
+            if (result.inserted > 0) touchedDates.add(date);
             item.duplicates += result.duplicates;
             if (result.digestWritten) item.digestsWritten += 1;
             item.cursor = result.cursor;
@@ -233,5 +244,6 @@ export async function runActivitySyncOnce(options: ActivitySyncRunOptions): Prom
     reindexErrorCount: results.filter((item) => item.reindexError !== undefined).length,
     totalInserted: results.reduce((sum, item) => sum + item.inserted, 0),
     results,
+    touchedDates: [...touchedDates].sort(),
   };
 }

package/src/activity/scheduler.test.ts

@@ -50,6 +50,7 @@ const SUMMARY: ActivitySyncRunSummary = {
   reindexErrorCount: 0,
   totalInserted: 0,
   results: [],
+  touchedDates: [],
 };
 
 function enabledConfig(): ActivityConfig {

package/src/activity/sync-registration.ts

@@ -50,6 +50,13 @@ export interface ActivitySyncRegistrarDeps {
   readonly getQmd: () => ActivityIndexRefresher;
   /** Debounced/singleflighted QMD retry used when a tick's reindex fails. */
   readonly requestReindexRetry: () => void;
+  /**
+   * Tail step (issue #1900): observe a completed sync tick so a dependent
+   * subsystem (meeting building) can rebuild the affected day(s). Fired only
+   * after a durable tick and never after teardown. Optional; omitted by hosts
+   * that do not build meetings.
+   */
+  readonly onSynced?: (summary: ActivitySyncRunSummary) => void;
   /** Scheduler factory (injectable for tests); defaults to the real scheduler. */
   readonly createScheduler?: (options: ActivitySyncSchedulerOptions) => ActivitySyncSchedulerLike;
 }
@@ -111,6 +118,12 @@ export class ActivitySyncRegistrar {
             );
             this.deps.requestReindexRetry();
           }
+          // Tail step: a durable tick that ingested snapshots may have changed a
+          // meeting's screen context; notify the dependent builder. Never after
+          // teardown.
+          if (summary.enabled && summary.totalInserted > 0 && !this.disposed) {
+            this.deps.onSynced?.(summary);
+          }
         },
       });
       this.scheduler = scheduler;

package/src/cli/meetings-commands.ts

@@ -0,0 +1,70 @@
+/**
+ * Meetings command group (issue #1900) — extracted from cli.ts so the surface
+ * file stays under its structural ceiling. Mirrors the
+ * registerResearchStatusCommands / registerCreationLedgerCommands seam: a single
+ * registrar wires the `meetings` command (list / show / build) on the parent
+ * `engram` command.
+ *
+ * Every subcommand forwards to the shared runner in meetings/cli.ts so this host
+ * CLI and the standalone `remnic` CLI never fork behavior or formatting.
+ * Behaviour is identical to the inline registration it replaces — the
+ * cli-command-surface contract tests guard against silent drift.
+ */
+
+import type { Orchestrator } from "../orchestrator.js";
+import type { CliCommand } from "../cli.js";
+import { runMeetingsCliCommand } from "../meetings/cli.js";
+
+export function registerMeetingsCommands(cmd: CliCommand, orchestrator: Orchestrator): void {
+  const meetingsCmd = cmd
+    .command("meetings")
+    .description(
+      "Retrospective meetings: list records, show one, build (detect + fuse + store) a day",
+    );
+  const forwardMeetings = async (argv: string[]): Promise<void> => {
+    const service = await orchestrator.getMeetingsService();
+    const code = await runMeetingsCliCommand(
+      { store: service.store, builder: service.builder, config: service.config },
+      argv,
+      { stdout: process.stdout, stderr: process.stderr },
+    );
+    if (code !== 0) process.exitCode = code;
+  };
+
+  meetingsCmd
+    .command("list")
+    .description("List meeting records (all days, or one day)")
+    .option("--date <date>", "Day to list (YYYY-MM-DD)")
+    .option("--json", "JSON output")
+    .action(async (...args: unknown[]) => {
+      const options = (args[0] ?? {}) as Record<string, unknown>;
+      await forwardMeetings([
+        "list",
+        ...(typeof options.date === "string" && options.date.length > 0
+          ? ["--date", options.date]
+          : []),
+        ...(options.json === true ? ["--json"] : []),
+      ]);
+    });
+
+  meetingsCmd
+    .command("show <meeting-id>")
+    .description("Print a stored meeting record")
+    .action(async (...args: unknown[]) => {
+      await forwardMeetings(["show", String(args[0] ?? "")]);
+    });
+
+  meetingsCmd
+    .command("build")
+    .description("Detect + fuse + store the day's meetings")
+    .option("--date <date>", "Day to build (YYYY-MM-DD)")
+    .option("--json", "JSON output")
+    .action(async (...args: unknown[]) => {
+      const options = (args[0] ?? {}) as Record<string, unknown>;
+      await forwardMeetings([
+        "build",
+        ...(typeof options.date === "string" ? ["--date", options.date] : []),
+        ...(options.json === true ? ["--json"] : []),
+      ]);
+    });
+}

package/src/cli.ts

@@ -13,6 +13,7 @@ import { ThreadingManager } from "./threading.js";
 import { bumpMemoryCorpusVersionForDir } from "./memory-corpus-version.js";
 import { utcDayRange } from "./transcript.js";
 import { runWearablesCliCommand } from "./wearables/cli.js";
+import { registerMeetingsCommands } from "./cli/meetings-commands.js";
 import { registerResearchStatusCommands } from "./cli/research-status-commands.js";
 import { registerCreationLedgerCommands } from "./cli/creation-ledger-commands.js";
 import type {
@@ -5197,11 +5198,11 @@ export function registerCli(
             "Wearable transcript sources (Limitless / Bee / Omi): sync, transcripts, search, speakers, corrections",
           );
         const forwardWearables = async (argv: string[]): Promise<void> => {
-          const code = await runWearablesCliCommand(
-            orchestrator.getWearablesService(),
-            argv,
-            { stdout: process.stdout, stderr: process.stderr },
-          );
+          const io = { stdout: process.stdout, stderr: process.stderr };
+          const code = await runWearablesCliCommand(orchestrator.getWearablesService(), argv, io);
+          if (argv[0] === "sync" && code === 0 && orchestrator.config.meetings.enabled) { // drain debounced build
+            await (await orchestrator.getMeetingsService()).flushBuilds();
+          }
           if (code !== 0) process.exitCode = code;
         };
         const stringOpt = (options: Record<string, unknown>, key: string, flag: string): string[] =>
@@ -6230,7 +6231,7 @@ export function registerCli(
 
       registerResearchStatusCommands(cmd, orchestrator);
 
-      registerCreationLedgerCommands(cmd, orchestrator);
+      registerCreationLedgerCommands(cmd, orchestrator); registerMeetingsCommands(cmd, orchestrator);
 
       cmd
         .command("trust-zone-promote")

package/src/extraction-error-classification.ts

@@ -0,0 +1,52 @@
+import type { ExtractionFailureClass } from "./types.js";
+import { isTransientHttpError } from "./connectors/live/transient-errors.js";
+
+/**
+ * Read a numeric HTTP status off a thrown error without re-implementing the
+ * shared transient classifier. Uses `in`/typeof narrowing (no inline casts).
+ */
+function httpStatusFromError(err: unknown): number | undefined {
+  if (!err || typeof err !== "object") return undefined;
+  if ("status" in err && typeof err.status === "number" && Number.isFinite(err.status)) return err.status;
+  if ("statusCode" in err && typeof err.statusCode === "number" && Number.isFinite(err.statusCode)) {
+    return err.statusCode;
+  }
+  return undefined;
+}
+
+/**
+ * Map a thrown extraction error to a coarse failure class for the retry/breaker
+ * layer. 401/403 → `auth_config` (misconfigured provider, open the breaker);
+ * transient (429/5xx/network, per the shared `isTransientHttpError`) → back off;
+ * anything else defaults to `provider_retryable` (fail-open toward retry, but
+ * capped by the per-fingerprint attempt budget). Never throws.
+ */
+export function classifyExtractionThrownError(err: unknown): ExtractionFailureClass {
+  try {
+    const status = httpStatusFromError(err);
+    if (status === 401 || status === 403) return "auth_config";
+    if (isTransientHttpError(err)) return "provider_retryable";
+    return "provider_retryable";
+  } catch {
+    return "provider_retryable";
+  }
+}
+
+/**
+ * Map the gateway fallback's discriminated parse-failure reason to a coarse
+ * extraction failure class. "no models configured" is an auth/config problem;
+ * an HTTP/transport failure backs off; an unparseable-but-present response is a
+ * genuine empty-parse.
+ */
+export function classifyFallbackParseFailure(
+  reason: "no_models" | "empty" | "http_error",
+): ExtractionFailureClass {
+  switch (reason) {
+    case "no_models":
+      return "auth_config";
+    case "http_error":
+      return "provider_retryable";
+    case "empty":
+      return "parse_empty";
+  }
+}

package/src/extraction.ts

@@ -40,7 +40,8 @@ import { normalizeProcedureSteps } from "./procedural/procedure-types.js";
 import { normalizeReasoningTrace } from "./reasoning-trace-types.js";
 import { looksLikeMechanicalTelemetryTranscript } from "./telemetry-transcript.js";
 import { buildFactProvenance, type ProvenanceTurnInput } from "./provenance.js";
-import { isTransientHttpError } from "./connectors/live/transient-errors.js";
+import { classifyExtractionThrownError, classifyFallbackParseFailure } from "./extraction-error-classification.js";
+export { classifyExtractionThrownError, classifyFallbackParseFailure } from "./extraction-error-classification.js";
 import { resolvePipelineProcessingCapabilities } from "./capabilities.js";
 import { resolveMemoryLifecycleCapabilities,
   resolveLocalLlmCapabilities,resolveRecallAuxiliaryCapabilities } from "./capabilities.js";
@@ -50,55 +51,6 @@ type ExtractedFactResult = ExtractionResult["facts"][number];
 type ExtractedEntityResult = ExtractionResult["entities"][number];
 type ExtractedRelationshipResult = NonNullable<ExtractionResult["relationships"]>[number];
 
-/**
- * Read a numeric HTTP status off a thrown error without re-implementing the
- * shared transient classifier. Uses `in`/typeof narrowing (no inline casts).
- */
-function httpStatusFromError(err: unknown): number | undefined {
-  if (!err || typeof err !== "object") return undefined;
-  if ("status" in err && typeof err.status === "number" && Number.isFinite(err.status)) return err.status;
-  if ("statusCode" in err && typeof err.statusCode === "number" && Number.isFinite(err.statusCode)) {
-    return err.statusCode;
-  }
-  return undefined;
-}
-
-/**
- * Map a thrown extraction error to a coarse failure class for the retry/breaker
- * layer. 401/403 → `auth_config` (misconfigured provider, open the breaker);
- * transient (429/5xx/network, per the shared `isTransientHttpError`) → back off;
- * anything else defaults to `provider_retryable` (fail-open toward retry, but
- * capped by the per-fingerprint attempt budget). Never throws.
- */
-export function classifyExtractionThrownError(err: unknown): ExtractionFailureClass {
-  try {
-    const status = httpStatusFromError(err);
-    if (status === 401 || status === 403) return "auth_config";
-    if (isTransientHttpError(err)) return "provider_retryable";
-    return "provider_retryable";
-  } catch {
-    return "provider_retryable";
-  }
-}
-
-/**
- * Map the gateway fallback's discriminated parse-failure reason to a coarse
- * extraction failure class. "no models configured" is an auth/config problem;
- * an HTTP/transport failure backs off; an unparseable-but-present response is a
- * genuine empty-parse.
- */
-export function classifyFallbackParseFailure(
-  reason: "no_models" | "empty" | "http_error",
-): ExtractionFailureClass {
-  switch (reason) {
-    case "no_models":
-      return "auth_config";
-    case "http_error":
-      return "provider_retryable";
-    case "empty":
-      return "parse_empty";
-  }
-}
 const PROACTIVE_MIN_CONFIDENCE = 0.8;
 const CONSOLIDATION_RESPONSE_SCHEMA = `{
   "items": [

package/src/mcp-read-only-tools.ts

@@ -21,6 +21,8 @@ export const MCP_READ_ONLY_TOOL_SUFFIXES: Readonly<Record<string, true>> = {
   transcript_day: true,
   transcript_search: true,
   transcript_memories: true,
+  meetings_list: true,
+  meetings_get: true,
   action_confidence: true,
   capsule_list: true,
   procedural_stats: true,