@remnic/core 9.66.8 → 9.66.10

package/dist/who-knows.d.ts

@@ -1,6 +1,6 @@
-export { bA as WHO_KNOWS_AUTHORSHIP_BONUS, bB as WHO_KNOWS_DEFAULT_LIMIT, bC as WHO_KNOWS_MAX_EVIDENCE, bD as WHO_KNOWS_MAX_LIMIT, bE as WHO_KNOWS_MCP_TOOLS, bF as WhoKnowsEntity, bG as WhoKnowsEvidence, bH as WhoKnowsHit, bI as WhoKnowsHttpOutcome, W as WhoKnowsResult, bJ as WhoKnowsStorage, bT as computeWhoKnows, bZ as handleWhoKnowsHttpQuery, c2 as loadWhoKnowsEntities, c9 as tokenizeTopic, ca as validateWhoKnowsInput } from './access-service-C2tV2-uL.js';
-import './types-CIpfYz1I.js';
-import './orchestrator-CaqnwNwM.js';
+export { bA as WHO_KNOWS_AUTHORSHIP_BONUS, bB as WHO_KNOWS_DEFAULT_LIMIT, bC as WHO_KNOWS_MAX_EVIDENCE, bD as WHO_KNOWS_MAX_LIMIT, bE as WHO_KNOWS_MCP_TOOLS, bF as WhoKnowsEntity, bG as WhoKnowsEvidence, bH as WhoKnowsHit, bI as WhoKnowsHttpOutcome, W as WhoKnowsResult, bJ as WhoKnowsStorage, bT as computeWhoKnows, bZ as handleWhoKnowsHttpQuery, c2 as loadWhoKnowsEntities, c9 as tokenizeTopic, ca as validateWhoKnowsInput } from './access-service-DcfM0Vf0.js';
+import './types-eM7QIcX2.js';
+import './orchestrator-Btq9lzAN.js';
 import './recall-state.js';
 import './utils/serialize-mutations.js';
 import './search/port.js';
@@ -16,7 +16,7 @@ import './active-context-config.js';
 import './types-continuity.js';
 import './included-memories.js';
 import './briefing.js';
-import './storage-CtsaojWD.js';
+import './storage-6fn7BPmb.js';
 import './corpus-read-cancellation.js';
 import './artifact-search.js';
 import './active-context-transform.js';
@@ -39,8 +39,8 @@ import './resolve-provider-secret.js';
 import './transcript.js';
 import './session-integrity.js';
 import './summarizer.js';
-import './maintenance-BBeaeYRR.js';
-import './catalog-C2jA-gLm.js';
+import './maintenance-BRcc3Hx8.js';
+import './catalog-BmBXTtOs.js';
 import './namespaces/search.js';
 import './compounding/engine.js';
 import './shared-context/manager.js';
@@ -50,7 +50,7 @@ import './utility-runtime.js';
 import './tier-routing.js';
 import './lifecycle.js';
 import './orchestration/compression-guideline-coordinator.js';
-import './semantic-consolidation-BiX68wZA.js';
+import './semantic-consolidation-DW3rEUoW.js';
 import './connectors/codex-materialize.js';
 import './logger.js';
 import './embedding-fallback.js';
@@ -72,10 +72,10 @@ import './conversation-index/chunker.js';
 import './conversation-index/backend.js';
 import './faiss-adapter-BHecI1fF.js';
 import './runtime/child-process.js';
-import './dependency-propagation-delivery-D4WMbOwA.js';
+import './dependency-propagation-delivery-BC3bCEet.js';
 import './namespaces/storage.js';
 import './threading.js';
-import './scope-profiles-DFaojvoP.js';
+import './scope-profiles-DqbxQXIS.js';
 import './graph-444E-DrF.js';
 import './recall-xray.js';
 import './memory-provenance.js';
@@ -88,7 +88,7 @@ import './negative.js';
 import './session-observer-state.js';
 import './semantic-BalR6EXU.js';
 import './replay/types.js';
-import './service-D5h2zZ0M.js';
+import './service-B2vJU_Bx.js';
 import './extraction-judge.js';
 import './lcm/engine.js';
 import './lcm/archive.js';
@@ -110,7 +110,7 @@ import './recall-audit.js';
 import './types-B1VHaf2w.js';
 import './transfer/capsule-import.js';
 import './transfer/types.js';
-import './access-namespace-preflight-50VIkPhB.js';
+import './access-namespace-preflight-S8fhQcCo.js';
 import './access-token-capabilities.js';
 import 'node:async_hooks';
 import './recall-explain-renderer.js';

package/dist/who-knows.js

@@ -9,19 +9,19 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-VYIPVLRX.js";
-import "./chunk-K7NUAY36.js";
+} from "./chunk-QB66LBXA.js";
+import "./chunk-4PHT7KE2.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-4ZWCQJNM.js";
 import "./chunk-WVGXCBOC.js";
-import "./chunk-OERZXNSK.js";
-import "./chunk-6BYJQ3L2.js";
-import "./chunk-YQNNHLCG.js";
-import "./chunk-6KTXE6A3.js";
-import "./chunk-N37X5RU7.js";
+import "./chunk-X5SDZMO7.js";
+import "./chunk-HJQZQUPC.js";
 import "./chunk-NNBZS3DY.js";
 import "./chunk-CYEPCZN5.js";
 import "./chunk-GIC6BASP.js";
+import "./chunk-YQNNHLCG.js";
+import "./chunk-6KTXE6A3.js";
+import "./chunk-N37X5RU7.js";
 import "./chunk-W7IGLX4G.js";
 import "./chunk-GUMZC2BO.js";
 import "./chunk-227UFSEQ.js";
@@ -33,8 +33,8 @@ import "./chunk-XXW32OL7.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-2GF27PGH.js";
 import "./chunk-S2HLHAZ4.js";
-import "./chunk-LDXUBPMO.js";
 import "./chunk-DM2T26WE.js";
+import "./chunk-LDXUBPMO.js";
 import "./chunk-XSTNGNJP.js";
 import "./chunk-AAD2ZS6P.js";
 import "./chunk-LUDBXTBJ.js";
@@ -49,10 +49,10 @@ import "./chunk-RBOJCG4T.js";
 import "./chunk-NNZFPYYX.js";
 import "./chunk-5WITETWU.js";
 import "./chunk-6CIAGZ6X.js";
-import "./chunk-C24UZSFW.js";
+import "./chunk-CEH2AFXG.js";
 import "./chunk-JXN77SGO.js";
-import "./chunk-ZLQ37WJX.js";
 import "./chunk-IUM3VSHI.js";
+import "./chunk-ZLQ37WJX.js";
 import "./chunk-WKAXBXVA.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-C64XATK7.js";

package/dist/write-envelope.d.ts

@@ -1,4 +1,4 @@
-import { y as MemoryCategory, N as MemorySubject } from './types-CIpfYz1I.js';
+import { y as MemoryCategory, N as MemorySubject } from './types-eM7QIcX2.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.66.8",
+  "version": "9.66.10",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3217,7 +3217,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.66.8"
+    "@remnic/coding-graph": "^9.66.10"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/scripts/ensure-better-sqlite3.mjs

@@ -30,6 +30,7 @@ if (!rebuild.ok) {
   console.error(
     "[remnic] Install the package dependencies so node-gyp is available locally, then retry installation.",
   );
+  console.error(recoveryHint());
   process.exit(rebuild.status ?? 1);
 }
 
@@ -41,6 +42,7 @@ try {
   console.error(
     `[remnic] better-sqlite3 rebuild completed but the binding still does not load: ${errorMessage(error)}`,
   );
+  console.error(recoveryHint());
   process.exit(1);
 }
 
@@ -123,3 +125,11 @@ function clearBetterSqlite3RequireCache(packageDir) {
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+
+function recoveryHint() {
+  const nodeMajor = process.versions.node.split(".")[0];
+  return (
+    `[remnic] Recovery: run \`npm rebuild better-sqlite3 --build-from-source\` with Node ${nodeMajor} ` +
+    `(ABI ${process.versions.modules}) — the shipped binding does not match this Node/ABI.`
+  );
+}

package/src/access-mcp-output-schemas.ts

@@ -82,7 +82,7 @@ const TOOL_OUTPUT_SCHEMAS: Readonly<Record<string, Record<string, unknown>>> = {
     skipped: T_NUMBER,
     removed: T_ARRAY,
   }),
-  standup: objectSchema({ date: T_STRING, yesterday: T_STRING, today: T_STRING, highlights: T_ARRAY, blockers: T_ARRAY, activityGrid: T_STRING, markdown: T_STRING }),
+  standup: objectSchema({ date: T_STRING, yesterday: T_STRING, today: T_STRING, highlights: T_ARRAY, priorities: T_ARRAY, blockers: T_ARRAY, activityGrid: T_STRING, markdown: T_STRING }),
   action_confidence: objectSchema({
     schemaVersion: T_NUMBER,
     decision: T_STRING,

package/src/activity/config.test.ts

@@ -17,7 +17,7 @@ test("parseActivityConfig defaults to an inert, search-only configuration", () =
     minConfidence: 0.7,
     minImportance: "normal",
     maxMemoriesPerDay: 0,
-    timeline: { enabled: false, journal: { enabled: false }, qa: { enabled: false, maxRangeDays: 31 } },
+    timeline: { enabled: false, journal: { enabled: false, source: "file" }, qa: { enabled: false, maxRangeDays: 31 } },
   });
   assert.deepEqual(parseActivityConfig(undefined), defaultActivityConfig());
 });

package/src/activity/config.ts

@@ -1,5 +1,6 @@
 import { coerceBooleanLike, coerceNumber } from "../connectors/coerce.js";
 import { assertValidTimezone } from "./digest.js";
+import { resolveJournalSource } from "./journal-source.js";
 import type { ImportanceLevel } from "../types.js";
 import type {
   ActivityConfig,
@@ -29,7 +30,7 @@ export function defaultActivityConfig(): ActivityConfig {
     minConfidence: 0.7,
     minImportance: "normal",
     maxMemoriesPerDay: 0,
-    timeline: { enabled: false, journal: { enabled: false }, qa: { enabled: false, maxRangeDays: 31 } },
+    timeline: { enabled: false, journal: { enabled: false, source: "file" }, qa: { enabled: false, maxRangeDays: 31 } },
   };
 }
 
@@ -200,7 +201,7 @@ export function parseActivityConfig(raw: unknown): ActivityConfig {
  * is malformed and must fail rather than silently disabling the layer.
  */
 function parseTimelineConfig(raw: unknown): ActivityTimelineConfig {
-  if (raw === undefined) return { enabled: false, journal: { enabled: false }, qa: parseTimelineQaConfig(undefined) };
+  if (raw === undefined) return { enabled: false, journal: { enabled: false, source: "file" }, qa: parseTimelineQaConfig(undefined) };
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
     throw new TypeError("activity.timeline must be an object");
   }
@@ -217,7 +218,7 @@ function parseTimelineConfig(raw: unknown): ActivityTimelineConfig {
 }
 
 function parseTimelineJournalConfig(raw: unknown): ActivityTimelineJournalConfig {
-  if (raw === undefined) return { enabled: false };
+  if (raw === undefined) return { enabled: false, source: "file" };
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
     throw new TypeError("activity.timeline.journal must be an object");
   }
@@ -226,7 +227,22 @@ function parseTimelineJournalConfig(raw: unknown): ActivityTimelineJournalConfig
   if (journal.enabled !== undefined && enabledValue === undefined) {
     throw new TypeError("activity.timeline.journal.enabled must be a boolean");
   }
-  return { enabled: enabledValue ?? false };
+  const heading = journal.heading;
+  if (heading !== undefined && typeof heading !== "string") {
+    throw new TypeError("activity.timeline.journal.heading must be a string");
+  }
+  const source = journal.source === undefined ? "file" : typeof journal.source === "string" ? journal.source : "";
+  const resolved = resolveJournalSource({ source, heading: heading ?? "" });
+  if (!resolved.ok) {
+    if (resolved.error === "unknown_source") {
+      throw new RangeError('activity.timeline.journal.source must be one of "file", "vault"');
+    }
+    throw new RangeError('activity.timeline.journal.heading must be a non-empty string when source is "vault"');
+  }
+  if (resolved.mode === "vault") {
+    return { enabled: enabledValue ?? false, source: "vault", heading: resolved.heading };
+  }
+  return { enabled: enabledValue ?? false, source: "file" };
 }
 
 function parseTimelineQaConfig(raw: unknown): ActivityTimelineQaConfig {

package/src/activity/index.ts

@@ -19,9 +19,11 @@ export * from "./journal.js";
 export * from "./journal-vault-read.js";
 export * from "./memory-gen.js";
 export * from "./privacy.js";
+export * from "./privacy-status.js";
 export * from "./privacy-window.js";
 export * from "./vault-path.js";
 export * from "./vault-publish.js";
+export * from "./vault-insert.js";
 export * from "./vault-frontmatter.js";
 export * from "./vault-wikilink.js";
 export * from "./vault-region.js";

package/src/activity/journal.test.ts

@@ -32,6 +32,46 @@ test("activity.timeline.journal.enabled defaults off", () => {
   );
 });
 
+test("activity.timeline.journal source defaults to file with no heading", () => {
+  const journal = parseActivityConfig(undefined).timeline.journal;
+  assert.equal(journal.source, "file");
+  assert.equal(journal.heading, undefined);
+});
+
+test("activity.timeline.journal vault mode trims and stores the heading", () => {
+  const journal = parseActivityConfig({ timeline: { journal: { enabled: true, source: "vault", heading: " Journal " } } }).timeline.journal;
+  assert.deepEqual(journal, { enabled: true, source: "vault", heading: "Journal" });
+});
+
+test("activity.timeline.journal vault mode requires a non-empty heading", () => {
+  for (const heading of [undefined, "", "   "]) {
+    assert.throws(
+      () => parseActivityConfig({ timeline: { journal: { source: "vault", heading } } }),
+      RangeError,
+    );
+  }
+});
+
+test("activity.timeline.journal rejects an unknown source", () => {
+  assert.throws(
+    () => parseActivityConfig({ timeline: { journal: { source: "memoryDir" } } }),
+    /activity\.timeline\.journal\.source must be one of "file", "vault"/,
+  );
+});
+
+test("activity.timeline.journal rejects a non-string heading", () => {
+  assert.throws(
+    () => parseActivityConfig({ timeline: { journal: { heading: 5 } } }),
+    /activity\.timeline\.journal\.heading must be a string/,
+  );
+});
+
+test("activity.timeline.journal file mode ignores a provided heading", () => {
+  const journal = parseActivityConfig({ timeline: { journal: { source: "file", heading: "Ignored" } } }).timeline.journal;
+  assert.deepEqual(journal, { enabled: false, source: "file" });
+  assert.equal("heading" in journal, false);
+});
+
 test("seed is a hard no-op without force", () => {
   withMemoryDir((memoryDir) => {
     const first = seedJournal({

package/src/activity/privacy-status.test.ts

@@ -0,0 +1,117 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { ACTIVITY_ANALYSIS_STATUSES, buildActivityHealth } from "./privacy-status.js";
+
+const base = {
+  enabled: true,
+  retentionDays: 30,
+  sourceRevision: "rev-42",
+  lastAnalysisStatus: "ok",
+  observationCount: 7,
+  cardCount: 3,
+} as const;
+
+test("enabled true returns full snapshot with trimmed revision", () => {
+  const snapshot = buildActivityHealth({ ...base, sourceRevision: "  rev-42  " });
+  assert.deepEqual(snapshot, {
+    enabled: true,
+    retentionDays: 30,
+    sourceRevision: "rev-42",
+    lastAnalysisStatus: "ok",
+    observationCount: 7,
+    cardCount: 3,
+  });
+});
+
+test("snapshot keys equal the documented set", () => {
+  const snapshot = buildActivityHealth({ ...base });
+  assert.deepEqual(Object.keys(snapshot), [
+    "enabled",
+    "retentionDays",
+    "sourceRevision",
+    "lastAnalysisStatus",
+    "observationCount",
+    "cardCount",
+  ]);
+});
+
+test("enabled false still returns snapshot with counts as given", () => {
+  const snapshot = buildActivityHealth({
+    ...base,
+    enabled: false,
+    observationCount: 9,
+    cardCount: 0,
+  });
+  assert.equal(snapshot.enabled, false);
+  assert.equal(snapshot.retentionDays, 30);
+  assert.equal(snapshot.observationCount, 9);
+  assert.equal(snapshot.cardCount, 0);
+});
+
+test("retentionDays 0 (keep forever) is preserved", () => {
+  assert.equal(buildActivityHealth({ ...base, retentionDays: 0 }).retentionDays, 0);
+});
+
+test("retentionDays must be a non-negative integer", () => {
+  assert.throws(
+    () => buildActivityHealth({ ...base, retentionDays: -1 }),
+    { name: "RangeError", message: /retentionDays/ },
+  );
+  assert.throws(() => buildActivityHealth({ ...base, retentionDays: 1.5 }), /retentionDays/);
+});
+
+test("null or missing sourceRevision maps to null", () => {
+  const nulled = buildActivityHealth({ ...base, sourceRevision: null });
+  const missing = buildActivityHealth({ ...base, sourceRevision: undefined });
+  assert.equal(nulled.sourceRevision, null);
+  assert.equal(missing.sourceRevision, null);
+});
+
+test("trimmed-blank sourceRevision maps to null", () => {
+  const blank = buildActivityHealth({ ...base, sourceRevision: "   \t " });
+  const empty = buildActivityHealth({ ...base, sourceRevision: "" });
+  assert.equal(blank.sourceRevision, null);
+  assert.equal(empty.sourceRevision, null);
+});
+
+test("missing lastAnalysisStatus defaults to never", () => {
+  const missing = buildActivityHealth({ ...base, lastAnalysisStatus: undefined });
+  const nulled = buildActivityHealth({ ...base, lastAnalysisStatus: null });
+  assert.equal(missing.lastAnalysisStatus, "never");
+  assert.equal(nulled.lastAnalysisStatus, "never");
+});
+
+test("each allow-list status round-trips", () => {
+  for (const status of ACTIVITY_ANALYSIS_STATUSES) {
+    const snapshot = buildActivityHealth({ ...base, lastAnalysisStatus: status });
+    assert.equal(snapshot.lastAnalysisStatus, status);
+  }
+});
+
+test("unknown analysis status throws listing the allow-list", () => {
+  assert.throws(
+    () => buildActivityHealth({ ...base, lastAnalysisStatus: "pending" }),
+    (err: unknown) => {
+      assert.ok(err instanceof TypeError);
+      assert.match(err.message, /analysis status/);
+      for (const status of ACTIVITY_ANALYSIS_STATUSES) {
+        assert.ok(err.message.includes(status), `message lists ${status}`);
+      }
+      return true;
+    },
+  );
+});
+
+test("negative or non-integer counts throw", () => {
+  assert.throws(
+    () => buildActivityHealth({ ...base, observationCount: -1 }),
+    { name: "RangeError", message: /count/ },
+  );
+  assert.throws(
+    () => buildActivityHealth({ ...base, cardCount: -2 }),
+    { name: "RangeError", message: /count/ },
+  );
+  assert.throws(() => buildActivityHealth({ ...base, observationCount: 1.5 }), /count/);
+  assert.throws(() => buildActivityHealth({ ...base, cardCount: Number.NaN }), /count/);
+});

package/src/activity/privacy-status.ts

@@ -0,0 +1,65 @@
+/**
+ * Content-free activity health snapshot (issue #2053 slice).
+ *
+ * Pure status builder. Surfaces report gate state, retention policy, source
+ * revision, last analysis outcome, and counts only — never observation or
+ * card content, prompts, or media.
+ */
+
+export const ACTIVITY_ANALYSIS_STATUSES = ["ok", "failed", "skipped", "never"] as const;
+export type ActivityAnalysisStatus = (typeof ACTIVITY_ANALYSIS_STATUSES)[number];
+
+export interface ActivityHealthSnapshot {
+  enabled: boolean;
+  retentionDays: number;
+  sourceRevision: string | null;
+  lastAnalysisStatus: ActivityAnalysisStatus;
+  observationCount: number;
+  cardCount: number;
+}
+
+const STATUS_ALLOW_LIST = ACTIVITY_ANALYSIS_STATUSES.join(", ");
+
+/**
+ * Build the health snapshot. Master `enabled: false` still returns a snapshot
+ * (surfaces must report the gate); counts stay as given and are never redacted.
+ */
+export function buildActivityHealth(input: {
+  enabled: boolean;
+  retentionDays: number;
+  sourceRevision?: string | null;
+  lastAnalysisStatus?: string | null;
+  observationCount: number;
+  cardCount: number;
+}): ActivityHealthSnapshot {
+  const { enabled, retentionDays, observationCount, cardCount } = input;
+  if (!Number.isInteger(retentionDays) || retentionDays < 0) {
+    throw new RangeError("retentionDays must be a non-negative integer");
+  }
+  if (!Number.isInteger(observationCount) || observationCount < 0) {
+    throw new RangeError("invalid count: observationCount must be a non-negative integer");
+  }
+  if (!Number.isInteger(cardCount) || cardCount < 0) {
+    throw new RangeError("invalid count: cardCount must be a non-negative integer");
+  }
+  const rawRevision = input.sourceRevision;
+  const trimmedRevision = typeof rawRevision === "string" ? rawRevision.trim() : "";
+  const rawStatus = input.lastAnalysisStatus;
+  let lastAnalysisStatus: ActivityAnalysisStatus = "never";
+  if (rawStatus !== undefined && rawStatus !== null) {
+    if (!(ACTIVITY_ANALYSIS_STATUSES as readonly string[]).includes(rawStatus)) {
+      throw new TypeError(
+        `unknown analysis status ${JSON.stringify(rawStatus)}; expected one of: ${STATUS_ALLOW_LIST}`,
+      );
+    }
+    lastAnalysisStatus = rawStatus as ActivityAnalysisStatus;
+  }
+  return {
+    enabled,
+    retentionDays,
+    sourceRevision: trimmedRevision === "" ? null : trimmedRevision,
+    lastAnalysisStatus,
+    observationCount,
+    cardCount,
+  };
+}

package/src/activity/timeline/index.ts

@@ -14,8 +14,10 @@ export * from "./recap-export.js";
 export * from "./recap-markdown.js";
 export * from "./week-export.js";
 export * from "./week-snapshot.js";
+export * from "./week-previous.js";
 export * from "./analysis-batch.js";
 export * from "./analysis-evidence.js";
 export * from "./analysis-prompt.js";
 export * from "./analysis-claim.js";
 export * from "./analysis-order.js";
+export * from "./recap-window.js";

package/src/activity/timeline/recap-window.test.ts

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import {
+  clipCardsToRecapWindow,
+  type RecapWindowCard,
+} from "./recap-window.js";
+
+const MINUTE = 60_000;
+const DAY_START = Date.UTC(2026, 0, 15); // 2026-01-15T00:00:00Z
+const DAY_END = DAY_START + 24 * 60 * 60_000;
+
+const iso = (ms: number): string => new Date(ms).toISOString();
+
+const card = (id: string, startMs: number, endMs: number): RecapWindowCard => ({
+  id,
+  startUtc: iso(startMs),
+  endUtc: iso(endMs),
+});
+
+describe("clipCardsToRecapWindow", () => {
+  it("returns [] for empty input", () => {
+    assert.deepEqual(clipCardsToRecapWindow([], DAY_START, DAY_END), []);
+  });
+
+  it("excludes a card ending exactly at windowStart and one starting exactly at windowEnd", () => {
+    const before = card("before", DAY_START - 2 * MINUTE, DAY_START);
+    const after = card("after", DAY_END, DAY_END + 2 * MINUTE);
+    const inside = card("inside", DAY_START, DAY_END);
+
+    const result = clipCardsToRecapWindow([before, after, inside], DAY_START, DAY_END);
+
+    assert.deepEqual(
+      result.map((c) => c.id),
+      ["inside"],
+    );
+    assert.equal(result[0]?.startMs, DAY_START);
+    assert.equal(result[0]?.endMs, DAY_END);
+    assert.equal(result[0]?.durationMs, DAY_END - DAY_START);
+
+    // Each midnight-touching card lands in exactly one adjacent window.
+    const windowMs = DAY_END - DAY_START;
+    const prevDay = clipCardsToRecapWindow([before], DAY_START - windowMs, DAY_START);
+    const nextDay = clipCardsToRecapWindow([after], DAY_END, DAY_END + windowMs);
+    assert.equal(prevDay[0]?.id, "before");
+    assert.equal(nextDay[0]?.id, "after");
+  });
+
+  it("clips a card straddling the window start", () => {
+    const straddle = card("straddle", DAY_START - 30 * MINUTE, DAY_START + 90 * MINUTE);
+
+    const result = clipCardsToRecapWindow([straddle], DAY_START, DAY_END);
+
+    assert.equal(result.length, 1);
+    assert.equal(result[0]?.startMs, DAY_START);
+    assert.equal(result[0]?.endMs, DAY_START + 90 * MINUTE);
+    assert.equal(result[0]?.durationMs, 90 * MINUTE);
+  });
+
+  it("clips a card straddling the window end", () => {
+    const straddle = card("tail", DAY_END - 5 * MINUTE, DAY_END + 45 * MINUTE);
+
+    const result = clipCardsToRecapWindow([straddle], DAY_START, DAY_END);
+
+    assert.equal(result.length, 1);
+    assert.equal(result[0]?.endMs, DAY_END);
+    assert.equal(result[0]?.durationMs, 5 * MINUTE);
+  });
+
+  it("skips cards with unparseable timestamps without throwing", () => {
+    const good = card("good", DAY_START + MINUTE, DAY_START + 10 * MINUTE);
+    const bad: RecapWindowCard[] = [
+      { id: "bad-start", startUtc: "not-a-date", endUtc: iso(DAY_START + 5 * MINUTE) },
+      { id: "bad-end", startUtc: iso(DAY_START), endUtc: "" },
+      good,
+    ];
+
+    const result = clipCardsToRecapWindow(bad, DAY_START, DAY_END);
+
+    assert.deepEqual(
+      result.map((c) => c.id),
+      ["good"],
+    );
+    assert.equal(result[0]?.durationMs, 9 * MINUTE);
+  });
+
+  it("throws RangeError on inverted or empty window", () => {
+    assert.throws(
+      () => clipCardsToRecapWindow([], DAY_END, DAY_START),
+      RangeError,
+    );
+    assert.throws(
+      () => clipCardsToRecapWindow([], DAY_START, DAY_START),
+      RangeError,
+    );
+  });
+
+  it("throws RangeError on non-finite window bounds", () => {
+    // NaN and Infinity pass `end <= start`, so without an explicit finite
+    // check they would produce NaN timestamps instead of an error.
+    for (const [start, end] of [
+      [Number.NaN, DAY_END],
+      [DAY_START, Number.NaN],
+      [Number.POSITIVE_INFINITY, DAY_END],
+      [DAY_START, Number.POSITIVE_INFINITY],
+    ] as const) {
+      assert.throws(() => clipCardsToRecapWindow([], start, end), /finite/);
+    }
+  });
+
+  it("sorts by startMs then id, byte-identical across calls", () => {
+    const same = DAY_START + 60 * MINUTE;
+    const cards: RecapWindowCard[] = [
+      card("z-late", DAY_START + 120 * MINUTE, DAY_START + 130 * MINUTE),
+      card("b-tie", same, same + 10 * MINUTE),
+      card("a-tie", same, same + 10 * MINUTE),
+      card("early", DAY_START + 5 * MINUTE, DAY_START + 6 * MINUTE),
+    ];
+
+    const first = clipCardsToRecapWindow(cards, DAY_START, DAY_END);
+    const second = clipCardsToRecapWindow(cards, DAY_START, DAY_END);
+
+    assert.deepEqual(
+      first.map((c) => c.id),
+      ["early", "a-tie", "b-tie", "z-late"],
+    );
+    assert.deepEqual(first, second);
+  });
+});