@remnic/core 9.66.0 → 9.66.1

package/src/activity/timeline/weekly.ts

@@ -0,0 +1,234 @@
+/**
+ * Deterministic weekly time/activity summary over timeline cards (issue #2052).
+ *
+ * Pure: cards + week bounds + category registry in, snapshot out. Half-open
+ * UTC [weekStart, weekEnd). Previous-period comparison is omitted in this
+ * slice and marked unavailable, never a silent zero. Later surfaces
+ * (CLI/MCP/HTTP/UI) consume this shape; they are not built here.
+ */
+import { parseFlexibleIsoTimestamp } from "../../utils/iso-timestamp.js";
+import { activityDayWindow, assertValidTimezone } from "../digest.js";
+import type { TimelineCard, TimelineCardKind, TimelineCategory } from "./types.js";
+
+export const WEEKLY_ACTIVITY_FORMAT_VERSION = 1;
+
+export interface WeeklyActivityOptions {
+  timezone: string;
+  weekStartUtc: string;
+  weekEndUtc: string;
+  categories: readonly TimelineCategory[];
+}
+
+export interface WeeklyCategoryTotal {
+  categoryId: string;
+  durationMs: number;
+}
+
+export interface WeeklyKindTotals {
+  activeMs: number;
+  idleMs: number;
+  pauseMs: number;
+  gapMs: number;
+  unclassifiedMs: number;
+}
+
+export interface WeeklyDayTotal extends WeeklyKindTotals {
+  date: string;
+  startUtc: string;
+  endUtc: string;
+  categories: WeeklyCategoryTotal[];
+}
+
+/** First slice never computes a prior week; the field is present so callers cannot treat absence as zero. */
+export interface WeeklyPreviousPeriodUnavailable {
+  available: false;
+}
+
+export interface WeeklyActivitySummary extends WeeklyKindTotals {
+  formatVersion: number;
+  timezone: string;
+  weekStartUtc: string;
+  weekEndUtc: string;
+  categories: WeeklyCategoryTotal[];
+  days: WeeklyDayTotal[];
+  previousPeriod: WeeklyPreviousPeriodUnavailable;
+}
+
+interface Acc extends WeeklyKindTotals {
+  byCategory: Map<string, number>;
+  intervals: Array<[number, number]>;
+}
+
+function parseBound(value: string, label: string): number {
+  const ms = parseFlexibleIsoTimestamp(value);
+  if (ms === null) {
+    throw new RangeError(`${label} is not a valid ISO timestamp`);
+  }
+  return ms;
+}
+
+function clip(start: number, end: number, winStart: number, winEnd: number): [number, number] | null {
+  const clippedStart = Math.max(start, winStart);
+  const clippedEnd = Math.min(end, winEnd);
+  return clippedEnd > clippedStart ? [clippedStart, clippedEnd] : null;
+}
+
+function unionDuration(intervals: readonly (readonly [number, number])[]): number {
+  const sorted = [...intervals].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  let total = 0;
+  let curStart = Number.NaN;
+  let curEnd = Number.NaN;
+  for (const [start, end] of sorted) {
+    if (!Number.isFinite(curStart)) {
+      curStart = start;
+      curEnd = end;
+      continue;
+    }
+    if (start <= curEnd) {
+      curEnd = Math.max(curEnd, end);
+      continue;
+    }
+    total += curEnd - curStart;
+    curStart = start;
+    curEnd = end;
+  }
+  if (Number.isFinite(curStart)) total += curEnd - curStart;
+  return total;
+}
+
+function localDateOf(ms: number, timezone: string): string {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(new Date(ms));
+  const get = (type: string): string => parts.find((part) => part.type === type)?.value ?? "";
+  return `${get("year")}-${get("month")}-${get("day")}`;
+}
+
+function shiftIsoDate(date: string, days: number): string {
+  const parsed = new Date(`${date}T00:00:00Z`);
+  parsed.setUTCDate(parsed.getUTCDate() + days);
+  return parsed.toISOString().slice(0, 10);
+}
+
+function daysOverlappingWeek(
+  weekStartMs: number,
+  weekEndMs: number,
+  timezone: string,
+): Array<{ date: string; startMs: number; endMs: number }> {
+  if (weekEndMs <= weekStartMs) return [];
+  let date = localDateOf(weekStartMs, timezone);
+  let window = activityDayWindow(date, timezone);
+  if (Date.parse(window.startUtc) > weekStartMs) {
+    date = shiftIsoDate(date, -1);
+    window = activityDayWindow(date, timezone);
+  }
+  const days: Array<{ date: string; startMs: number; endMs: number }> = [];
+  while (Date.parse(window.startUtc) < weekEndMs) {
+    const startMs = Math.max(Date.parse(window.startUtc), weekStartMs);
+    const endMs = Math.min(Date.parse(window.endUtc), weekEndMs);
+    if (endMs > startMs) days.push({ date, startMs, endMs });
+    date = shiftIsoDate(date, 1);
+    window = activityDayWindow(date, timezone);
+  }
+  return days;
+}
+
+function emptyAcc(categoryIds: readonly string[]): Acc {
+  return {
+    activeMs: 0,
+    idleMs: 0,
+    pauseMs: 0,
+    gapMs: 0,
+    unclassifiedMs: 0,
+    byCategory: new Map(categoryIds.map((id) => [id, 0])),
+    intervals: [],
+  };
+}
+
+function addClipped(acc: Acc, kind: TimelineCardKind, categoryId: string, known: ReadonlySet<string>, start: number, end: number): void {
+  const duration = end - start;
+  acc.intervals.push([start, end]);
+  if (kind === "idle") acc.idleMs += duration;
+  else if (kind === "pause") acc.pauseMs += duration;
+  else acc.activeMs += duration;
+  if (known.has(categoryId)) {
+    acc.byCategory.set(categoryId, (acc.byCategory.get(categoryId) ?? 0) + duration);
+  } else {
+    acc.unclassifiedMs += duration;
+  }
+}
+
+function sortCategoryTotals(byCategory: Map<string, number>): WeeklyCategoryTotal[] {
+  return [...byCategory.entries()]
+    .map(([categoryId, durationMs]) => ({ categoryId, durationMs }))
+    .sort((a, b) => b.durationMs - a.durationMs || (a.categoryId < b.categoryId ? -1 : a.categoryId > b.categoryId ? 1 : 0));
+}
+
+function finish(acc: Acc, windowMs: number): WeeklyKindTotals & { categories: WeeklyCategoryTotal[] } {
+  const covered = unionDuration(acc.intervals);
+  return {
+    activeMs: acc.activeMs,
+    idleMs: acc.idleMs,
+    pauseMs: acc.pauseMs,
+    gapMs: Math.max(0, windowMs - covered),
+    unclassifiedMs: acc.unclassifiedMs,
+    categories: sortCategoryTotals(acc.byCategory),
+  };
+}
+
+/** Build a time/activity summary for one half-open week. Pure. */
+export function buildWeeklyActivitySummary(
+  cards: readonly TimelineCard[],
+  options: WeeklyActivityOptions,
+): WeeklyActivitySummary {
+  assertValidTimezone(options.timezone);
+  const weekStartMs = parseBound(options.weekStartUtc, "weekStartUtc");
+  const weekEndMs = parseBound(options.weekEndUtc, "weekEndUtc");
+  if (weekStartMs > weekEndMs) {
+    throw new RangeError("reversed range: weekStartUtc must be <= weekEndUtc");
+  }
+
+  const categoryIds = options.categories.map((category) => category.id);
+  const known = new Set(categoryIds);
+  const week = emptyAcc(categoryIds);
+  const dayWindows = daysOverlappingWeek(weekStartMs, weekEndMs, options.timezone);
+  const dayAccs = dayWindows.map(() => emptyAcc(categoryIds));
+
+  for (const card of cards) {
+    const start = Date.parse(card.startUtc);
+    const end = Date.parse(card.endUtc);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) continue;
+    const weekClip = clip(start, end, weekStartMs, weekEndMs);
+    if (!weekClip) continue;
+    addClipped(week, card.kind, card.categoryId, known, weekClip[0], weekClip[1]);
+    for (let i = 0; i < dayWindows.length; i++) {
+      const day = dayWindows[i];
+      const dayClip = clip(start, end, day.startMs, day.endMs);
+      if (dayClip) addClipped(dayAccs[i], card.kind, card.categoryId, known, dayClip[0], dayClip[1]);
+    }
+  }
+
+  const weekTotals = finish(week, weekEndMs - weekStartMs);
+  const days: WeeklyDayTotal[] = dayWindows.map((day, i) => {
+    const totals = finish(dayAccs[i], day.endMs - day.startMs);
+    return {
+      date: day.date,
+      startUtc: new Date(day.startMs).toISOString(),
+      endUtc: new Date(day.endMs).toISOString(),
+      ...totals,
+    };
+  });
+
+  return {
+    formatVersion: WEEKLY_ACTIVITY_FORMAT_VERSION,
+    timezone: options.timezone,
+    weekStartUtc: new Date(weekStartMs).toISOString(),
+    weekEndUtc: new Date(weekEndMs).toISOString(),
+    ...weekTotals,
+    days,
+    previousPeriod: { available: false },
+  };
+}

package/src/activity/types.ts

@@ -96,9 +96,23 @@ export interface ActivitySourceConfig {
   token?: string;
 }
 
+/** Opt-in daily journal settings (issue #1984). Default off. */
+export interface ActivityTimelineJournalConfig {
+  enabled: boolean;
+}
+
+/** Opt-in timeline Q&A range/search settings (issue #1983 PR1). Default off. */
+export interface ActivityTimelineQaConfig {
+  enabled: boolean;
+  /** Inclusive max half-open range length in 24h days. Integer 1..366. */
+  maxRangeDays: number;
+}
+
 /** Opt-in timeline-card derivation settings (issue #2049). Default off. */
 export interface ActivityTimelineConfig {
   enabled: boolean;
+  journal: ActivityTimelineJournalConfig;
+  qa: ActivityTimelineQaConfig;
 }
 
 /** Opt-in activity synchronization + trust-gated extraction settings. */

package/src/activity/vault-publish.test.ts

@@ -0,0 +1,166 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { applyManagedRegion, publishVaultRegion } from "./vault-publish.js";
+
+const START = "<!-- remnic:timeline:start -->";
+const END = "<!-- remnic:timeline:end -->";
+
+function withVault(fn: (vaultPath: string) => void): void {
+  const vaultPath = mkdtempSync(path.join(tmpdir(), "remnic-vault-"));
+  try {
+    fn(vaultPath);
+  } finally {
+    rmSync(vaultPath, { recursive: true, force: true });
+  }
+}
+
+test("applyManagedRegion replaces only the marked region", () => {
+  const fileText = [
+    "---",
+    "title: daily",
+    "---",
+    "",
+    "human notes",
+    START,
+    "old cards",
+    END,
+    "more human",
+    "",
+  ].join("\n");
+  const result = applyManagedRegion(fileText, {
+    strategy: "markers",
+    name: "timeline",
+    content: "new cards",
+  });
+  assert.equal(result.ok, true);
+  if (!result.ok) return;
+  assert.equal(
+    result.text,
+    [
+      "---",
+      "title: daily",
+      "---",
+      "",
+      "human notes",
+      START,
+      "new cards",
+      END,
+      "more human",
+      "",
+    ].join("\n"),
+  );
+});
+
+test("applyManagedRegion is a no-op when markers are missing", () => {
+  const fileText = "no managed region here\n";
+  const result = applyManagedRegion(fileText, {
+    strategy: "markers",
+    name: "timeline",
+    content: "new cards",
+  });
+  assert.deepEqual(result, { ok: false, reason: "no_marker", text: fileText });
+});
+
+test("applyManagedRegion preserves CRLF outside and inside the owned region", () => {
+  const fileText = [
+    "---",
+    "title: daily",
+    "---",
+    "",
+    "human notes",
+    START,
+    "old cards",
+    END,
+    "more human",
+    "",
+  ].join("\r\n");
+  const result = applyManagedRegion(fileText, {
+    strategy: "markers",
+    name: "timeline",
+    content: "new cards\nline two",
+  });
+  assert.equal(result.ok, true);
+  if (!result.ok) return;
+  assert.equal(
+    result.text,
+    [
+      "---",
+      "title: daily",
+      "---",
+      "",
+      "human notes",
+      START,
+      "new cards",
+      "line two",
+      END,
+      "more human",
+      "",
+    ].join("\r\n"),
+  );
+  assert.equal(result.text.includes("\n") && !result.text.includes("\r\n"), false);
+});
+
+test("applyManagedRegion keeps every outside byte identical", () => {
+  const prefix = "---\nkeep: me\n---\n\n- [ ] task\n```dataview\nLIST\n```\n";
+  const suffix = "\n<!-- other-agent:start -->\nleave this\n<!-- other-agent:end -->\n  trailing  \n";
+  const fileText = `${prefix}${START}\nold\n${END}${suffix}`;
+  const startAt = fileText.indexOf(START);
+  const endAt = fileText.indexOf(END);
+  const before = Buffer.from(fileText.slice(0, startAt + START.length), "utf8");
+  const after = Buffer.from(fileText.slice(endAt), "utf8");
+  const result = applyManagedRegion(fileText, {
+    strategy: "markers",
+    name: "timeline",
+    content: "replacement",
+  });
+  assert.equal(result.ok, true);
+  if (!result.ok) return;
+  const nextStart = result.text.indexOf(START);
+  const nextEnd = result.text.indexOf(END);
+  assert.deepEqual(Buffer.from(result.text.slice(0, nextStart + START.length), "utf8"), before);
+  assert.deepEqual(Buffer.from(result.text.slice(nextEnd), "utf8"), after);
+});
+
+test("publishVaultRegion updates an existing note and skips an unchanged rewrite", () => {
+  withVault((vaultPath) => {
+    const relativeFile = "Daily Notes/2026-08-17.md";
+    const dest = path.join(vaultPath, relativeFile);
+    mkdirSync(path.dirname(dest), { recursive: true });
+    writeFileSync(dest, `intro\n${START}\nold\n${END}\noutro\n`);
+    const first = publishVaultRegion({
+      vaultPath,
+      relativeFile,
+      name: "timeline",
+      content: "new cards",
+    });
+    assert.deepEqual(first, { ok: true, status: "updated" });
+    assert.equal(readFileSync(dest, "utf8"), `intro\n${START}\nnew cards\n${END}\noutro\n`);
+    const mtime = statSync(dest).mtimeMs;
+    const second = publishVaultRegion({
+      vaultPath,
+      relativeFile,
+      name: "timeline",
+      content: "new cards",
+    });
+    assert.deepEqual(second, { ok: true, status: "unchanged" });
+    assert.equal(statSync(dest).mtimeMs, mtime);
+  });
+});
+
+test("publishVaultRegion never creates a missing file", () => {
+  withVault((vaultPath) => {
+    const relativeFile = "missing.md";
+    const result = publishVaultRegion({
+      vaultPath,
+      relativeFile,
+      name: "timeline",
+      content: "new cards",
+    });
+    assert.deepEqual(result, { ok: false, reason: "missing_file" });
+    assert.equal(existsSync(path.join(vaultPath, relativeFile)), false);
+  });
+});

package/src/activity/vault-publish.ts

@@ -0,0 +1,101 @@
+/**
+ * Managed-region vault publisher (issue #1985 first slice).
+ *
+ * Replaces only the bytes between `<!-- remnic:<name>:start -->` and
+ * `<!-- remnic:<name>:end -->`. Missing markers leave the file unchanged.
+ * `activity.timeline.vault.enabled` stays default-false until a later parse
+ * slice; this module does not read config.
+ */
+import { createHash, randomBytes } from "node:crypto";
+import { readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+import { expandTildePath } from "../utils/path.js";
+
+export type ApplyManagedRegionResult =
+  | { ok: true; text: string }
+  | { ok: false; reason: "no_marker"; text: string };
+
+export type PublishVaultRegionResult =
+  | { ok: true; status: "updated" | "unchanged" }
+  | { ok: false; reason: "no_marker" | "missing_file" | "not_directory" };
+
+export function applyManagedRegion(
+  fileText: string,
+  opts: { strategy: "markers"; name: string; content: string },
+): ApplyManagedRegionResult {
+  const startMarker = `<!-- remnic:${opts.name}:start -->`;
+  const endMarker = `<!-- remnic:${opts.name}:end -->`;
+  const startIdx = fileText.indexOf(startMarker);
+  if (startIdx === -1) return { ok: false, reason: "no_marker", text: fileText };
+  const endIdx = fileText.indexOf(endMarker, startIdx + startMarker.length);
+  if (endIdx === -1) return { ok: false, reason: "no_marker", text: fileText };
+
+  const eol = fileText.includes("\r\n") ? "\r\n" : "\n";
+  let body = opts.content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (eol === "\r\n") body = body.replace(/\n/g, "\r\n");
+  if (body.endsWith(eol)) body = body.slice(0, -eol.length);
+
+  return {
+    ok: true,
+    text: `${fileText.slice(0, startIdx + startMarker.length)}${eol}${body}${eol}${fileText.slice(endIdx)}`,
+  };
+}
+
+export function publishVaultRegion(input: {
+  vaultPath: string;
+  relativeFile: string;
+  name: string;
+  content: string;
+}): PublishVaultRegionResult {
+  const vault = expandTildePath(input.vaultPath);
+  try {
+    if (!statSync(vault).isDirectory()) return { ok: false, reason: "not_directory" };
+  } catch {
+    return { ok: false, reason: "not_directory" };
+  }
+
+  if (input.relativeFile.length === 0 || path.isAbsolute(input.relativeFile)) {
+    return { ok: false, reason: "missing_file" };
+  }
+  const root = path.resolve(vault);
+  const dest = path.resolve(root, input.relativeFile);
+  const rel = path.relative(root, dest);
+  if (rel.length === 0 || rel.startsWith("..") || path.isAbsolute(rel)) {
+    return { ok: false, reason: "missing_file" };
+  }
+
+  let existing: string;
+  try {
+    if (!statSync(dest).isFile()) return { ok: false, reason: "missing_file" };
+    existing = readFileSync(dest, "utf8");
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return { ok: false, reason: "missing_file" };
+    throw err;
+  }
+
+  const applied = applyManagedRegion(existing, {
+    strategy: "markers",
+    name: input.name,
+    content: input.content,
+  });
+  if (!applied.ok) return { ok: false, reason: applied.reason };
+
+  const prevHash = createHash("sha256").update(existing, "utf8").digest("hex");
+  const nextHash = createHash("sha256").update(applied.text, "utf8").digest("hex");
+  if (prevHash === nextHash) return { ok: true, status: "unchanged" };
+
+  const tmpPath = path.join(path.dirname(dest), `.remnic-vault-${randomBytes(8).toString("hex")}.tmp`);
+  writeFileSync(tmpPath, applied.text);
+  try {
+    renameSync(tmpPath, dest);
+  } catch (renameErr) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+      // temp cleanup is best-effort
+    }
+    throw renameErr;
+  }
+  return { ok: true, status: "updated" };
+}

package/src/config.test.ts

@@ -2569,7 +2569,7 @@ test("parseConfig forwards activity source settings", () => {
     minConfidence: 0.7,
     minImportance: "normal",
     maxMemoriesPerDay: 0,
-    timeline: { enabled: false },
+    timeline: { enabled: false, journal: { enabled: false }, qa: { enabled: false, maxRangeDays: 31 } },
   });
 });
 

package/src/config.ts

@@ -48,6 +48,7 @@ import { parseSkillProjectionConfig } from "./procedural/skill-projection.js";
 import { parseDriftDetectionConfig } from "./preferences/drift-config.js";
 import { parseContradictionLocalizationConfig, parseContradictionScanConfig } from "./contradiction-config.js";
 import { parseGraphPathScoringConfig } from "./graph-path-scoring-config.js";
+import { parseWritePathDedupConfig } from "./dedup/novelty-gate.js";
 import { hasLegacyConnectorEntries } from "./connectors/paths.js";
 import {
   parseQmdChunkStrategy,
@@ -3190,28 +3191,7 @@ export function parseConfig(
 
     // v6.0 Fact deduplication & archival
     factDeduplicationEnabled: cfg.factDeduplicationEnabled !== false,
-    // Issue #373 — write-time semantic similarity guard
-    semanticDedupEnabled: cfg.semanticDedupEnabled !== false,
-    // Guard against NaN / Infinity — Number.isFinite rejects both and falls
-    // back to the documented default so the semantic dedup guard cannot be
-    // silently disabled by a malformed config value.
-    semanticDedupThreshold:
-      typeof cfg.semanticDedupThreshold === "number" &&
-      Number.isFinite(cfg.semanticDedupThreshold)
-        ? Math.min(1, Math.max(0, cfg.semanticDedupThreshold))
-        : 0.92,
-    // Zero is a valid "disable candidate lookup" signal and must be preserved.
-    // Only negative or non-finite values fall back to the default of 5.
-    // Fractional values in (0, 1) floor to 0, which would silently disable
-    // semantic dedup despite a clearly non-zero operator intent — clamp to 1.
-    semanticDedupCandidates: (() => {
-      const raw = cfg.semanticDedupCandidates;
-      if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0) return 5;
-      const n = Math.floor(raw);
-      // Positive fractional input (e.g. 0.5) should mean "at least 1 candidate",
-      // not "disabled". Only explicit 0 is the operator's disable signal.
-      return raw > 0 && n === 0 ? 1 : n;
-    })(),
+    ...parseWritePathDedupConfig(cfg),
     factArchivalEnabled: cfg.factArchivalEnabled === true,
     factArchivalAgeDays:
       typeof cfg.factArchivalAgeDays === "number" ? cfg.factArchivalAgeDays : 90,

package/src/dedup/merge-on-write.test.ts

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+  type MergeJudgeVerdict,
+  type MergeOnWritePair,
+  applyMergeOnWrite,
+  judgeMergeDecision,
+  shouldConsiderMerge,
+} from "./merge-on-write.js";
+
+function pair(overrides: Partial<MergeOnWritePair> = {}): MergeOnWritePair {
+  return {
+    category: "fact",
+    score: 0.85,
+    incomingContent: "User prefers dark mode on laptops.",
+    existingContent: "User likes dark mode.",
+    existingId: "mem-1",
+    ...overrides,
+  };
+}
+
+const mergeJudge = async () => "merge" as const;
+
+test("merge-on-write: skip band is not considered", () => {
+  assert.equal(shouldConsiderMerge({ score: 0.92 }), false);
+  assert.equal(shouldConsiderMerge({ score: 0.99 }), false);
+});
+
+test("merge-on-write: merge band is considered", () => {
+  assert.equal(shouldConsiderMerge({ score: 0.8 }), true);
+  assert.equal(shouldConsiderMerge({ score: 0.85 }), true);
+  assert.equal(shouldConsiderMerge({ score: 0.919 }), true);
+});
+
+test("merge-on-write: score below mergeMin is not considered", () => {
+  assert.equal(shouldConsiderMerge({ score: 0.79 }), false);
+});
+
+test("merge-on-write: refused categories always create", async () => {
+  for (const category of ["procedure", "reasoning_trace", "moment", "correction"]) {
+    const decision = await applyMergeOnWrite({
+      enabled: true,
+      pair: pair({ category }),
+      judge: mergeJudge,
+    });
+    assert.equal(decision, "create", category);
+  }
+});
+
+test("merge-on-write: judge throw creates", async () => {
+  const viaJudge = await judgeMergeDecision(pair(), async () => {
+    throw new Error("timeout");
+  });
+  assert.equal(viaJudge, "create");
+
+  const viaApply = await applyMergeOnWrite({
+    enabled: true,
+    pair: pair(),
+    judge: async () => {
+      throw new Error("timeout");
+    },
+  });
+  assert.equal(viaApply, "create");
+});
+
+test("merge-on-write: uncertain judge creates", async () => {
+  const decision = await judgeMergeDecision(pair(), async (): Promise<MergeJudgeVerdict> => "uncertain");
+  assert.equal(decision, "create");
+});
+
+test("merge-on-write: disabled or mergeMin 0 creates", async () => {
+  let called = 0;
+  const judge = async () => {
+    called += 1;
+    return "merge" as const;
+  };
+
+  assert.equal(await applyMergeOnWrite({ pair: pair(), judge }), "create");
+  assert.equal(await applyMergeOnWrite({ enabled: false, pair: pair(), judge }), "create");
+  assert.equal(await applyMergeOnWrite({ enabled: true, mergeMin: 0, pair: pair(), judge }), "create");
+  assert.equal(called, 0);
+});
+
+test("merge-on-write: enabled in-band merge applies", async () => {
+  const decision = await applyMergeOnWrite({
+    enabled: true,
+    pair: pair(),
+    judge: mergeJudge,
+  });
+  assert.equal(decision, "merge");
+});