@remnic/core 9.63.3 → 9.63.5

package/src/binary-lifecycle/pipeline.ts

@@ -294,11 +294,25 @@ async function stageRedirect(
         }
 
         if (asset.redirectedAt === undefined) {
-          if (!dryRun) {
-            asset.status = "mirrored";
+          let remoteSeen = false;
+          for (const mdPath of mdFiles) {
+            try {
+              const content = await readMarkdownFile(mdPath);
+              if (content.includes(asset.mirroredPath)) {
+                remoteSeen = true;
+                break;
+              }
+            } catch {
+              // Verify already succeeded; a later read error is not a local ref.
+            }
+          }
+          if (!remoteSeen) {
+            if (!dryRun) {
+              asset.status = "mirrored";
+            }
+            log.info(`[binary-lifecycle] preserved mirrored asset without redirected marker: ${asset.originalPath}${dryRun ? " [dry-run]" : ""}`);
+            continue;
           }
-          log.info(`[binary-lifecycle] preserved mirrored asset without redirected marker: ${asset.originalPath}${dryRun ? " [dry-run]" : ""}`);
-          continue;
         }
 
         if (!Number.isFinite(new Date(asset.mirroredAt).getTime())) {
@@ -400,9 +414,6 @@ async function stageRedirect(
       continue;
     }
 
-    const redirectedAt = new Date().toISOString();
-    asset.redirectedAt = redirectedAt;
-
     const verifyResult = await countRemainingLocalReferences(
       memoryDir,
       asset,
@@ -411,7 +422,10 @@ async function stageRedirect(
       readMarkdownFile,
     );
     if (verifyResult.errors.length > 0 || verifyResult.remaining > 0) {
-      asset.status = "error";
+asset.status = "error";
+// Failed verify must not read as a completed redirect (#2471); this also
+// clears stale stamps written by manifests from before that fix.
+delete asset.redirectedAt;
       for (const msg of verifyResult.errors) {
         log.error(`[binary-lifecycle] ${msg}`);
         errors.push(msg);
@@ -424,7 +438,7 @@ async function stageRedirect(
       continue;
     }
     asset.status = "redirected";
-    asset.redirectedAt = redirectedAt;
+asset.redirectedAt = new Date().toISOString();
     redirected++;
     log.info(`[binary-lifecycle] redirected: ${asset.originalPath}`);
   }

package/src/buffer.ts

@@ -619,6 +619,12 @@ export class SmartBuffer {
     log.debug(
       `buffer[${bufferKey}]: ${mutation.turnCountInWindow} turns, signal=${mutation.signalLevel}, decision=${decision}`,
     );
+    if (decision !== "keep_buffering" && extractionTurns === undefined) {
+      extractionTurns = [
+        ...mutation.retainedTurnsSnapshot,
+        ...mutation.activeTurnsSnapshot,
+      ];
+    }
     return extractionTurns ? { decision, extractionTurns } : { decision };
   }
 

package/src/chat/chat-cli.test.ts

@@ -15,6 +15,12 @@ import { withTempDir as managedWithTempDir } from "../testing/tmp-dir.js";
 import type { EngramAccessService } from "../access-service.js";
 import { parseConfig } from "../config.js";
 import { runChatCli } from "./chat-cli.js";
+import { processChatMessage } from "./chat-factory.js";
+import {
+  createChatSession,
+  loadChatSession,
+  markPendingPlan,
+} from "./chat-session.js";
 import { DEFAULT_CHAT_CONFIG } from "./chat-config.js";
 
 /** Capture stdout.write for the duration of `fn`. */
@@ -137,3 +143,50 @@ test("CLI: resumes an existing session by id", async () => {
     assert.ok(second.includes("[session:"), "resumed run should also print a session id");
   });
 });
+
+test("CLI --once: pending plan is visible on reload the same way as HTTP (issue #2479)", async () => {
+  await withTempDir(async (memoryDir) => {
+    const service = makeService({
+      memoryDir,
+      configRef: parseConfig({ memoryDir, chat: { ...DEFAULT_CHAT_CONFIG, enabled: true } }),
+    });
+
+    // CLI side: first turn mints the session.
+    const first = await captureStdout(() =>
+      runChatCli({ service, config: service.configRef!.chat, memoryDir, once: true, input: "hello" }),
+    );
+    const sessionId = /\[session: ([^\]]+)\]/.exec(first)![1]!;
+    // Pending plan minted by an earlier correction-preview turn.
+    await markPendingPlan(memoryDir, sessionId, "plan-cli-2479");
+    await captureStdout(() =>
+      runChatCli({ service, config: service.configRef!.chat, memoryDir, once: true, input: "anything else?", sessionId }),
+    );
+    const viaCli = await loadChatSession(memoryDir, sessionId);
+    // HTTP side: identical scenario through the shared processor.
+    const httpSession = await createChatSession(memoryDir, {});
+    await processChatMessage({
+      service,
+      config: service.configRef!.chat,
+      memoryDir,
+      message: "hello",
+      chatSessionId: httpSession.id,
+    });
+    await markPendingPlan(memoryDir, httpSession.id, "plan-http-2479");
+    await processChatMessage({
+      service,
+      config: service.configRef!.chat,
+      memoryDir,
+      message: "anything else?",
+      chatSessionId: httpSession.id,
+    });
+    const viaHttp = await loadChatSession(memoryDir, httpSession.id);
+
+    assert.equal(viaCli?.pendingPlanId, "plan-cli-2479", "CLI turn must leave the pending plan visible on reload");
+    assert.equal(viaHttp?.pendingPlanId, "plan-http-2479", "HTTP turn must leave the pending plan visible on reload");
+    // Transcript shape parity: both surfaces append the same role sequence.
+    assert.deepEqual(
+      viaCli!.transcript.map((e) => e.role),
+      viaHttp!.transcript.map((e) => e.role),
+    );
+  });
+});

package/src/chat/chat-cli.ts

@@ -6,28 +6,25 @@
  * and `--once` / non-TTY mode for scripting/tests
  * (`echo "question" | remnic chat --once`).
  *
+ * Every turn routes through the shared `processChatMessage` factory
+ * (issue #2479) so session lifecycle, transcript persistence, and
+ * pending-plan/promotion markers behave identically to the HTTP/MCP
+ * surfaces.
+ *
  * This module is imported by cli.ts with a single thin registration line —
  * the god-file ratchet (#1520) tracks cli.ts LOC.
  */
 
-import readline from "node:readline";
 import { createInterface } from "node:readline";
-import { randomUUID } from "node:crypto";
 
 import type { EngramAccessService } from "../access-service.js";
-import type { PluginConfig } from "../types.js";
-import type { ChatConfig } from "./chat-types.js";
-import type { ChatTurnResult } from "./chat-types.js";
-import { ChatEngine } from "./chat-engine.js";
-import { createProductionChatLlmAdapter } from "./chat-llm.js";
-import { createChatExecutor } from "./chat-executor.js";
+import type { ChatConfig, ChatTurnResult } from "./chat-types.js";
+import { processChatMessage } from "./chat-factory.js";
 import {
   createChatSession,
   loadChatSession,
-  appendTranscriptEntry,
   sessionBelongsToPrincipal,
 } from "./chat-session.js";
-import { isConfirmationMessage } from "./chat-engine.js";
 
 /**
  * Read all of stdin to a UTF-8 string (non-TTY / scripting mode).
@@ -78,16 +75,10 @@ export async function runChatCli(opts: ChatCliOptions): Promise<void> {
     return;
   }
 
-  const adapter = createProductionChatLlmAdapter(llm as {
-    chatCompletion(
-      messages: Array<{ role: string; content: string }>,
-      options?: { model?: string; signal?: AbortSignal },
-    ): Promise<{ content: string } | null>;
-  });
-
-  // Load or create session FIRST so the executor inherits the session's
-  // stored namespace/sessionKey scope — a resumed session created via MCP
-  // must not lose its scope binding (codex review, Thread 19).
+  // Resolve the session up front so the banner and --once output print a
+  // stable session id.  Each turn then routes through processChatMessage,
+  // which reloads the session from disk — persisted state markers
+  // (pending plan/promotion) stay authoritative across turns.
   let session;
   if (opts.sessionId) {
     session = await loadChatSession(opts.memoryDir, opts.sessionId);
@@ -107,21 +98,15 @@ export async function runChatCli(opts: ChatCliOptions): Promise<void> {
     });
   }
 
-  const executor = createChatExecutor({
-    service: opts.service,
-    principal: opts.principal,
-    ...(session.namespace ? { namespace: session.namespace } : {}),
-    ...(session.sessionKey ? { sessionKey: session.sessionKey } : {}),
-  });
-
-  const engine = new ChatEngine({
-    llm: adapter,
-    executor,
-    maxToolCallsPerTurn: config.maxToolCallsPerTurn,
-    ...(config.model ? { model: config.model } : {}),
-    correctionAvailable: false,
-    scopeInspectAvailable: false,
-  });
+  const processTurn = (message: string): Promise<ChatTurnResult> =>
+    processChatMessage({
+      service: opts.service,
+      config,
+      memoryDir: opts.memoryDir,
+      message,
+      chatSessionId: session.id,
+      principal: opts.principal,
+    });
 
   // ── Non-TTY / --once mode ───────────────────────────────────────────
   if (opts.once) {
@@ -131,17 +116,7 @@ export async function runChatCli(opts: ChatCliOptions): Promise<void> {
       process.stdout.write("[error] No input provided.\n");
       return;
     }
-    const userEntry = await appendTranscriptEntry(opts.memoryDir, session.id, {
-      role: "user",
-      content: message,
-    });
-    session.transcript.push(userEntry);
-    const result = await engine.processMessage(message, session);
-    const assistantEntry = await appendTranscriptEntry(opts.memoryDir, session.id, {
-      role: "assistant",
-      content: result.reply,
-    });
-    session.transcript.push(assistantEntry);
+    const result = await processTurn(message);
     process.stdout.write(result.reply + "\n");
     process.stdout.write(`[session: ${session.id}]\n`);
     return;
@@ -173,18 +148,7 @@ export async function runChatCli(opts: ChatCliOptions): Promise<void> {
     // Serialize turns: a second line waits for the first to finish so
     // transcript updates and engine state don't race on the same session.
     inFlight = inFlight.then(async () => {
-    const userEntry = await appendTranscriptEntry(opts.memoryDir, session!.id, {
-      role: "user",
-      content: message,
-    });
-    session!.transcript.push(userEntry);
-
-    const result = await engine.processMessage(message, session!);
-    const assistantEntry = await appendTranscriptEntry(opts.memoryDir, session!.id, {
-      role: "assistant",
-      content: result.reply,
-    });
-    session!.transcript.push(assistantEntry);
+    const result = await processTurn(message);
 
     console.log(`\nassistant> ${result.reply}\n`);
     if (result.pendingPlan) {

package/src/dedup/index.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import test from "node:test";
 
-import { findContradictions, findDuplicates } from "./index.js";
+import { NEGATION_WORDS, findContradictions, findDuplicates } from "./index.js";
 
 test("findContradictions detects can versus cannot statements", async () => {
   const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-dedup-contradiction-"));
@@ -149,3 +149,67 @@ test("dedup scans reject symlinked category directories outside memoryDir", asyn
     await rm(outsideDir, { recursive: true, force: true });
   }
 });
+
+test("strip-negation pattern is derived from NEGATION_WORDS", async () => {
+  NEGATION_WORDS.add("seldom");
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-dedup-negation-"));
+
+  try {
+    const factsDir = path.join(memoryDir, "facts");
+    await mkdir(factsDir);
+    await writeFile(
+      path.join(factsDir, "plain.md"),
+      ["---", "id: mem-plain", "category: fact", "---", "The user enjoys morning runs."].join("\n"),
+      "utf8"
+    );
+    await writeFile(
+      path.join(factsDir, "seldom.md"),
+      ["---", "id: mem-seldom", "category: fact", "---", "The user seldom enjoys morning runs."].join("\n"),
+      "utf8"
+    );
+
+    const result = findContradictions({ memoryDir, categories: ["facts"] });
+
+    // "high" requires the stripped texts to match exactly, which only happens
+    // when the strip pattern honors the word the test added to the set.
+    assert.equal(result.contradictions.length, 1);
+    assert.equal(result.contradictions[0]?.severity, "high");
+    assert.equal(result.contradictions[0]?.reason, "Negated version of similar content");
+  } finally {
+    NEGATION_WORDS.delete("seldom");
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("strip-negation cache rebuilds on same-size vocabulary swap", async () => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-dedup-negation-swap-"));
+
+  try {
+    const factsDir = path.join(memoryDir, "facts");
+    await mkdir(factsDir);
+    await writeFile(
+      path.join(factsDir, "plain.md"),
+      ["---", "id: mem-swap-plain", "category: fact", "---", "The user enjoys morning runs."].join("\n"),
+      "utf8"
+    );
+    await writeFile(
+      path.join(factsDir, "rarely.md"),
+      ["---", "id: mem-swap-rarely", "category: fact", "---", "The user rarely enjoys morning runs."].join("\n"),
+      "utf8"
+    );
+
+    // Warm the pattern cache with the current vocabulary (no "rarely" yet).
+    assert.equal(findContradictions({ memoryDir, categories: ["facts"] }).contradictions.length, 0);
+
+    // Same-size swap: the size-keyed cache would keep serving the stale pattern.
+    NEGATION_WORDS.delete("never");
+    NEGATION_WORDS.add("rarely");
+    const result = findContradictions({ memoryDir, categories: ["facts"] });
+    assert.equal(result.contradictions.length, 1);
+    assert.equal(result.contradictions[0]?.severity, "high");
+  } finally {
+    NEGATION_WORDS.delete("rarely");
+    NEGATION_WORDS.add("never");
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/dedup/index.ts

@@ -245,7 +245,7 @@ function tokenizeForSimilarity(text: string): Set<string> {
 
 // ── Contradiction detection ──────────────────────────────────────────────────
 
-const NEGATION_WORDS = new Set([
+export const NEGATION_WORDS = new Set([
   "not",
   "don't",
   "doesn't",
@@ -317,9 +317,31 @@ function containsNegation(text: string): boolean {
   return words.some((w) => NEGATION_WORDS.has(w));
 }
 
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// Single vocabulary source: the strip pattern is derived from NEGATION_WORDS,
+// never hand-maintained. Keyed on the alternation content so any vocabulary
+// change (not just a size change) rebuilds the pattern.
+let stripNegationPattern: RegExp | null = null;
+let stripNegationPatternSource: string | null = null;
+
+function stripNegationRegex(): RegExp {
+  const alternation = [...NEGATION_WORDS]
+    .sort((a, b) => b.length - a.length)
+    .map(escapeRegExp)
+    .join("|");
+  if (stripNegationPattern === null || stripNegationPatternSource !== alternation) {
+    stripNegationPattern = new RegExp(`\\b(?:${alternation})\\b`, "gi");
+    stripNegationPatternSource = alternation;
+  }
+  return stripNegationPattern;
+}
+
 function stripNegation(text: string): string {
   return text
-    .replace(/\b(not|don't|doesn't|isn't|aren't|won't|can't|cannot|never|no|none|neither|nor|nothing|nowhere)\b/gi, "")
+    .replace(stripNegationRegex(), "")
     .replace(/\s+/g, " ")
     .trim();
 }

package/src/maintenance/namespace-planner.ts

@@ -177,8 +177,6 @@ function candidatePriority(candidate: NamespaceMaintenanceCandidate): number {
   if (candidate.source === "configured") return 2;
   if (candidate.kind === "team-project") return 3;
   if (candidate.kind === "project") return 4;
-  if (candidate.kind === "self") return 5;
-  if (candidate.kind === "legacy") return 6;
   if (candidate.kind === "branch") return 8;
   return 7;
 }

package/src/meetings/build.test.ts

@@ -5,12 +5,12 @@ import { MeetingsBuilder, type MeetingDayData, type MeetingsDayBuildSummary, typ
 import { DEFAULT_MEETINGS_CONFIG } from "./config.js";
 import { MeetingRecordStore, type MeetingRecordFileIo } from "./store.js";
 import type {
-  MeetingActivitySnapshot,
   MeetingsConfig,
   MeetingAppSpan,
   MeetingAudioWindow,
   MeetingRecord,
 } from "./types.js";
+import type { ActivitySnapshot } from "../activity/types.js";
 import type { FusionConversationInput, FusionSegmentInput } from "../wearables/fusion/types.js";
 import type { MeetingMemoryGenerator, MeetingMemoryOutcome } from "./memory-generator.js";
 
@@ -174,9 +174,25 @@ test("degradation — audio only yields a record with no screen-context section"
 });
 
 test("full — app+audio with activity fuses transcript and screen context", async () => {
-  const activity: MeetingActivitySnapshot[] = [
-    { tsUtc: "2026-03-10T14:05:00.000Z", app: "Preview", title: "Q3-roadmap.pdf" },
-    { tsUtc: "2026-03-10T14:30:00.000Z", app: "Zoom", text: "meeting chat" },
+  const activity: ActivitySnapshot[] = [
+    {
+      machine: "workstation",
+      capturedAtUtc: "2026-03-10T14:05:00.000Z",
+      app: "Preview",
+      windowTitle: "Q3-roadmap.pdf",
+      text: "",
+      textSource: "ax",
+      contentHash: "snap-1",
+    },
+    {
+      machine: "workstation",
+      capturedAtUtc: "2026-03-10T14:30:00.000Z",
+      app: "Zoom",
+      windowTitle: "",
+      text: "meeting chat",
+      textSource: "ax",
+      contentHash: "snap-2",
+    },
   ];
   const { builder: b, store } = builder(
     {

package/src/meetings/build.ts

@@ -22,10 +22,10 @@ import type {
   MeetingMemoryOutcome,
   MeetingsDayFactGenResult,
 } from "./memory-generator.js";
+import type { ActivitySnapshot } from "../activity/types.js";
 import type { FusionConversationInput } from "../wearables/fusion/types.js";
 import type {
   DetectedMeeting,
-  MeetingActivitySnapshot,
   MeetingRecord,
   MeetingsConfig,
   MeetingsDetectionInput,
@@ -38,7 +38,7 @@ export interface MeetingDayData {
   /** Fusion conversation inputs across all wearable sources for the day. */
   conversations: FusionConversationInput[];
   /** Screen-activity snapshots for the day. */
-  activity?: MeetingActivitySnapshot[];
+  activity?: ActivitySnapshot[];
 }
 
 /** Supplies a day's signals. Backed by fixtures in tests; by the activity +

package/src/meetings/day-source.test.ts

@@ -127,7 +127,9 @@ test("loadDayData assembles detection + activity for the requested day, keyed to
   assert.equal(data.detection.appSpans[0]?.app, "Zoom");
   assert.deepEqual(data.detection.audioWindows, [], "no wearable transcripts → no audio windows");
   assert.equal(data.activity?.length, 2);
-  assert.equal(data.activity?.[0]?.title, "Standup");
+  // Activity is the raw ActivitySnapshot list now — no rename mapper in between.
+  assert.equal(data.activity?.[0]?.windowTitle, "Standup");
+  assert.equal(data.activity?.[0]?.capturedAtUtc, "2026-03-10T14:00:00.000Z");
   assert.equal(data.conversations.length, 0);
 });
 

package/src/meetings/day-source.ts

@@ -28,7 +28,6 @@ import type { FusionConversationInput, FusionSegmentInput } from "../wearables/f
 import type { MeetingDayData, MeetingsDaySource } from "./build.js";
 import { MeetingsInputError } from "./errors.js";
 import type {
-  MeetingActivitySnapshot,
   MeetingAppSpan,
   MeetingAudioWindow,
   MeetingsConfig,
@@ -97,15 +96,6 @@ export function storageWearableDayReader(store: WearableDayTranscriptStore): Mee
   };
 }
 
-/** Map an activity snapshot to the redaction-safe screen snapshot fusion sees. */
-function toMeetingActivitySnapshot(snapshot: ActivitySnapshot): MeetingActivitySnapshot {
-  const out: MeetingActivitySnapshot = { tsUtc: snapshot.capturedAtUtc, app: snapshot.app };
-  if (snapshot.windowTitle.length > 0) out.title = snapshot.windowTitle;
-  if (snapshot.browserUrl !== undefined && snapshot.browserUrl.length > 0) out.url = snapshot.browserUrl;
-  if (snapshot.text.length > 0) out.text = snapshot.text;
-  return out;
-}
-
 /**
  * Fallback dwell for a lone trailing meeting-app tick on a machine that
  * captured no other snapshot to estimate a cadence from. Five minutes keeps
@@ -341,12 +331,11 @@ export class ActivityWearablesMeetingsDaySource implements MeetingsDaySource {
     const snapshots = this.deps.activity
       ? await this.deps.activity.listSnapshotsForDay(null, startUtc, endUtc)
       : [];
-    const activity = snapshots.map(toMeetingActivitySnapshot);
     const appSpans = deriveAppSpans(snapshots, this.deps.config.appPatterns);
     const bodies = await this.deps.wearables.readDayBodies(date);
     const tzBySource = new Map(bodies.map((b) => [b.source, b.timezone ?? ""] as const));
     const conversations = shiftFusionInputsToUtc(reconstructFusionInputs(date, bodies), tzBySource);
     const audioWindows = buildAudioWindows(conversations);
-    return { detection: { date, appSpans, audioWindows }, conversations, activity };
+    return { detection: { date, appSpans, audioWindows }, conversations, activity: snapshots };
   }
 }

package/src/meetings/fuse.test.ts

@@ -1,13 +1,12 @@
 import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { test } from "node:test";
 
 import { DEFAULT_MEETINGS_CONFIG } from "./config.js";
 import { fuseMeeting } from "./fuse.js";
-import type {
-  DetectedMeeting,
-  MeetingActivitySnapshot,
-  MeetingsConfig,
-} from "./types.js";
+import type { ActivitySnapshot } from "../activity/types.js";
+import type { DetectedMeeting, MeetingsConfig } from "./types.js";
 import type { FusionConversationInput, FusionSegmentInput } from "../wearables/fusion/types.js";
 
 const DATE = "2026-03-10";
@@ -51,8 +50,17 @@ function conv(
   return { source, conversationId: id, startIso, endIso, segments };
 }
 
-function snap(overrides: Partial<MeetingActivitySnapshot> & { tsUtc: string; app: string }): MeetingActivitySnapshot {
-  return { ...overrides };
+function snap(
+  overrides: Partial<ActivitySnapshot> & { capturedAtUtc: string; app: string },
+): ActivitySnapshot {
+  return {
+    machine: "workstation",
+    windowTitle: "",
+    text: "",
+    textSource: "ax",
+    contentHash: "snap-hash",
+    ...overrides,
+  };
 }
 
 test("fusion prefers the higher-trust source in overlap regions and records corroboratedBy without duplicating text", () => {
@@ -97,10 +105,10 @@ test("screen context includes a >=20s dwell and omits a 5s alt-tab; meeting-app
         ]),
       ],
       activity: [
-        snap({ tsUtc: "2026-03-10T14:05:00.000Z", app: "Preview", title: "Q3-roadmap.pdf", text: "Q3 roadmap draft" }),
-        snap({ tsUtc: "2026-03-10T14:05:25.000Z", app: "Notes", title: "scratch" }), // Preview dwell 25s → include; Notes starts
-        snap({ tsUtc: "2026-03-10T14:05:30.000Z", app: "Preview", title: "Q3-roadmap.pdf" }), // Notes dwell 5s → exclude
-        snap({ tsUtc: "2026-03-10T14:10:00.000Z", app: "Zoom", text: "Jane: agenda item one" }), // meeting-app → excerpt
+        snap({ capturedAtUtc: "2026-03-10T14:05:00.000Z", app: "Preview", windowTitle: "Q3-roadmap.pdf", text: "Q3 roadmap draft" }),
+        snap({ capturedAtUtc: "2026-03-10T14:05:25.000Z", app: "Notes", windowTitle: "scratch" }), // Preview dwell 25s → include; Notes starts
+        snap({ capturedAtUtc: "2026-03-10T14:05:30.000Z", app: "Preview", windowTitle: "Q3-roadmap.pdf" }), // Notes dwell 5s → exclude
+        snap({ capturedAtUtc: "2026-03-10T14:10:00.000Z", app: "Zoom", text: "Jane: agenda item one" }), // meeting-app → excerpt
       ],
     },
     config(),
@@ -122,9 +130,9 @@ test("context excerpts respect maxContextChars", () => {
       meeting: meeting(),
       conversations: [],
       activity: [
-        snap({ tsUtc: "2026-03-10T14:01:00.000Z", app: "Zoom", text: "aaaa" }),
-        snap({ tsUtc: "2026-03-10T14:02:00.000Z", app: "Zoom", text: "bbbb" }),
-        snap({ tsUtc: "2026-03-10T14:03:00.000Z", app: "Zoom", text: "cccc" }),
+        snap({ capturedAtUtc: "2026-03-10T14:01:00.000Z", app: "Zoom", text: "aaaa" }),
+        snap({ capturedAtUtc: "2026-03-10T14:02:00.000Z", app: "Zoom", text: "bbbb" }),
+        snap({ capturedAtUtc: "2026-03-10T14:03:00.000Z", app: "Zoom", text: "cccc" }),
       ],
     },
     config({ maxContextChars: 8 }),
@@ -199,10 +207,51 @@ test("a lone trailing other-app snapshot is not inflated to the meeting end", ()
       ],
       // A single Notes snapshot 1 min before the window end. With no later
       // snapshot, the trailing run must NOT count dwell up to the meeting end.
-      activity: [snap({ tsUtc: "2026-03-10T14:29:00.000Z", app: "Notes", title: "scratch" })],
+      activity: [snap({ capturedAtUtc: "2026-03-10T14:29:00.000Z", app: "Notes", windowTitle: "scratch" })],
     },
     config(),
   );
   assert.equal(fused.snapshotCount, 1);
   assert.deepEqual(fused.screenContext, [], "a lone trailing snapshot has zero observed dwell");
 });
+
+test("fusion reads ActivitySnapshot fields — capturedAtUtc, browserUrl runs, windowTitle fallback", () => {
+  const fused = fuseMeeting(
+    {
+      meeting: meeting(),
+      conversations: [],
+      activity: [
+        snap({ capturedAtUtc: "2026-03-10T14:05:00.000Z", app: "Chrome", browserUrl: "https://github.com/org/repo/pull/1" }),
+        snap({ capturedAtUtc: "2026-03-10T14:06:00.000Z", app: "Chrome", browserUrl: "https://github.com/org/repo/pull/1" }),
+        // Different URL on the same app → a separate dwell run.
+        snap({ capturedAtUtc: "2026-03-10T14:06:30.000Z", app: "Chrome", browserUrl: "https://example.com/doc" }),
+        snap({ capturedAtUtc: "2026-03-10T14:07:00.000Z", app: "Chrome", browserUrl: "https://example.com/doc" }),
+        // Empty browserUrl falls back to the window title for key and label.
+        snap({ capturedAtUtc: "2026-03-10T14:07:30.000Z", app: "Chrome", windowTitle: "Spec v2" }),
+        snap({ capturedAtUtc: "2026-03-10T14:08:00.000Z", app: "Chrome", windowTitle: "Spec v2" }),
+      ],
+    },
+    config(),
+  );
+  assert.equal(fused.snapshotCount, 6);
+  assert.deepEqual(
+    fused.screenContext.map((e) => e.label),
+    [
+      "Chrome: github.com/org/repo/pull/1",
+      "Chrome: example.com/doc",
+      "Chrome: Spec v2",
+    ],
+  );
+  // Run dwell ends at the next different-key snapshot (90s, 60s) or, for the
+  // trailing run, at its own last snapshot (30s).
+  assert.deepEqual(fused.screenContext.map((e) => e.dwellSeconds), [90, 60, 30]);
+});
+
+test("MeetingActivitySnapshot and its rename mapper are gone", () => {
+  const here = import.meta.dirname;
+  for (const file of ["types.ts", "fuse.ts", "day-source.ts", "build.ts"]) {
+    const src = readFileSync(join(here, file), "utf8");
+    assert.ok(!src.includes("MeetingActivitySnapshot"), `${file} must not reference MeetingActivitySnapshot`);
+    assert.ok(!src.includes("toMeetingActivitySnapshot"), `${file} must not reference toMeetingActivitySnapshot`);
+  }
+});