@remnic/core 9.22.0 → 9.22.2

package/src/meetings/summary-extractor.test.ts

@@ -0,0 +1,287 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { composeMeetingRecord, type MeetingRecordBase } from "./store.js";
+import { DEFAULT_MEETINGS_CONFIG } from "./config.js";
+import {
+  generateMeetingSummaryFacts,
+  type MeetingFactCandidate,
+} from "./memory-gen.js";
+import type { MeetingMemoryWriter } from "./memory-generator.js";
+import {
+  LlmMeetingSummaryExtractor,
+  createMeetingSummaryDeps,
+  createMeetingSummaryJudge,
+  parseMeetingSummaryResponse,
+  type MeetingSummaryChatClient,
+} from "./summary-extractor.js";
+import type { FusedMeeting, MeetingRecord, MeetingsConfig } from "./types.js";
+import type { FusedSegment } from "../wearables/fusion/types.js";
+import type { SealedMemoryEnvelope } from "../write-envelope.js";
+import type { MemoryWriteResult } from "../storage.js";
+import type { JudgeBatchResult, JudgeCandidate, JudgeVerdict } from "../extraction-judge.js";
+
+const DATE = "2026-03-10";
+
+/** Chat client double: replays canned responses (string, null, or throw) and
+ *  records how it was called. `null`/`Error` items exercise chain fallthrough. */
+function fakeLlm(script: Array<string | null | Error>): MeetingSummaryChatClient & {
+  calls: Array<{ system: string; user: string }>;
+} {
+  let i = 0;
+  return {
+    calls: [],
+    async chatCompletion(messages) {
+      const system = messages.find((m) => m.role === "system")?.content ?? "";
+      const user = messages.find((m) => m.role === "user")?.content ?? "";
+      this.calls.push({ system, user });
+      const next = script[Math.min(i, script.length - 1)];
+      i++;
+      if (next instanceof Error) throw next;
+      return next === null ? null : { content: next };
+    },
+  };
+}
+
+function segment(text: string): FusedSegment {
+  return {
+    speaker: "Jane",
+    isSelf: false,
+    text,
+    startIso: "2026-03-10T14:05:00.000Z",
+    confidence: 0.9,
+    provenance: { source: "desktop", conversationId: "d1", sourceTrust: 0.9, reason: "only-source", alternatives: [] },
+  };
+}
+
+function fused(overrides: Partial<FusedMeeting> = {}): FusedMeeting {
+  return {
+    attendees: ["Jane", "Sam"],
+    sources: ["desktop", "pendant"],
+    corroboratedBy: [],
+    screenContext: [],
+    contextExcerpts: [],
+    transcript: [segment("we shipped v2")],
+    speakers: [],
+    snapshotCount: 0,
+    ...overrides,
+  };
+}
+
+function record(f: Partial<FusedMeeting> = {}): MeetingRecord {
+  const base: MeetingRecordBase = {
+    id: "mtg-2026-03-10-abcdef01",
+    date: DATE,
+    startUtc: "2026-03-10T14:00:00.000Z",
+    endUtc: "2026-03-10T14:30:00.000Z",
+    app: "Zoom",
+    detectionSource: "app+audio",
+  };
+  return composeMeetingRecord(base, fused(f));
+}
+
+function meetingConfig(overrides: Partial<MeetingsConfig> = {}): MeetingsConfig {
+  return { ...DEFAULT_MEETINGS_CONFIG, appPatterns: [...DEFAULT_MEETINGS_CONFIG.appPatterns], enabled: true, ...overrides };
+}
+
+interface WriteCall {
+  envelope: SealedMemoryEnvelope;
+  extras: { status?: string; memoryKind?: string };
+}
+
+/** In-memory writer modelling the sealed write path + source-scoped dedup. */
+class FakeWriter implements MeetingMemoryWriter {
+  writes: WriteCall[] = [];
+  private bySource = new Map<string, Set<string>>();
+
+  async writeSealedMemory(
+    envelope: SealedMemoryEnvelope,
+    extras: { status?: string; memoryKind?: string; contentHashSource?: string },
+  ): Promise<MemoryWriteResult> {
+    this.writes.push({ envelope, extras });
+    if (extras.contentHashSource !== undefined) {
+      const set = this.bySource.get(envelope.source) ?? new Set<string>();
+      set.add(extras.contentHashSource);
+      this.bySource.set(envelope.source, set);
+    }
+    return { id: `m${this.writes.length}`, path: `moments/m${this.writes.length}.md` } as unknown as MemoryWriteResult;
+  }
+  async hasMemoryFromSource(source: string, content: string): Promise<boolean> {
+    return this.bySource.get(source)?.has(content) ?? false;
+  }
+  async retireMemoriesFromSource(source: string): Promise<number> {
+    const count = this.bySource.get(source)?.size ?? 0;
+    this.bySource.delete(source);
+    return count;
+  }
+}
+
+const DECISION_COMMITMENT_QUESTION_JSON = JSON.stringify({
+  summary: "The team reviewed the v2 launch and settled the ship date.",
+  decisions: ["Ship v2 on Friday"],
+  commitments: [{ owner: "Sam", action: "send the launch recap by EOD" }],
+  openQuestions: ["Who owns the rollback plan?"],
+});
+
+/** A judge closure that returns the given verdict kind for every candidate,
+ *  in the shared `JudgeBatchResult` shape `judgeFactDurability` produces. */
+function judgeAll(kind: JudgeVerdict["kind"]): (candidates: JudgeCandidate[]) => Promise<JudgeBatchResult> {
+  return async (candidates) => {
+    const verdicts = new Map<number, JudgeVerdict>();
+    candidates.forEach((_, index) => verdicts.set(index, { durable: kind === "accept", reason: "test", kind }));
+    return { verdicts, cached: 0, judged: candidates.length, elapsed: 0, deferred: 0, deferredCappedToReject: 0 };
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Extractor
+// ---------------------------------------------------------------------------
+
+test("extractor categorizes decisions, commitments, and open questions from a JSON response", async () => {
+  const llm = fakeLlm([DECISION_COMMITMENT_QUESTION_JSON]);
+  const extractor = new LlmMeetingSummaryExtractor([llm]);
+  const { summary, candidates } = await extractor.extract({
+    record: record(),
+    transcriptText: "**Jane** [14:05]: we shipped v2",
+    screenContextText: "",
+  });
+  assert.equal(llm.calls.length, 1);
+  assert.match(summary, /settled the ship date/);
+  const decision = candidates.find((c) => c.category === "decision");
+  assert.equal(decision?.content, "Ship v2 on Friday");
+  const commitment = candidates.find((c) => c.category === "commitment");
+  assert.equal(commitment?.content, "Sam: send the launch recap by EOD", "owner-bearing commitment carries its owner");
+  const question = candidates.find((c) => c.category === "fact");
+  assert.equal(question?.content, "Open question: Who owns the rollback plan?");
+});
+
+test("extractor passes transcript + screen context into the prompt and tolerates code fences", async () => {
+  const fenced = "```json\n" + DECISION_COMMITMENT_QUESTION_JSON + "\n```";
+  const llm = fakeLlm([fenced]);
+  const extractor = new LlmMeetingSummaryExtractor([llm]);
+  const res = await extractor.extract({
+    record: record(),
+    transcriptText: "**Jane** [14:05]: ship it",
+    screenContextText: "[14:05] Zoom — Standup",
+  });
+  assert.equal(res.candidates.length, 3, "a fenced JSON body still parses to 3 candidates");
+  assert.match(llm.calls[0]!.user, /## Transcript/);
+  assert.match(llm.calls[0]!.user, /ship it/);
+  assert.match(llm.calls[0]!.user, /## Screen context/);
+  assert.match(llm.calls[0]!.user, /Standup/);
+});
+
+test("extractor tolerates malformed output — empty candidates, best-effort summary, never throws", async () => {
+  const extractor = new LlmMeetingSummaryExtractor([fakeLlm(["this is not json, just prose about the meeting"])]);
+  const res = await extractor.extract({ record: record(), transcriptText: "x", screenContextText: "" });
+  assert.deepEqual(res.candidates, []);
+  assert.equal(res.summary, "this is not json, just prose about the meeting");
+});
+
+test("extractor returns empty when no client yields content (null / empty chain)", async () => {
+  const nullRes = await new LlmMeetingSummaryExtractor([fakeLlm([null])]).extract({
+    record: record(),
+    transcriptText: "x",
+    screenContextText: "",
+  });
+  assert.deepEqual(nullRes, { summary: "", candidates: [] });
+  const emptyChain = await new LlmMeetingSummaryExtractor([]).extract({
+    record: record(),
+    transcriptText: "x",
+    screenContextText: "",
+  });
+  assert.deepEqual(emptyChain, { summary: "", candidates: [] });
+});
+
+test("extractor falls through the client chain: a throwing/empty client yields to the next", async () => {
+  const first = fakeLlm([new Error("local backend down")]);
+  const second = fakeLlm([DECISION_COMMITMENT_QUESTION_JSON]);
+  const extractor = new LlmMeetingSummaryExtractor([first, second]);
+  const res = await extractor.extract({ record: record(), transcriptText: "x", screenContextText: "" });
+  assert.equal(first.calls.length, 1, "the first client was tried");
+  assert.equal(second.calls.length, 1, "the chain fell through to the second client");
+  assert.equal(res.candidates.length, 3);
+});
+
+test("parseMeetingSummaryResponse never throws on garbage and salvages prose", () => {
+  assert.deepEqual(parseMeetingSummaryResponse("{ broken json"), { summary: "{ broken json", candidates: [] });
+  assert.deepEqual(parseMeetingSummaryResponse(""), { summary: "", candidates: [] });
+});
+
+// ---------------------------------------------------------------------------
+// Judge adapter
+// ---------------------------------------------------------------------------
+
+test("judge adapter maps shared judge verdicts aligned to candidate order", async () => {
+  const judge = createMeetingSummaryJudge(async (candidates) => {
+    const verdicts = new Map<number, JudgeVerdict>([
+      [0, { durable: true, reason: "keep", kind: "accept" }],
+      [1, { durable: false, reason: "drop", kind: "reject" }],
+      [2, { durable: false, reason: "later", kind: "defer" }],
+    ]);
+    return { verdicts, cached: 0, judged: candidates.length, elapsed: 0, deferred: 1, deferredCappedToReject: 0 };
+  });
+  const candidates: MeetingFactCandidate[] = [
+    { content: "a decision", category: "decision", confidence: 0.9 },
+    { content: "a weak claim", category: "fact", confidence: 0.5 },
+    { content: "an ambiguous claim", category: "fact", confidence: 0.6 },
+  ];
+  assert.deepEqual(await judge.judge(candidates), ["accept", "reject", "defer"]);
+});
+
+test("judge adapter degrades to no verdicts (empty array) when the shared judge throws", async () => {
+  const judge = createMeetingSummaryJudge(async () => {
+    throw new Error("judge backend down");
+  });
+  assert.deepEqual(await judge.judge([{ content: "x", category: "decision", confidence: 0.9 }]), []);
+});
+
+// ---------------------------------------------------------------------------
+// Production wiring: the SAME factory workspace-ops injects, driven through the
+// real trust-gated generateMeetingSummaryFacts path.
+// ---------------------------------------------------------------------------
+
+test("createMeetingSummaryDeps: smart mode writes a trust-gated decision + commitment with meeting provenance", async () => {
+  const llm = fakeLlm([DECISION_COMMITMENT_QUESTION_JSON]);
+  const { extractor, judge } = createMeetingSummaryDeps({
+    localLlm: llm,
+    fallbackLlm: null,
+    judgeFacts: judgeAll("accept"),
+  });
+  const writer = new FakeWriter();
+  const res = await generateMeetingSummaryFacts(record(), meetingConfig({ summaryMode: "smart" }), {
+    extractor,
+    judge,
+    writer,
+  });
+  assert.equal(res.llmInvoked, true);
+  assert.equal(llm.calls.length, 1, "the production extractor invoked the LLM once");
+
+  const decision = writer.writes.find((w) => w.envelope.category === "decision");
+  assert.ok(decision, "a decision fact was written");
+  assert.equal(decision!.extras.status, "active", "judge-accepted decision (0.8*0.85+0.15=0.83) is auto-active");
+  assert.equal(decision!.envelope.rawStructuredAttributes?.meetingId, "mtg-2026-03-10-abcdef01");
+
+  const commitment = writer.writes.find((w) => w.envelope.category === "commitment");
+  assert.ok(commitment, "a commitment fact (category commitment) was written");
+  assert.equal(commitment!.extras.status, "active");
+  assert.equal(commitment!.envelope.rawStructuredAttributes?.meetingId, "mtg-2026-03-10-abcdef01");
+});
+
+test("createMeetingSummaryDeps: off mode makes zero LLM calls", async () => {
+  const llm = fakeLlm([DECISION_COMMITMENT_QUESTION_JSON]);
+  const { extractor, judge } = createMeetingSummaryDeps({
+    localLlm: llm,
+    fallbackLlm: null,
+    judgeFacts: judgeAll("accept"),
+  });
+  const writer = new FakeWriter();
+  const res = await generateMeetingSummaryFacts(record(), meetingConfig({ summaryMode: "off" }), {
+    extractor,
+    judge,
+    writer,
+  });
+  assert.equal(res.llmInvoked, false);
+  assert.equal(llm.calls.length, 0, "off mode must NEVER invoke the LLM");
+  assert.equal(writer.writes.length, 0);
+});

package/src/meetings/summary-extractor.ts

@@ -0,0 +1,264 @@
+/**
+ * Production meeting summary extractor + durability-judge adapter (issue #1900).
+ *
+ * The engine's `MeetingsBuilder` accepts an optional `summary` dep pair
+ * ({ extractor, judge }); when present alongside `memoryWriter` and
+ * `summaryMode !== "off"` it runs `generateMeetingSummaryFacts` per record. This
+ * module supplies the PRODUCTION implementations of those interfaces so the
+ * default `summaryMode: "smart"` actually generates trust-gated meeting facts in
+ * production. It lives beside `memory-gen` (whose interfaces it implements) so
+ * `workspace-ops` stays thin — that file only constructs + injects.
+ *
+ * Reuse, not fork: the judge adapter wraps the SAME `judgeFactDurability` the
+ * live extraction + wearables pipelines use (verdict cache + defer counters
+ * included), and the extractor calls the shared local -> gateway LLM clients. No
+ * parallel trust/judge/LLM machinery lives here.
+ */
+
+import { getVerdictKind, type JudgeBatchResult, type JudgeCandidate } from "../extraction-judge.js";
+import { log } from "../logger.js";
+import type {
+  MeetingFactCandidate,
+  MeetingSummaryExtractor,
+  MeetingSummaryJudge,
+} from "./memory-gen.js";
+import type { MeetingRecord } from "./types.js";
+
+/**
+ * Narrow chat client the extractor needs. Structurally satisfied by BOTH
+ * `LocalLlmClient` and `FallbackLlmClient`, so production injects the real
+ * local -> gateway chain and unit tests inject a fake. Kept minimal (never fork
+ * the clients) so a client outage or a null return degrades to "no candidates"
+ * rather than throwing through the build.
+ */
+export interface MeetingSummaryChatClient {
+  chatCompletion(
+    messages: Array<{ role: "system" | "user" | "assistant"; content: string }>,
+    options?: { temperature?: number; maxTokens?: number; operation?: string },
+  ): Promise<{ content: string } | null>;
+}
+
+const SUMMARY_SYSTEM_PROMPT = `You are a meeting scribe extracting DURABLE memory from a meeting transcript and its on-screen context.
+
+Return ONLY a single JSON object, no prose, no code fences, in exactly this shape:
+{
+  "summary": "one concise paragraph (2-4 sentences) describing what the meeting was about and its outcome",
+  "decisions": ["a concrete decision the group reached", ...],
+  "commitments": [{"owner": "who owns it", "action": "what they committed to do, including any due date"}, ...],
+  "openQuestions": ["an unresolved question that was raised", ...]
+}
+
+Rules:
+- decisions: concrete choices the group made. Omit hypotheticals and discussion that led nowhere.
+- commitments: owner-bearing action items only. If there is no clear owner, omit it.
+- openQuestions: genuinely unresolved questions, not rhetorical asides.
+- Prefer fewer, higher-quality items. Use [] for any empty list. Never invent content the transcript does not support.`;
+
+const DECISION_CONFIDENCE = 0.8;
+const COMMITMENT_CONFIDENCE = 0.8;
+const QUESTION_CONFIDENCE = 0.6;
+const DEFAULT_MAX_TOKENS = 1024;
+/** Cap a salvaged (non-JSON) best-effort summary so a runaway response cannot
+ *  push a huge blob into the trust-gated summary fact. */
+const MAX_BEST_EFFORT_SUMMARY = 2000;
+
+function meetingPromptHeader(record: MeetingRecord): string {
+  const parts = [`Meeting on ${record.date}`];
+  if (record.app !== undefined) parts.push(`app: ${record.app}`);
+  if (record.attendees.length > 0) parts.push(`attendees: ${record.attendees.join(", ")}`);
+  return parts.join(" | ");
+}
+
+function buildUserPrompt(
+  record: MeetingRecord,
+  transcriptText: string,
+  screenContextText: string,
+): string {
+  const sections = [meetingPromptHeader(record), "", "## Transcript", transcriptText || "(none)"];
+  if (screenContextText.trim().length > 0) {
+    sections.push("", "## Screen context", screenContextText);
+  }
+  return sections.join("\n");
+}
+
+/** Strip a wrapping markdown code fence, if present. */
+function stripCodeFence(text: string): string {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("```")) return trimmed;
+  const withoutOpen = trimmed.replace(/^```[a-zA-Z0-9]*\n?/, "");
+  const closeIdx = withoutOpen.lastIndexOf("```");
+  return (closeIdx === -1 ? withoutOpen : withoutOpen.slice(0, closeIdx)).trim();
+}
+
+function asString(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function pushIfContent(
+  out: MeetingFactCandidate[],
+  content: string,
+  category: MeetingFactCandidate["category"],
+  confidence: number,
+): void {
+  const trimmed = content.trim();
+  if (trimmed.length > 0) out.push({ content: trimmed, category, confidence });
+}
+
+function candidatesFromParsed(parsed: Record<string, unknown>): MeetingFactCandidate[] {
+  const out: MeetingFactCandidate[] = [];
+  const decisions = Array.isArray(parsed.decisions) ? parsed.decisions : [];
+  for (const d of decisions) pushIfContent(out, asString(d), "decision", DECISION_CONFIDENCE);
+
+  const commitments = Array.isArray(parsed.commitments) ? parsed.commitments : [];
+  for (const c of commitments) {
+    if (typeof c === "string") {
+      pushIfContent(out, c, "commitment", COMMITMENT_CONFIDENCE);
+    } else if (c !== null && typeof c === "object") {
+      const owner = asString((c as Record<string, unknown>).owner);
+      const action = asString((c as Record<string, unknown>).action);
+      const content = owner.length > 0 && action.length > 0 ? `${owner}: ${action}` : owner || action;
+      pushIfContent(out, content, "commitment", COMMITMENT_CONFIDENCE);
+    }
+  }
+
+  const questions = Array.isArray(parsed.openQuestions) ? parsed.openQuestions : [];
+  for (const q of questions) {
+    const text = asString(q);
+    if (text.length > 0) pushIfContent(out, `Open question: ${text}`, "fact", QUESTION_CONFIDENCE);
+  }
+  return out;
+}
+
+/**
+ * Parse the model response into a summary + categorized candidates. Tolerant by
+ * contract: malformed output yields empty candidates plus a best-effort summary
+ * (the salvaged prose), and NEVER throws — a bad LLM response must degrade the
+ * build, not fail it.
+ */
+export function parseMeetingSummaryResponse(raw: string): {
+  summary: string;
+  candidates: MeetingFactCandidate[];
+} {
+  const body = stripCodeFence(raw);
+  const start = body.indexOf("{");
+  const end = body.lastIndexOf("}");
+  if (start !== -1 && end > start) {
+    try {
+      const parsed: unknown = JSON.parse(body.slice(start, end + 1));
+      if (parsed !== null && typeof parsed === "object") {
+        const obj = parsed as Record<string, unknown>;
+        return { summary: asString(obj.summary), candidates: candidatesFromParsed(obj) };
+      }
+    } catch {
+      // fall through to best-effort salvage
+    }
+  }
+  // Best-effort: a model that ignored the JSON contract still gave us prose.
+  return { summary: body.slice(0, MAX_BEST_EFFORT_SUMMARY).trim(), candidates: [] };
+}
+
+/**
+ * Production extractor. Tries each injected chat client in order (local first,
+ * then the gateway fallback) until one returns content; a null/empty result or
+ * a thrown client error degrades to an empty extraction (no summary, no
+ * candidates) instead of failing the meeting build.
+ */
+export class LlmMeetingSummaryExtractor implements MeetingSummaryExtractor {
+  constructor(
+    private readonly clients: readonly MeetingSummaryChatClient[],
+    private readonly options: { maxTokens?: number } = {},
+  ) {}
+
+  async extract(input: {
+    record: MeetingRecord;
+    transcriptText: string;
+    screenContextText: string;
+  }): Promise<{ summary: string; candidates: MeetingFactCandidate[] }> {
+    const raw = await this.complete(
+      buildUserPrompt(input.record, input.transcriptText, input.screenContextText),
+    );
+    if (raw === null) return { summary: "", candidates: [] };
+    return parseMeetingSummaryResponse(raw);
+  }
+
+  private async complete(userPrompt: string): Promise<string | null> {
+    for (const client of this.clients) {
+      try {
+        const res = await client.chatCompletion(
+          [
+            { role: "system", content: SUMMARY_SYSTEM_PROMPT },
+            { role: "user", content: userPrompt },
+          ],
+          { temperature: 0, maxTokens: this.options.maxTokens ?? DEFAULT_MAX_TOKENS, operation: "meeting-summary" },
+        );
+        const content = res?.content?.trim();
+        if (content !== undefined && content.length > 0) return content;
+      } catch (err) {
+        log.warn(
+          `meetings: summary extractor LLM call failed, trying next client: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+      }
+    }
+    return null;
+  }
+}
+
+/**
+ * Judge adapter over the SHARED durability judge. Maps meeting candidates to
+ * `JudgeCandidate`s, runs `judgeFacts` (the same `judgeFactDurability` closure
+ * the wearables service passes — cache + defer counters included), and returns
+ * verdict kinds aligned to the input candidate order. A judge outage returns an
+ * empty array so `generateMeetingSummaryFacts` continues on trust score alone
+ * (matching the wearables graceful-degradation contract); it never throws.
+ */
+export function createMeetingSummaryJudge(
+  judgeFacts: (candidates: JudgeCandidate[]) => Promise<JudgeBatchResult>,
+): MeetingSummaryJudge {
+  return {
+    async judge(candidates) {
+      if (candidates.length === 0) return [];
+      const judgeCandidates: JudgeCandidate[] = candidates.map((c) => ({
+        text: c.content,
+        category: c.category,
+        confidence: c.confidence ?? 0.7,
+      }));
+      try {
+        const { verdicts } = await judgeFacts(judgeCandidates);
+        return candidates.map((_, i) => {
+          const verdict = verdicts.get(i);
+          return verdict ? getVerdictKind(verdict) : "defer";
+        });
+      } catch (err) {
+        log.warn(
+          `meetings: durability judge unavailable, scoring without verdicts: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+        return [];
+      }
+    },
+  };
+}
+
+/**
+ * Build the production summary deps (extractor + judge) the `MeetingsBuilder`
+ * consumes. Pure construction — no disk, no network — so a caller can build it
+ * unconditionally and let the builder gate on `summaryMode`. Reuses the caller's
+ * local + fallback clients and the shared judge closure, so nothing here forks
+ * the trust/judge/LLM contracts.
+ */
+export function createMeetingSummaryDeps(deps: {
+  localLlm: MeetingSummaryChatClient | null;
+  fallbackLlm: MeetingSummaryChatClient | null;
+  judgeFacts: (candidates: JudgeCandidate[]) => Promise<JudgeBatchResult>;
+}): { extractor: MeetingSummaryExtractor; judge: MeetingSummaryJudge } {
+  const clients: MeetingSummaryChatClient[] = [];
+  if (deps.localLlm !== null) clients.push(deps.localLlm);
+  if (deps.fallbackLlm !== null) clients.push(deps.fallbackLlm);
+  return {
+    extractor: new LlmMeetingSummaryExtractor(clients),
+    judge: createMeetingSummaryJudge(deps.judgeFacts),
+  };
+}

package/src/orchestration/maintenance.ts

@@ -62,6 +62,7 @@ import {
 } from "../storage/memory-lifecycle-ledger-access.js";
 import { STATE_FILE_MAX_DECRYPT_BYTES } from "../storage/secure-line-reader.js";
 import { ActivitySyncRegistrar } from "../activity/sync-registration.js";
+import type { ActivitySyncRunSummary } from "../activity/runner.js";
 import { resolveHomeDir } from "../runtime/env.js";
 import { log } from "../logger.js";
 import { isErrnoCode } from "../utils/errno.js";
@@ -105,6 +106,12 @@ export interface MaintenanceSchedulerDeps {
    * (#1910). Consulted only when namespaces are enabled.
    */
   storageForNamespace?: (namespace: string) => Promise<StorageManager>;
+  /**
+   * Tail step (issue #1900): observe a durable activity sync tick so the
+   * meetings builder can rebuild the affected day(s). Optional; omitted by
+   * hosts that do not build meetings.
+   */
+  onActivitySynced?: (summary: ActivitySyncRunSummary) => void;
 }
 
 /**
@@ -153,6 +160,7 @@ export class MaintenanceScheduler {
       secureStoreEnabled: resolveRecallAuxiliaryCapabilities(deps.config).secureStore,
       getQmd: () => deps.getQmd(),
       requestReindexRetry: () => this.requestQmdMaintenanceForTool("activity-reindex-retry"),
+      ...(deps.onActivitySynced ? { onSynced: deps.onActivitySynced } : {}),
     });
   }
 

package/src/orchestration/orchestrator-init.ts

@@ -45,6 +45,7 @@ import { TranscriptManager } from "../transcript.js";
 import type { PluginConfig } from "../types.js";
 import { type UtilityRuntimeValues, loadUtilityRuntimeValues } from "../utility-runtime.js";
 import { WearablesService } from "../wearables/service.js";
+import type { MeetingsService } from "../meetings/service.js";
 import {
   COMPACTION_SIGNAL_MAX_AGE_MS,
   defaultWorkspaceDir,
@@ -64,7 +65,8 @@ export interface OrchestratorInitDeps {
   deferredSyncSucceeded: boolean;
   disposeSearchBackendIfNeeded(): Promise<void>;
   readonly embeddingFallback: EmbeddingFallback;
-  getWearablesService(): WearablesService;
+  getWearablesService(namespace?: string): WearablesService;
+  getMeetingsService(namespace?: string): Promise<MeetingsService>;
   readonly handleHistory: RecallHandleHistoryStore;
   readonly lastRecall: LastRecallStore;
   maintenanceNamespaces(
@@ -562,6 +564,9 @@ export class OrchestratorInitCoordinator {
               : {}),
           },
           {
+            // The shared wearables service fires its own meeting tail-step hook
+            // (wired in workspace-ops), so both this auto-sync path and the
+            // manual sync path rebuild affected meetings — no per-adapter fan-out.
             sync: (options) => this.deps.getWearablesService().sync(options),
             log: {
               info: (message) => log.info(message),