@remnic/core 9.22.0 → 9.22.1

package/src/meetings/http-glue.ts

@@ -0,0 +1,126 @@
+/**
+ * Meetings HTTP route glue (issue #1900) — the route bodies extracted from
+ * access-http.ts so the surface file stays under its structural ceiling. The
+ * thin inline hooks in access-http.ts keep the pathname/method match + the
+ * `enforceTokenOp("meetings_*")` boundary-dispatch marker (required by the
+ * surface-catalog fitness test) and delegate the body here.
+ *
+ * `MeetingsInputError` (invalid dates/ids) maps to a 400; everything else
+ * rethrows so backend faults keep flowing to the global 500 handler. Behaviour,
+ * validation, and `meetings.enabled` gating live in MeetingsService — these
+ * functions only translate transport shape.
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { EngramAccessInputError, type WearablesMeetingsScope } from "../access-service.js";
+import { MeetingsInputError } from "./errors.js";
+
+type RespondJson = (res: ServerResponse, status: number, payload: unknown) => void;
+type ReadJsonBody = (req: IncomingMessage) => Promise<unknown>;
+
+/** Minimal meetings surface the HTTP glue drives (satisfied by EngramAccessService). */
+export interface MeetingsHttpService {
+  meetingsList(date?: string, scope?: WearablesMeetingsScope): Promise<unknown>;
+  meetingsGet(id: string, scope?: WearablesMeetingsScope): Promise<unknown>;
+  meetingsBuild(date: string, scope?: WearablesMeetingsScope): Promise<unknown>;
+}
+
+function respondMeetingsError(respondJson: RespondJson, res: ServerResponse, err: unknown): boolean {
+  if (err instanceof MeetingsInputError) {
+    respondJson(res, 400, { error: "invalid_request", code: "invalid_request", message: err.message });
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Decode a meeting `:id` URL path segment, mapping malformed percent-encoded
+ * input (e.g. `%E0%A4%A`) to a 400 `MeetingsInputError` rather than letting the
+ * `URIError` bubble up to the global 500 handler — mirrors the access-http
+ * `decode*Segment` helpers.
+ */
+function decodeMeetingIdSegment(raw: string): string {
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    throw new MeetingsInputError("meeting id path segment is not valid percent-encoded input");
+  }
+}
+
+/**
+ * Per-principal write-quota hooks the build route shares with every other
+ * mutating REST route: `enforceQuota` throws a 429 when the principal is over
+ * budget; `recordHit` accounts the successful write. Injected from access-http
+ * so the quota state stays owned by the server (issue #1937).
+ */
+export interface MeetingsWriteQuotaHooks {
+  enforceQuota(): void;
+  recordHit(): void;
+}
+
+export async function respondMeetingsList(
+  res: ServerResponse,
+  respondJson: RespondJson,
+  service: MeetingsHttpService,
+  date: string | undefined,
+  scope?: WearablesMeetingsScope,
+): Promise<void> {
+  try {
+    respondJson(res, 200, await service.meetingsList(date, scope));
+  } catch (err) {
+    if (respondMeetingsError(respondJson, res, err)) return;
+    throw err;
+  }
+}
+
+export async function respondMeetingsGet(
+  res: ServerResponse,
+  respondJson: RespondJson,
+  service: MeetingsHttpService,
+  rawId: string,
+  scope?: WearablesMeetingsScope,
+): Promise<void> {
+  try {
+    respondJson(res, 200, await service.meetingsGet(decodeMeetingIdSegment(rawId), scope));
+  } catch (err) {
+    if (respondMeetingsError(respondJson, res, err)) return;
+    throw err;
+  }
+}
+
+export async function respondMeetingsBuild(
+  req: IncomingMessage,
+  res: ServerResponse,
+  respondJson: RespondJson,
+  readJsonBody: ReadJsonBody,
+  service: MeetingsHttpService,
+  quota: MeetingsWriteQuotaHooks,
+  scopeFor?: (bodyNamespace?: string, bodySessionKey?: string) => WearablesMeetingsScope,
+): Promise<void> {
+  const body = (await readJsonBody(req)) as Record<string, unknown>;
+  const raw = body.date;
+  if (raw !== undefined && raw !== null && raw !== "" && typeof raw !== "string") {
+    throw new EngramAccessInputError(`date must be a string (got ${JSON.stringify(raw)})`);
+  }
+  const date = raw === undefined || raw === null || raw === "" ? undefined : raw;
+  if (date === undefined) {
+    throw new EngramAccessInputError("date is required (YYYY-MM-DD)");
+  }
+  // Build persists/deletes records, writes memories, and reindexes — a mutating
+  // route, so it carries the same per-principal write quota as every other
+  // write (capsule import/export, admin promote). Enforce before the write,
+  // account the hit after it succeeds (issue #1937).
+  quota.enforceQuota();
+  const scope = scopeFor?.(
+    typeof body.namespace === "string" ? body.namespace : undefined,
+    typeof body.sessionKey === "string" ? body.sessionKey : undefined,
+  );
+  try {
+    const result = await service.meetingsBuild(date, scope);
+    quota.recordHit();
+    respondJson(res, 200, result);
+  } catch (err) {
+    if (respondMeetingsError(respondJson, res, err)) return;
+    throw err;
+  }
+}

package/src/meetings/index.ts

@@ -1,9 +1,6 @@
 /**
  * Public entry for the retrospective meeting-detection subsystem (issue #1900):
- * the deterministic engine — detection, fusion, record store, day build, and the
- * CLI over a day's already-ingested audio + app-span signals — plus the
- * memory-generation SEAM the builder depends on. The concrete memory generator
- * and the day-source/service/scheduler wiring ship in the surface slice.
+ * pure detection over a day's already-ingested audio + app-span signals.
  * Re-exported from the package root (`src/index.ts`) so consumers import it from
  * `@remnic/core`, matching the wearables/activity subsystems' surfacing.
  */
@@ -15,4 +12,8 @@ export * from "./fuse.js";
 export * from "./store.js";
 export * from "./memory-generator.js";
 export * from "./build.js";
+export * from "./memory-gen.js";
 export * from "./cli.js";
+export * from "./day-source.js";
+export * from "./build-scheduler.js";
+export * from "./service.js";

package/src/meetings/manual-sync-flush.test.ts

@@ -0,0 +1,72 @@
+/**
+ * Manual wearables-sync tail-step flush (P2 gap).
+ *
+ * The meeting tail-step (`MeetingsService.requestBuild`) arms a DEBOUNCED,
+ * unref'd 5s timer. A long-lived orchestrator lets that timer fire; a
+ * short-lived one-shot caller (manual `remnic wearables sync` over CLI/HTTP/MCP)
+ * reaches its shutdown before the debounce fires, so the meeting build never
+ * ran for a manual sync.
+ *
+ * `EngramAccessService.wearablesSync` — the shared manual sync path every
+ * one-shot host funnels through — now drains the debounced build
+ * (`flushBuilds()`) after sync completes, so the meeting build actually runs
+ * before the caller exits. The long-lived auto-sync daemon calls the shared
+ * wearables service's `sync` DIRECTLY (never through this method) and must keep
+ * coalescing on the debounce timer instead of flushing eagerly.
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { buildMeetingsNamespaceHarness } from "../testing/subjects/meetings-namespace-harness.js";
+
+const scope = (namespace: string, principal: string) => ({ namespace, authenticatedPrincipal: principal });
+
+test("manual wearables sync flushes the debounced meeting build (P2): the build runs before the one-shot caller returns", async () => {
+  const h = await buildMeetingsNamespaceHarness();
+  const DATE = "2026-03-10";
+  try {
+    // Manual one-shot path (CLI/HTTP/MCP funnel through EngramAccessService).
+    await h.service.wearablesSync({ date: DATE, ...scope("nsA", "pA") });
+
+    // No explicit meetingsBuild and no 5s wait: the meeting record can only
+    // exist if the manual sync drained the debounced tail-step build. Before
+    // the fix the build sat on an unfired unref'd timer and this was empty.
+    const storageA = await h.storageForNs("nsA");
+    assert.deepEqual(
+      await storageA.meetingRecordStore().listMeetingDates(),
+      [DATE],
+      "manual sync ran the debounced meeting build (record present without an explicit build)",
+    );
+  } finally {
+    await h.cleanup();
+  }
+});
+
+test("auto-sync path keeps the meeting build debounced (P2): the shared wearables service's direct sync does NOT flush eagerly", async () => {
+  const h = await buildMeetingsNamespaceHarness();
+  const DATE = "2026-03-11";
+  try {
+    // Daemon-style path: startWearablesAutoSync's adapter calls the shared
+    // wearables service's `sync` directly, bypassing EngramAccessService. It
+    // must arm the debounce, not flush it.
+    await h.orchestrator.getWearablesService("nsA").sync({ date: DATE });
+
+    const storageA = await h.storageForNs("nsA");
+    assert.deepEqual(
+      await storageA.meetingRecordStore().listMeetingDates(),
+      [],
+      "auto-sync path left the meeting build debounced (no eager flush)",
+    );
+
+    // The pending build is real, not impossible: draining it now produces the
+    // record — proving the auto-sync path merely deferred it on the timer.
+    await (await h.orchestrator.getMeetingsService("nsA")).flushBuilds();
+    assert.deepEqual(
+      await storageA.meetingRecordStore().listMeetingDates(),
+      [DATE],
+      "the debounced build was pending, not skipped",
+    );
+  } finally {
+    await h.cleanup();
+  }
+});

package/src/meetings/mcp-tools.ts

@@ -0,0 +1,65 @@
+/**
+ * Meetings MCP tool definitions (issue #1900) — the three `engram.meetings_*`
+ * tool-def objects, extracted from access-mcp.ts so the surface file stays under
+ * its structural ceiling. Spread back into `this.tools` (`...MEETINGS_MCP_TOOLS`);
+ * tools/list is verified at runtime. MCP_MIGRATED_OPERATIONS + callTool dispatch
+ * stay inline in access-mcp.ts.
+ */
+
+import type { McpTool } from "../access-mcp.js";
+
+export const MEETINGS_MCP_TOOLS: McpTool[] = [
+  {
+    name: "engram.meetings_list",
+    description:
+      "List stored meeting records (issue #1900), across all days or one day. Returns per-day meeting summaries; empty when meetings.enabled is off.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Caller namespace to scope this operation to (issue #2123)." },
+        sessionKey: { type: "string", description: "Session key for principal/namespace resolution." },
+        date: {
+          type: "string",
+          description: "Optional day to list (YYYY-MM-DD). Omit for all days.",
+        },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "engram.meetings_get",
+    description:
+      "Return one stored meeting record's markdown by id (mtg-YYYY-MM-DD-<hash>). Absent when not found or meetings.enabled is off.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Caller namespace to scope this operation to (issue #2123)." },
+        sessionKey: { type: "string", description: "Session key for principal/namespace resolution." },
+        id: {
+          type: "string",
+          description: "Meeting id (mtg-YYYY-MM-DD-<hash>). Required.",
+        },
+      },
+      required: ["id"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "engram.meetings_build",
+    description:
+      "Detect + fuse + store a day's meetings from ingested audio + screen activity. No-op (enabled:false) when meetings.enabled is off.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Caller namespace to scope this operation to (issue #2123)." },
+        sessionKey: { type: "string", description: "Session key for principal/namespace resolution." },
+        date: {
+          type: "string",
+          description: "Day to build (YYYY-MM-DD). Required.",
+        },
+      },
+      required: ["date"],
+      additionalProperties: false,
+    },
+  },
+];