@remnic/core 9.69.46 → 9.69.47

package/src/access-surface-catalog.test.ts

@@ -378,6 +378,26 @@ function extractHttpRouteDispatchMap(): Map<string, Set<string>> {
       }
     }
   }
+
+  // Memory-store browse routes (issue #2978): same seam — access-http.ts
+  // delegates to maybeRespondMemoryBrowse; the boundary dispatch markers
+  // live per-route in memory-browse-http-glue.ts.
+  if (/\bawait\s+maybeRespondMemoryBrowse\(/.test(source)) {
+    const browseSource = readFileSync(
+      new URL("./memory-browse-http-glue.ts", import.meta.url),
+      "utf-8",
+    );
+    const browseRoutes = [
+      ["POST", "/engram/v1/memory/ls", "memory_ls"],
+      ["POST", "/engram/v1/memory/tree", "memory_tree"],
+      ["POST", "/engram/v1/memory/find", "memory_find"],
+    ] as const;
+    for (const [method, pathname, operation] of browseRoutes) {
+      if (browseSource.includes(`"${pathname}"`) && browseSource.includes(`enforceTokenOp("${operation}")`)) {
+        routeOps.set(`${method} ${pathname}`, new Set([operation]));
+      }
+    }
+  }
   for (const [sourcePath, routes] of [
     ["./support-passport/access-http.ts", SUPPORT_PASSPORT_OWNER_HTTP_ROUTES],
     ["./support-passport/public-http.ts", SUPPORT_PASSPORT_PUBLIC_HTTP_ROUTES],

package/src/access-surface-catalog.ts

@@ -74,6 +74,9 @@ export const MCP_TOOLS: readonly McpToolEntry[] = [
   { tool: "deep_recall", operation: "deep_recall" },
   { tool: "memory_expand", operation: "memory_expand" },
   { tool: "memory_traverse", operation: "memory_traverse" },
+  { tool: "memory_ls", operation: "memory_ls" },
+  { tool: "memory_tree", operation: "memory_tree" },
+  { tool: "memory_find", operation: "memory_find" },
   { tool: "standup", operation: "standup" },
   { tool: "action_confidence", operation: "action_confidence" },
   { tool: "chatgpt_memory_inspector", operation: "chatgpt_memory_inspector" },
@@ -241,6 +244,9 @@ export const HTTP_ROUTES: readonly HttpRouteEntry[] = [
   { method: "POST", pathname: "/engram/v1/recall/deep", operation: "deep_recall" },
   { method: "POST", pathname: "/engram/v1/memory/expand", operation: "memory_expand" },
   { method: "POST", pathname: "/engram/v1/memory/traverse", operation: "memory_traverse" },
+  { method: "POST", pathname: "/engram/v1/memory/ls", operation: "memory_ls" },
+  { method: "POST", pathname: "/engram/v1/memory/tree", operation: "memory_tree" },
+  { method: "POST", pathname: "/engram/v1/memory/find", operation: "memory_find" },
   { method: "GET", pathname: "/engram/v1/standup", operation: "standup" },
   { method: "POST", pathname: "/engram/v1/observe", operation: "observe" },
   { method: "POST", pathname: "/engram/v1/lcm/search", operation: "lcm_search" },

package/src/activity/timeline/index.ts

@@ -14,6 +14,7 @@ export * from "./analysis-provider.js";
 export * from "./analysis-run.js";
 export * from "./regenerate.js";
 export * from "./recap-export.js";
+export * from "./recap-export-range.js";
 export * from "./recap-markdown.js";
 export * from "./week-export.js";
 export * from "./week-snapshot.js";

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

@@ -3,6 +3,7 @@ import test from "node:test";
 
 import type { TimelineCard } from "./types.js";
 import { renderDeterministicJournal } from "./journal-recap.js";
+import { projectCardForRecapExport } from "./recap-export.js";
 
 const DATE = "2026-08-17";
 const TZ = "UTC";
@@ -111,3 +112,19 @@ test("recap does not invent people or mood claims", () => {
   assert.match(body, /Terminal/);
   assert.match(body, /Idle/);
 });
+
+test("a privacy-projected card without a title renders its id", () => {
+  const projected = projectCardForRecapExport(
+    card({
+      id: "act-redacted",
+      title: "Secret Window Title",
+      startUtc: "2026-08-17T14:00:00.000Z",
+      endUtc: "2026-08-17T15:00:00.000Z",
+    }),
+    false,
+  );
+  const body = renderDeterministicJournal([projected], { date: DATE, timezone: TZ });
+  assert.equal(body.includes("Secret Window Title"), false);
+  assert.equal(body.includes("undefined"), false);
+  assert.equal(body.includes("- 60m act-redacted"), true);
+});

package/src/activity/timeline/journal-recap.ts

@@ -6,15 +6,28 @@
  * valid file body. Does not invent people, mood, or productivity claims.
  */
 import { activityDayWindow } from "../digest.js";
-import type { TimelineCard } from "./types.js";
+import type { TimelineCardKind } from "./types.js";
 
+/**
+ * Minimal card shape the renderer reads. `TimelineCard` is assignable, and
+ * so is the privacy-projected export card whose `title` is stripped
+ * (issue #2051): a title-less card renders its stable id instead.
+ */
+export interface JournalRenderCard {
+  id: string;
+  kind: TimelineCardKind;
+  title?: string;
+  categoryId: string;
+  startUtc: string;
+  endUtc: string;
+}
 export interface DeterministicJournalOptions {
   date: string;
   timezone: string;
 }
 
 interface ClippedCard {
-  card: TimelineCard;
+  card: JournalRenderCard;
   startMs: number;
   endMs: number;
   durationMs: number;
@@ -25,7 +38,7 @@ function formatMinutes(ms: number): string {
 }
 
 function clipToWindow(
-  cards: readonly TimelineCard[],
+  cards: readonly JournalRenderCard[],
   winStart: number,
   winEnd: number,
 ): ClippedCard[] {
@@ -42,7 +55,7 @@ function clipToWindow(
   clipped.sort((left, right) => {
     const byStart = left.startMs - right.startMs;
     if (byStart !== 0) return byStart;
-    const byTitle = left.card.title.localeCompare(right.card.title);
+    const byTitle = (left.card.title ?? "").localeCompare(right.card.title ?? "");
     if (byTitle !== 0) return byTitle;
     return left.card.id.localeCompare(right.card.id);
   });
@@ -91,7 +104,7 @@ function countGaps(
 
 /** Render a byte-stable Markdown journal for one local day. */
 export function renderDeterministicJournal(
-  cards: readonly TimelineCard[],
+  cards: readonly JournalRenderCard[],
   options: DeterministicJournalOptions,
 ): string {
   const window = activityDayWindow(options.date, options.timezone);
@@ -108,7 +121,7 @@ export function renderDeterministicJournal(
   const cardLines =
     clipped.length === 0
       ? ["_No cards._"]
-      : clipped.map((row) => `- ${formatMinutes(row.durationMs)} ${row.card.title}`);
+      : clipped.map((row) => `- ${formatMinutes(row.durationMs)} ${row.card.title ?? row.card.id}`);
   return [
     `# Journal — ${options.date} (${options.timezone})`,
     "",

package/src/activity/timeline/recap-export-range.test.ts

@@ -0,0 +1,289 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { TimelineCard } from "./types.js";
+import {
+  DEFAULT_RECAP_RANGE_MAX_DAYS,
+  exportDeterministicRecapRange,
+  renderDeterministicJournalRange,
+} from "./recap-export-range.js";
+import { renderDeterministicJournal } from "./journal-recap.js";
+
+const TZ = "UTC";
+
+function card(
+  overrides: Partial<TimelineCard> & Pick<TimelineCard, "id" | "dayKey">,
+): TimelineCard {
+  return {
+    kind: "activity",
+    title: "Untitled",
+    summary: "none",
+    categoryId: "development",
+    confidence: 1,
+    startUtc: `${overrides.dayKey}T09:00:00.000Z`,
+    endUtc: `${overrides.dayKey}T10:00:00.000Z`,
+    timezone: TZ,
+    machine: "ws-a",
+    evidenceIds: [],
+    evidenceRange: null,
+    ...overrides,
+  };
+}
+
+function okRange(options: Parameters<typeof exportDeterministicRecapRange>[0]) {
+  const result = exportDeterministicRecapRange(options);
+  assert.equal(result.ok, true);
+  assert.ok(result.ok);
+  return result.range;
+}
+
+test("empty range days are exported with empty card lists", () => {
+  const range = okRange({
+    startDate: "2026-08-17",
+    endDate: "2026-08-18",
+    timezone: TZ,
+    cards: [],
+  });
+  assert.deepEqual(
+    range.days.map((d) => [d.date, d.cards.length]),
+    [
+      ["2026-08-17", 0],
+      ["2026-08-18", 0],
+    ],
+  );
+});
+
+test("cards land on their dayKey; out-of-range cards are dropped", () => {
+  const range = okRange({
+    startDate: "2026-08-17",
+    endDate: "2026-08-18",
+    timezone: TZ,
+    cards: [
+      card({ id: "b", dayKey: "2026-08-18" }),
+      card({ id: "a", dayKey: "2026-08-17" }),
+      card({ id: "x", dayKey: "2026-08-16" }),
+      card({ id: "y", dayKey: "2026-08-19" }),
+    ],
+  });
+  assert.deepEqual(
+    range.days.map((d) => d.cards.map((c) => c.id)),
+    [["a"], ["b"]],
+  );
+});
+
+test("determinism: same inputs, shuffled card order, identical JSON bytes", () => {
+  const cards = [
+    card({ id: "c2", dayKey: "2026-08-17" }),
+    card({ id: "c1", dayKey: "2026-08-18" }),
+    card({ id: "c3", dayKey: "2026-08-17" }),
+  ];
+  const first = JSON.stringify(
+    exportDeterministicRecapRange({
+      startDate: "2026-08-17",
+      endDate: "2026-08-18",
+      timezone: TZ,
+      cards,
+    }),
+  );
+  const second = JSON.stringify(
+    exportDeterministicRecapRange({
+      startDate: "2026-08-17",
+      endDate: "2026-08-18",
+      timezone: TZ,
+      cards: [cards[1], cards[2], cards[0]],
+    }),
+  );
+  assert.equal(first, second);
+  assert.equal(
+    first,
+    JSON.stringify(
+      exportDeterministicRecapRange({
+        startDate: "2026-08-17",
+        endDate: "2026-08-18",
+        timezone: TZ,
+        cards,
+      }),
+    ),
+  );
+});
+
+test("privacy boundary: titles are omitted by default in range exports", () => {
+  const range = okRange({
+    startDate: "2026-08-17",
+    endDate: "2026-08-17",
+    timezone: TZ,
+    cards: [card({ id: "a", dayKey: "2026-08-17", title: "Secret Window Title" })],
+  });
+  const json = JSON.stringify(range);
+  assert.equal(json.includes("Secret Window Title"), false);
+  assert.equal(range.days[0].cards[0].title, undefined);
+});
+
+test("privacy boundary: includeObservations keeps titles in range exports", () => {
+  const range = okRange({
+    startDate: "2026-08-17",
+    endDate: "2026-08-17",
+    timezone: TZ,
+    cards: [card({ id: "a", dayKey: "2026-08-17", title: "Secret Window Title" })],
+    includeObservations: true,
+  });
+  assert.equal(range.days[0].cards[0].title, "Secret Window Title");
+});
+
+test("markdown: redacted days render card ids, never titles", () => {
+  const rendered = renderDeterministicJournalRange({
+    startDate: "2026-08-17",
+    endDate: "2026-08-17",
+    timezone: TZ,
+    cards: [card({ id: "card-a", dayKey: "2026-08-17", title: "Secret Window Title" })],
+  });
+  assert.ok(rendered.ok);
+  assert.ok(rendered.ok);
+  assert.equal(rendered.markdown.includes("Secret Window Title"), false);
+  assert.equal(rendered.markdown.includes("- 60m card-a"), true);
+});
+
+test("markdown: a single-day range equals the single-day renderer", () => {
+  const cards = [card({ id: "a", dayKey: "2026-08-17", title: "Terminal" })];
+  const rendered = renderDeterministicJournalRange({
+    startDate: "2026-08-17",
+    endDate: "2026-08-17",
+    timezone: TZ,
+    cards,
+    includeObservations: true,
+  });
+  assert.ok(rendered.ok);
+  assert.ok(rendered.ok);
+  assert.equal(
+    rendered.markdown,
+    renderDeterministicJournal(cards, { date: "2026-08-17", timezone: TZ }),
+  );
+});
+
+test("markdown: multi-day ranges emit ascending per-day sections", () => {
+  const rendered = renderDeterministicJournalRange({
+    startDate: "2026-08-17",
+    endDate: "2026-08-19",
+    timezone: TZ,
+    cards: [],
+  });
+  assert.ok(rendered.ok);
+  assert.ok(rendered.ok);
+  assert.equal(rendered.dayCount, 3);
+  const headings = rendered.markdown
+    .split("\n")
+    .filter((line) => line.startsWith("# Journal — "));
+  assert.deepEqual(headings, [
+    "# Journal — 2026-08-17 (UTC)",
+    "# Journal — 2026-08-18 (UTC)",
+    "# Journal — 2026-08-19 (UTC)",
+  ]);
+});
+
+test("invalid and inverted ranges fail with typed errors", () => {
+  const cases: Array<
+    [Parameters<typeof exportDeterministicRecapRange>[0], string]
+  > = [
+    [{ startDate: "", endDate: "2026-08-18", timezone: TZ, cards: [] }, "invalid_start_date"],
+    [{ startDate: "2026-8-17", endDate: "2026-08-18", timezone: TZ, cards: [] }, "invalid_start_date"],
+    [{ startDate: "2026-02-30", endDate: "2026-03-01", timezone: TZ, cards: [] }, "invalid_start_date"],
+    [{ startDate: "2026-08-17", endDate: "2026-13-01", timezone: TZ, cards: [] }, "invalid_end_date"],
+    [{ startDate: "2026-08-18", endDate: "2026-08-17", timezone: TZ, cards: [] }, "end_before_start"],
+  ];
+  for (const [options, error] of cases) {
+    const result = exportDeterministicRecapRange(options);
+    assert.equal(result.ok, false, JSON.stringify(options));
+    assert.ok(!result.ok);
+    assert.deepEqual(
+      { error: result.error, limit: result.limit },
+      { error, limit: undefined },
+    );
+  }
+});
+
+test("range bound: spans past the default 366 days fail with the limit", () => {
+  const result = exportDeterministicRecapRange({
+    startDate: "2026-01-01",
+    endDate: "2027-01-02",
+    timezone: TZ,
+    cards: [],
+  });
+  assert.ok(!result.ok);
+  assert.deepEqual(
+    { error: result.error, limit: result.limit },
+    { error: "range_too_large", limit: DEFAULT_RECAP_RANGE_MAX_DAYS },
+  );
+  // Exactly the bound still passes.
+  const atBound = exportDeterministicRecapRange({
+    startDate: "2026-01-01",
+    endDate: "2026-12-31",
+    timezone: TZ,
+    cards: [],
+  });
+  assert.ok(atBound.ok);
+  assert.ok(atBound.ok);
+  assert.equal(atBound.range.days.length, 365);
+});
+
+test("range bound: maxDays override is enforced and validated", () => {
+  const denied = exportDeterministicRecapRange({
+    startDate: "2026-08-17",
+    endDate: "2026-08-20",
+    timezone: TZ,
+    cards: [],
+    maxDays: 2,
+  });
+  assert.ok(!denied.ok);
+  assert.equal(denied.error, "range_too_large");
+  assert.equal(denied.limit, 2);
+  assert.throws(
+    () =>
+      exportDeterministicRecapRange({
+        startDate: "2026-08-17",
+        endDate: "2026-08-17",
+        timezone: TZ,
+        cards: [],
+        maxDays: 0,
+      }),
+    RangeError,
+  );
+});
+
+test("a card spanning midnight attributes only to its stored dayKey", () => {
+  const range = okRange({
+    startDate: "2026-08-17",
+    endDate: "2026-08-18",
+    timezone: TZ,
+    cards: [
+      card({
+        id: "spans",
+        dayKey: "2026-08-17",
+        startUtc: "2026-08-17T23:00:00.000Z",
+        endUtc: "2026-08-18T01:00:00.000Z",
+      }),
+    ],
+    includeObservations: true,
+  });
+  assert.deepEqual(
+    range.days.map((d) => d.cards.map((c) => c.id)),
+    [["spans"], []],
+  );
+  // The markdown render clips the spanning card to each day window: it
+  // contributes 60m to day 1 and nothing to day 2.
+  const day2 = renderDeterministicJournalRange({
+    startDate: "2026-08-18",
+    endDate: "2026-08-18",
+    timezone: TZ,
+    cards: [
+      card({
+        id: "spans",
+        dayKey: "2026-08-17",
+        startUtc: "2026-08-17T23:00:00.000Z",
+        endUtc: "2026-08-18T01:00:00.000Z",
+      }),
+    ],
+  });
+  assert.ok(day2.ok);
+  assert.ok(day2.ok);
+  assert.equal(day2.markdown.includes("- 60m spans"), false);
+});

package/src/activity/timeline/recap-export-range.ts

@@ -0,0 +1,169 @@
+/**
+ * Deterministic recap export over a bounded date range (issue #2051).
+ *
+ * Pure: cards + inclusive [startDate, endDate] + timezone in, stable JSON or
+ * Markdown out. No LLM, no I/O. Every date in the range gets a day entry —
+ * empty days included — and cards land on their stored `dayKey`, so reruns
+ * with the same inputs always produce the same bytes regardless of input
+ * card order. Cards whose `dayKey` falls outside the range are not exported.
+ *
+ * The range is bounded: at most `maxDays` days (default 366) per call, so a
+ * swapped start/end or a multi-year span fails with a typed error instead of
+ * producing an unbounded document.
+ */
+import { isValidActivityDate } from "../digest.js";
+import { parseRecapDate } from "./recap-date.js";
+import { renderDeterministicJournal } from "./journal-recap.js";
+import {
+  projectCardForRecapExport,
+  type RecapExportCard,
+} from "./recap-export.js";
+import type { TimelineCard } from "./types.js";
+
+export const DEFAULT_RECAP_RANGE_MAX_DAYS = 366;
+
+export interface DeterministicRecapRangeOptions {
+  /** Inclusive first local day, YYYY-MM-DD. */
+  startDate: string;
+  /** Inclusive last local day, YYYY-MM-DD. */
+  endDate: string;
+  timezone: string;
+  cards: readonly TimelineCard[];
+  /** Include observation-derived card content (`title`). Default false. */
+  includeObservations?: boolean;
+  /** Hard upper bound on exported days; default 366. */
+  maxDays?: number;
+}
+
+export interface DeterministicRecapDay {
+  date: string;
+  timezone: string;
+  cards: RecapExportCard[];
+}
+
+export interface DeterministicRecapRange {
+  startDate: string;
+  endDate: string;
+  timezone: string;
+  days: DeterministicRecapDay[];
+}
+
+export type DeterministicRecapRangeResult =
+  | { ok: true; range: DeterministicRecapRange }
+  | {
+      ok: false;
+      error:
+        | "invalid_start_date"
+        | "invalid_end_date"
+        | "end_before_start"
+        | "range_too_large";
+      /** The enforced day bound, present on range_too_large. */
+      limit?: number;
+    };
+
+export type DeterministicRecapRangeMarkdownResult =
+  | { ok: true; markdown: string; dayCount: number }
+  | Extract<DeterministicRecapRangeResult, { ok: false }>;
+
+function compareCardIds(a: RecapExportCard, b: RecapExportCard): number {
+  if (a.id < b.id) return -1;
+  if (a.id > b.id) return 1;
+  return 0;
+}
+
+/** UTC-midnight stepping over validated real calendar dates. */
+function* isoDays(startDate: string, endDate: string): Generator<string> {
+  const endMs = Date.parse(`${endDate}T00:00:00Z`);
+  let cursor = new Date(`${startDate}T00:00:00Z`);
+  while (cursor.getTime() <= endMs) {
+    yield cursor.toISOString().slice(0, 10);
+    cursor = new Date(cursor.getTime() + 86_400_000);
+  }
+}
+
+function dayCount(startDate: string, endDate: string): number {
+  return (
+    (Date.parse(`${endDate}T00:00:00Z`) - Date.parse(`${startDate}T00:00:00Z`)) /
+      86_400_000 +
+    1
+  );
+}
+
+/**
+ * Build the byte-stable JSON recap document for an inclusive local-day
+ * range. Day entries are ascending; day cards are sorted by id; per-card
+ * key order is fixed by `projectCardForRecapExport`.
+ */
+export function exportDeterministicRecapRange(
+  options: DeterministicRecapRangeOptions,
+): DeterministicRecapRangeResult {
+  const start = parseRecapDate(options.startDate);
+  if (!start.ok || !isValidActivityDate(start.date)) {
+    return { ok: false, error: "invalid_start_date" };
+  }
+  const end = parseRecapDate(options.endDate);
+  if (!end.ok || !isValidActivityDate(end.date)) {
+    return { ok: false, error: "invalid_end_date" };
+  }
+  if (Date.parse(`${end.date}T00:00:00Z`) < Date.parse(`${start.date}T00:00:00Z`)) {
+    return { ok: false, error: "end_before_start" };
+  }
+  const limit = options.maxDays ?? DEFAULT_RECAP_RANGE_MAX_DAYS;
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new RangeError(`maxDays must be a positive integer; got ${options.maxDays}`);
+  }
+  if (dayCount(start.date, end.date) > limit) {
+    return { ok: false, error: "range_too_large", limit };
+  }
+
+  const includeObservations = options.includeObservations === true;
+  const byDay = new Map<string, RecapExportCard[]>();
+  for (const card of options.cards) {
+    if (card.dayKey < start.date || card.dayKey > end.date) continue;
+    const bucket = byDay.get(card.dayKey);
+    const projected = projectCardForRecapExport(card, includeObservations);
+    if (bucket === undefined) byDay.set(card.dayKey, [projected]);
+    else bucket.push(projected);
+  }
+
+  const days: DeterministicRecapDay[] = [];
+  for (const date of isoDays(start.date, end.date)) {
+    days.push({
+      date,
+      timezone: options.timezone,
+      cards: (byDay.get(date) ?? []).sort(compareCardIds),
+    });
+  }
+  return {
+    ok: true,
+    range: {
+      startDate: start.date,
+      endDate: end.date,
+      timezone: options.timezone,
+      days,
+    },
+  };
+}
+
+/**
+ * Render the byte-stable Markdown recap for an inclusive local-day range:
+ * one `renderDeterministicJournal` section per day, ascending. Validation
+ * and bounds match `exportDeterministicRecapRange`.
+ */
+export function renderDeterministicJournalRange(
+  options: DeterministicRecapRangeOptions,
+): DeterministicRecapRangeMarkdownResult {
+  const exported = exportDeterministicRecapRange(options);
+  if (!exported.ok) return exported;
+  const sections = exported.range.days.map((day) =>
+    renderDeterministicJournal(day.cards, {
+      date: day.date,
+      timezone: day.timezone,
+    }),
+  );
+  return {
+    ok: true,
+    markdown: sections.join("\n"),
+    dayCount: exported.range.days.length,
+  };
+}

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

@@ -2,7 +2,10 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import type { TimelineCard } from "./types.js";
-import { exportDeterministicRecap } from "./recap-export.js";
+import {
+  exportDeterministicRecap,
+  projectCardForRecapExport,
+} from "./recap-export.js";
 
 const DATE = "2026-08-17";
 
@@ -76,3 +79,72 @@ test("input cards are not mutated and reruns are stable", () => {
   assert.deepEqual(input.map((c) => c.id), ["card-b", "card-a"]);
   assert.equal(JSON.stringify(first), JSON.stringify(second));
 });
+
+test("privacy boundary: default export omits observation-derived titles", () => {
+  const recap = exportDeterministicRecap({
+    date: DATE,
+    timezone: "UTC",
+    cards: [card({ id: "card-a", title: "Secret Window Title" })],
+  });
+  const json = JSON.stringify(recap);
+  assert.equal(json.includes("Secret Window Title"), false);
+  assert.equal(recap.cards[0].title, undefined);
+  // Evidence references survive: the export points at content, never copies it.
+  assert.deepEqual(recap.cards[0].evidenceIds, [1]);
+  assert.equal(recap.cards[0].dayKey, DATE);
+});
+
+test("privacy boundary: includeObservations keeps the title", () => {
+  const recap = exportDeterministicRecap({
+    date: DATE,
+    timezone: "UTC",
+    cards: [card({ id: "card-a", title: "Secret Window Title" })],
+    includeObservations: true,
+  });
+  assert.equal(recap.cards[0].title, "Secret Window Title");
+});
+
+test("manualEdit provenance is kept and sorts last in the projected card", () => {
+  const projected = projectCardForRecapExport(
+    card({
+      id: "card-a",
+      manualEdit: { categoryId: "focus", editedAtUtc: "2026-08-17T12:00:00.000Z" },
+    }),
+    false,
+  );
+  assert.equal(projected.manualEdit?.categoryId, "focus");
+  assert.equal(Object.keys(projected).at(-1), "manualEdit");
+});
+test("projectCardForRecapExport emits a fixed key order without the title", () => {
+  const projected = projectCardForRecapExport(card({ id: "card-a" }), false);
+  assert.deepEqual(Object.keys(projected), [
+    "id",
+    "kind",
+    "summary",
+    "categoryId",
+    "confidence",
+    "startUtc",
+    "endUtc",
+    "dayKey",
+    "timezone",
+    "machine",
+    "evidenceIds",
+    "evidenceRange",
+  ]);
+});
+
+
+test("projected exports are byte-identical across reruns and shuffled input", () => {
+  const cards = [card({ id: "c3" }), card({ id: "c1" }), card({ id: "c2" })];
+  const first = JSON.stringify(
+    exportDeterministicRecap({ date: DATE, timezone: "UTC", cards }),
+  );
+  const second = JSON.stringify(
+    exportDeterministicRecap({
+      date: DATE,
+      timezone: "UTC",
+      cards: [cards[2], cards[0], cards[1]],
+    }),
+  );
+  assert.equal(first, second);
+});