@vellumai/assistant 0.12.2 → 0.12.3-staging.1

package/src/plugin-api/plugin-channel-turn-trust.test.ts

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+type InboundTrustReadResult =
+  | {
+      ok: true;
+      verdict: {
+        trustClass: string;
+        canonicalSenderId: string | null;
+        contactId?: string;
+        status?: string;
+        resolutionFailed?: boolean;
+      };
+      admissionPolicy: string | null;
+    }
+  | { ok: false };
+
+let nextRead: InboundTrustReadResult = { ok: false };
+
+mock.module("../calls/inbound-trust-reader.js", () => ({
+  readInboundTrust: async () => nextRead,
+}));
+
+import {
+  PluginTurnNotAdmittedError,
+  resolvePluginChannelTurnTrust,
+} from "./plugin-channel-turn-trust.js";
+
+const CHANNEL = {
+  sourceChannel: "plugin" as const,
+  externalChatId: "imessage:+12025550142",
+  externalUserId: "imessage:+12025550142",
+  displayName: "Ada",
+};
+
+beforeEach(() => {
+  nextRead = { ok: false };
+});
+
+describe("resolvePluginChannelTurnTrust", () => {
+  test("returns the gateway verdict as the turn trust context", async () => {
+    nextRead = {
+      ok: true,
+      verdict: {
+        trustClass: "trusted_contact",
+        canonicalSenderId: "imessage:+12025550142",
+        contactId: "c-ada",
+        status: "active",
+      },
+      admissionPolicy: "trusted_contacts",
+    };
+
+    const trust = await resolvePluginChannelTurnTrust(CHANNEL);
+    expect(trust.trustClass).toBe("trusted_contact");
+    expect(trust.sourceChannel).toBe("plugin");
+    expect(trust.requesterChatId).toBe(CHANNEL.externalChatId);
+  });
+
+  test("fails closed when the gateway could not vouch for the sender", async () => {
+    nextRead = {
+      ok: true,
+      verdict: {
+        trustClass: "unknown",
+        canonicalSenderId: null,
+        resolutionFailed: true,
+      },
+      admissionPolicy: "strangers",
+    };
+
+    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toMatchObject({
+      name: "PluginTurnNotAdmittedError",
+      reason: "trust_resolution_failed",
+    });
+  });
+
+  test("fails closed when the gateway trust read fails", async () => {
+    nextRead = { ok: false };
+    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toMatchObject({
+      name: "PluginTurnNotAdmittedError",
+      reason: "trust_resolution_failed",
+    });
+  });
+
+  test("rejects a sender below the channel admission floor", async () => {
+    nextRead = {
+      ok: true,
+      verdict: { trustClass: "unknown", canonicalSenderId: null },
+      admissionPolicy: "guardian_only",
+    };
+
+    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toEqual(
+      expect.objectContaining({
+        name: "PluginTurnNotAdmittedError",
+        reason: "admission_policy_guardian_only",
+      }),
+    );
+  });
+
+  test("rejects a blocked member regardless of floor", async () => {
+    nextRead = {
+      ok: true,
+      verdict: {
+        trustClass: "trusted_contact",
+        canonicalSenderId: "imessage:+12025550142",
+        contactId: "c-ada",
+        status: "blocked",
+      },
+      admissionPolicy: "strangers",
+    };
+
+    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toMatchObject({
+      name: "PluginTurnNotAdmittedError",
+      reason: "member_blocked",
+    });
+  });
+
+  test("admits when the gateway reports no admission policy", async () => {
+    nextRead = {
+      ok: true,
+      verdict: { trustClass: "unknown", canonicalSenderId: null },
+      admissionPolicy: null,
+    };
+
+    const trust = await resolvePluginChannelTurnTrust(CHANNEL);
+    expect(trust.trustClass).toBe("unknown");
+  });
+
+  test("PluginTurnNotAdmittedError names the deny reason", () => {
+    const err = new PluginTurnNotAdmittedError("admission_policy_no_one");
+    expect(err).toBeInstanceOf(Error);
+    expect(err.reason).toBe("admission_policy_no_one");
+    expect(err.message).toContain("admission_policy_no_one");
+  });
+});

package/src/plugin-api/plugin-channel-turn-trust.ts

@@ -0,0 +1,71 @@
+/**
+ * Gateway admission and trust for plugin turns addressed by a channel chat.
+ *
+ * A channel address means an inbound sender, not an internal plugin job.
+ * Trust comes from the gateway verdict (`resolve_inbound_trust`); the turn
+ * runs only when that sender clears the channel admission floor.
+ */
+
+import { meetsAdmissionFloor } from "@vellumai/gateway-client";
+
+import { readInboundTrust } from "../calls/inbound-trust-reader.js";
+import type { ChannelId } from "../channels/types.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
+import { trustContextFromVerdict } from "../runtime/trust-verdict-consumer.js";
+
+interface PluginChannelTurnAddress {
+  sourceChannel: ChannelId;
+  externalChatId: string;
+  externalUserId?: string | null;
+  displayName?: string | null;
+  username?: string | null;
+}
+
+export class PluginTurnNotAdmittedError extends Error {
+  readonly reason: string;
+
+  constructor(reason: string) {
+    super(`This inbound plugin turn was not admitted (${reason}).`);
+    this.name = "PluginTurnNotAdmittedError";
+    this.reason = reason;
+  }
+}
+
+export async function resolvePluginChannelTurnTrust(
+  channel: PluginChannelTurnAddress,
+): Promise<TrustContext> {
+  const actorExternalId = channel.externalUserId?.trim() || undefined;
+  const read = await readInboundTrust({
+    channelType: channel.sourceChannel,
+    actorExternalId,
+  });
+  if (!read.ok) {
+    throw new PluginTurnNotAdmittedError("trust_resolution_failed");
+  }
+
+  if (read.verdict.resolutionFailed) {
+    throw new PluginTurnNotAdmittedError("trust_resolution_failed");
+  }
+
+  const memberStatus = read.verdict.status;
+  if (memberStatus === "blocked" || memberStatus === "revoked") {
+    throw new PluginTurnNotAdmittedError(`member_${memberStatus}`);
+  }
+
+  const trustClass = read.verdict.trustClass;
+  if (
+    read.admissionPolicy != null &&
+    !meetsAdmissionFloor(read.admissionPolicy, trustClass)
+  ) {
+    throw new PluginTurnNotAdmittedError(
+      `admission_policy_${read.admissionPolicy}`,
+    );
+  }
+
+  return trustContextFromVerdict(read.verdict, {
+    sourceChannel: channel.sourceChannel,
+    conversationExternalId: channel.externalChatId,
+    actorDisplayName: channel.displayName ?? undefined,
+    actorUsername: channel.username ?? undefined,
+  });
+}

package/src/plugins/defaults/memory/AGENTS.md

@@ -68,6 +68,13 @@ Everything else under the plugin root is **spine**:
   the writer plus the one matcher every reader uses. It lives at the root
   precisely so `substrate/`, `graph/`, and `graph-topology/` can all reach it
   without a tier importing spine. Do not add a second matcher anywhere),
+  `buffer-file` (the two writers of `memory/buffer.md`: the append every
+  `remember()`-shaped path uses and the consume the consolidation job runs
+  after a pass. Do not write the buffer from anywhere else, and never
+  rewrite it from a read that is not inside `consumeBufferEntries`'s
+  synchronous critical section), `memory-run-evidence` (readers of what a
+  background memory run durably produced from its persisted messages; every
+  job that gates a state transition on a verified write uses them),
   `segmenter`, `message-media`, `worker`, `worker-control`,
   `memory-recall-log-store`, `activation-session-store` (the onboarding
   activation rail — **not** a memory tier despite the name),
@@ -213,7 +220,8 @@ not break.
   behind a re-injected copy), and a reset whose ledger clear fails reports
   that the same way a missing marker does.
 - **The store is plugin-owned.** `memory_v3_injected_sections`,
-  `memory_v3_pools`, and the `section_key` column of `memory_v3_selections`
+  `memory_v3_pools`, `memory_v3_pool_inputs`, `memory_v3_pool_texts`, and
+  the `section_key` column of `memory_v3_selections`
   are created by `v3/plugin-schema.ts` (`ensureMemoryV3PluginSchema` from the
   `init` hook, and each store's once-per-connection ensure on first use),
   never by the global migration chain, and every read goes through its
@@ -365,13 +373,16 @@ Persisted rows; a rename orphans every existing install.
 | `memory_v2_injection_events`      | v2 scoring feedback                                             |
 | `memory_v3_selections`            | v3 selection log (`section_key` column plugin-added, see below) |
 | `memory_v3_pools`                 | v3 selector pool audit (plugin-created, see below)              |
+| `memory_v3_pool_inputs`           | v3 selector input capture, opt-in (plugin-created, see below)   |
+| `memory_v3_pool_texts`            | v3 pooled candidate texts by content hash, opt-in (see below)   |
 | `memory_v3_injected_sections`     | v3 section dedup, prune bytes + recency (plugin-created, below) |
 | `memory_v3_ever_injected`         | v3 card dedup (superseded, frozen)                              |
 | `memory_retrospective_state`      | retrospective (tier-agnostic)                                   |
 | `activation_sessions`             | onboarding activation rail                                      |
 
-`memory_v3_pools` and `memory_v3_injected_sections` are the plugin's own
-tables, created by the plugin rather than by the global migration chain
+`memory_v3_pools`, `memory_v3_pool_inputs`, `memory_v3_pool_texts`, and
+`memory_v3_injected_sections` are the plugin's own tables, created by the
+plugin rather than by the global migration chain
 (`v3/plugin-schema.ts`): the memory plugin's `init` hook ensures both on every
 boot, and each store ensures again on the first use of a connection in its
 process (the memory worker is a separate process), idempotently and fail-open,
@@ -407,8 +418,13 @@ per distinct matched section, at most `memory.v3.finderSectionsPerPage` in
 surfacing order (needle, dense, reply, span) plus its entity and rare-term
 lines, and selecting a line selects that section; the selection log keeps
 one row per slug, so the pool row is where the per-section verdicts live. A
-turn whose selector never judged a pool (the injection gate hard-skipped it,
-or nothing was pooled) persists an empty pool with `selector_ran = 0`, and a
+turn whose selector never judged a pool persists it with `selector_ran = 0`:
+an empty pool when the injection gate hard-skipped it or nothing was pooled,
+and the pool as the selector was given it, stable-prefix cards chosen and
+finder lines not, when the selector's provider failed and the orchestrator
+kept that prefix unjudged. That turn writes no `memory_v3_selections` rows:
+the hot set's frecency and the learned-edge graph read that table as
+judgments, and an unjudged page is not one. A
 turn that logged no selections is still reachable by its stamped
 `message_id`, so the inspector shows negative verdicts too. The pool row and
 the turn's `memory_v3_selections` rows are
@@ -419,6 +435,24 @@ diagnostics, roughly 10KB each, with no retention job; a conversation delete
 purges them with the other conversation-keyed tables
 (`conversation-memory-purge.ts`).
 
+`memory_v3_pool_inputs` and `memory_v3_pool_texts` (`v3/pool-log-store.ts`,
+written only under `memory.v3.poolLog.captureInput`, off by default) extend
+the pool row with the selector's exact input, for offline selector
+evaluation and training data. One `memory_v3_pool_inputs` row per turn
+holds the context strings the selector was given (situation, recent context,
+current message, the previous assistant reply), the selector prompt's
+content hash, the gate reason, the keep-all flag, and the content hash of
+every pooled candidate's rendered text in pool order, aligned index for
+index with the pool row's `candidates_json` (pool position `i + 1` is the
+number the selector saw candidate `i` under). `memory_v3_pool_texts` holds
+each rendered text once by that hash: a stable-prefix card is its
+pre-rendered card, a finder line is exactly the line the selector saw minus
+its number (`renderFinderLine` in `v3/pool-select.ts`), and a card repeated
+across turns is stored once. The input row is written in the transaction
+that writes the pool and selection rows and purged with the conversation;
+the texts table is page-derived and keyed by content, so it is never purged
+per conversation.
+
 **v3 finder lanes.** The per-turn finder lanes (`v3/orchestrate.ts`) surface
 candidates in a fixed order, needle, dense, reply, span, entity, rare, then
 edge and learned, and each only ever adds lines. The entity lane

package/src/plugins/defaults/memory/__tests__/buffer-file.test.ts

@@ -0,0 +1,365 @@
+/**
+ * Tests for `buffer-file.ts`: the two writers of `memory/buffer.md`.
+ *
+ * The consume cases pin the invariant the module exists for: an entry saved
+ * at any point while a consolidation run is in flight is either the run's
+ * own material or still in the buffer afterwards, never destroyed. The
+ * cross-process case is the reason to believe it: a child process appends
+ * as fast as it can while this process consumes in a loop, and every tagged
+ * entry must end up consumed or present. The harness's accounting is proven
+ * against a naive read-modify-write consume with the losing interleaving
+ * forced, not raced, so the proof does not depend on scheduling.
+ */
+
+import {
+  appendFileSync,
+  chmodSync,
+  closeSync,
+  existsSync,
+  mkdtempSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
+
+import {
+  appendBufferAndArchive,
+  consumeBufferEntries,
+} from "../buffer-file.js";
+import {
+  type BufferEntryLines,
+  bufferEntryText,
+  formatRememberEntry,
+  joinBufferEntries,
+  splitBufferContent,
+} from "../buffer-format.js";
+
+let tmp: string;
+beforeAll(() => {
+  tmp = mkdtempSync(join(tmpdir(), "memory-buffer-file-test-"));
+});
+afterAll(() => {
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+let memoryDir: string;
+let bufferPath: string;
+beforeEach(() => {
+  memoryDir = mkdtempSync(join(tmp, "memory-"));
+  bufferPath = join(memoryDir, "buffer.md");
+});
+
+const A = "- [Apr 27, 9:00 AM] Alice prefers VS Code.";
+const B = "- [Apr 27, 9:01 AM] Bob shared a snippet:\n  line two\n  line three";
+const C = "- [Apr 27, 9:02 AM] Carol loves jazz.";
+const D = "- [Apr 27, 9:03 AM] Dave runs marathons.";
+
+function file(...entries: string[]): string {
+  return entries.map((e) => `${e}\n`).join("");
+}
+function entries(content: string): BufferEntryLines[] {
+  return splitBufferContent(content);
+}
+function texts(): string[] {
+  return entries(readFileSync(bufferPath, "utf-8")).map(bufferEntryText);
+}
+
+describe("appendBufferAndArchive", () => {
+  test("appends to the buffer and the dated archive, seeding the archive header once", () => {
+    const now = new Date(2026, 3, 27, 9, 0);
+    const entry = formatRememberEntry("Alice prefers VS Code.", now);
+    const first = appendBufferAndArchive({ rootDir: memoryDir, entry, now });
+    appendBufferAndArchive({ rootDir: memoryDir, entry, now });
+
+    expect(first.bufferPath).toBe(bufferPath);
+    expect(readFileSync(bufferPath, "utf-8")).toBe(entry + entry);
+    expect(first.archivePath).toBe(join(memoryDir, "archive", "2026-04-27.md"));
+    expect(readFileSync(first.archivePath, "utf-8")).toBe(
+      `# Apr 27, 2026\n\n${entry}${entry}`,
+    );
+  });
+});
+
+describe("consumeBufferEntries", () => {
+  test("removes exactly the consumed entries and keeps the rest verbatim and in order", async () => {
+    writeFileSync(bufferPath, file(A, B, C, D));
+    const pass = entries(file(A, B));
+
+    const result = await consumeBufferEntries(bufferPath, pass, {
+      lateAppendGraceMs: 0,
+    });
+
+    expect(result).toEqual({
+      removed: 2,
+      alreadyAbsent: 0,
+      lateAppendBytesRecovered: 0,
+      unrecoveredLateAppendBytes: 0,
+      lateAppendDrainFailed: false,
+    });
+    expect(readFileSync(bufferPath, "utf-8")).toBe(file(C, D));
+  });
+
+  test("entries appended after the snapshot survive, including one that duplicates a consumed entry", async () => {
+    // The snapshot held one copy of A; the same fact was remembered again
+    // during the run. Multiset semantics: one copy goes, one stays.
+    writeFileSync(bufferPath, file(A, B));
+    const pass = entries(file(A, B));
+    appendFileSync(bufferPath, file(C, A));
+
+    const result = await consumeBufferEntries(bufferPath, pass, {
+      lateAppendGraceMs: 0,
+    });
+
+    expect(result.removed).toBe(2);
+    expect(texts()).toEqual([C, A]);
+  });
+
+  test("a consumed entry missing from the live file is counted, not searched for", async () => {
+    writeFileSync(bufferPath, file(B, C));
+    const pass = entries(file(A, B));
+
+    const result = await consumeBufferEntries(bufferPath, pass, {
+      lateAppendGraceMs: 0,
+    });
+
+    expect(result).toMatchObject({ removed: 1, alreadyAbsent: 1 });
+    expect(texts()).toEqual([C]);
+  });
+
+  test("a missing buffer file consumes nothing and creates nothing", async () => {
+    const result = await consumeBufferEntries(bufferPath, entries(file(A)), {
+      lateAppendGraceMs: 0,
+    });
+
+    expect(result).toEqual({
+      removed: 0,
+      alreadyAbsent: 1,
+      lateAppendBytesRecovered: 0,
+      unrecoveredLateAppendBytes: 0,
+      lateAppendDrainFailed: false,
+    });
+    expect(existsSync(bufferPath)).toBe(false);
+  });
+
+  test("consuming everything leaves an empty file and no temp file behind", async () => {
+    writeFileSync(bufferPath, file(A, B));
+
+    await consumeBufferEntries(bufferPath, entries(file(A, B)), {
+      lateAppendGraceMs: 0,
+    });
+
+    expect(readFileSync(bufferPath, "utf-8")).toBe("");
+    expect(readdirSync(memoryDir)).toEqual(["buffer.md"]);
+  });
+
+  test("an append that landed on the replaced inode is drained back into the buffer", async () => {
+    // An appender that opened the file before the rename writes to the old
+    // inode. The consumer holds that inode open and copies the late bytes
+    // over. The test plays the appender: open before, write after the
+    // synchronous phase, before the grace-window drain.
+    writeFileSync(bufferPath, file(A, B));
+    const lateFd = openSync(bufferPath, "a");
+    const consuming = consumeBufferEntries(bufferPath, entries(file(A)), {
+      lateAppendGraceMs: 50,
+    });
+    // The synchronous phase (read, rewrite, rename) ran before the first
+    // await inside consume, so this write lands on the orphaned inode.
+    appendFileSync(lateFd, file(C));
+    closeSync(lateFd);
+
+    const result = await consuming;
+
+    expect(result.removed).toBe(1);
+    expect(result.lateAppendBytesRecovered).toBe(file(C).length);
+    expect(result.unrecoveredLateAppendBytes).toBe(0);
+    expect(texts()).toEqual([B, C]);
+  });
+
+  test("a late append the drain cannot copy back is reported, not thrown, and the pass stays consumed", async () => {
+    // The rename has committed when the drain runs, so a failing copy must
+    // not surface as "nothing happened". The test makes the rewritten
+    // buffer read-only before the late bytes land, so every copy attempt
+    // fails.
+    writeFileSync(bufferPath, file(A, B));
+    const lateFd = openSync(bufferPath, "a");
+    const consuming = consumeBufferEntries(bufferPath, entries(file(A)), {
+      lateAppendGraceMs: 50,
+    });
+    chmodSync(bufferPath, 0o444);
+    appendFileSync(lateFd, file(C));
+    closeSync(lateFd);
+
+    try {
+      const result = await consuming;
+      expect(result.removed).toBe(1);
+      expect(result.lateAppendBytesRecovered).toBe(0);
+      expect(result.unrecoveredLateAppendBytes).toBe(file(C).length);
+      expect(result.lateAppendDrainFailed).toBe(false);
+      expect(texts()).toEqual([B]);
+    } finally {
+      chmodSync(bufferPath, 0o644);
+    }
+  });
+});
+
+/**
+ * The cross-process invariant. A child appends `count` tagged entries as
+ * fast as it can through `appendFileSync`; this process consumes the leading
+ * entries (up to `passSize` at a time) in a loop through `consume`. Returns
+ * the tags that were neither consumed by a pass nor left in the buffer: the
+ * entries the consume destroyed.
+ */
+async function lostUnder(
+  consume: (path: string, pass: BufferEntryLines[]) => Promise<unknown>,
+  count: number,
+  passSize: number,
+): Promise<{ lost: string[]; duplicated: string[]; passes: number }> {
+  const tag = `t${Math.random().toString(36).slice(2, 8)}`;
+  writeFileSync(bufferPath, "");
+  const child = Bun.spawn(
+    [
+      process.execPath,
+      join(import.meta.dir, "fixtures", "buffer-appender.ts"),
+      bufferPath,
+      String(count),
+      tag,
+    ],
+    { stdout: "ignore", stderr: "inherit" },
+  );
+  const consumed: string[] = [];
+  let passes = 0;
+  let childDone = false;
+  void child.exited.then(() => {
+    childDone = true;
+  });
+  while (!childDone) {
+    const snapshot = entries(readFileSync(bufferPath, "utf-8"));
+    const pass = snapshot.slice(0, passSize);
+    if (pass.length === 0) {
+      await Bun.sleep(1);
+      continue;
+    }
+    await consume(bufferPath, pass);
+    consumed.push(...pass.map(bufferEntryText));
+    passes += 1;
+  }
+  await child.exited;
+  return { ...accountFor(count, tag, consumed), passes };
+}
+
+/** A tagged entry as the appender writes it. */
+function taggedEntry(tag: string, i: number): string {
+  return `- [Apr 27, 9:00 AM] ${tag}-${i}`;
+}
+
+/**
+ * The harness's verdict: of `count` tagged entries, which were neither
+ * consumed by a pass nor left in the buffer (lost), and which were both
+ * (duplicated).
+ */
+function accountFor(
+  count: number,
+  tag: string,
+  consumed: readonly string[],
+): { lost: string[]; duplicated: string[] } {
+  const seen = new Map<string, number>();
+  for (const text of [...consumed, ...texts()]) {
+    seen.set(text, (seen.get(text) ?? 0) + 1);
+  }
+  const lost: string[] = [];
+  const duplicated: string[] = [];
+  for (let i = 0; i < count; i++) {
+    const text = taggedEntry(tag, i);
+    const n = seen.get(text) ?? 0;
+    if (n === 0) {
+      lost.push(text);
+    } else if (n > 1) {
+      duplicated.push(text);
+    }
+  }
+  return { lost, duplicated };
+}
+
+/**
+ * A read-modify-write consume, the shape the production consume is measured
+ * against: an append that lands between its read and its write is destroyed.
+ * `betweenReadAndWrite` runs in exactly that window.
+ */
+async function naiveConsume(
+  path: string,
+  pass: BufferEntryLines[],
+  betweenReadAndWrite?: () => void,
+): Promise<void> {
+  const pending = pass.map(bufferEntryText);
+  const remaining = entries(readFileSync(path, "utf-8")).filter((entry) => {
+    const index = pending.indexOf(bufferEntryText(entry));
+    if (index === -1) {
+      return true;
+    }
+    pending.splice(index, 1);
+    return false;
+  });
+  betweenReadAndWrite?.();
+  writeFileSync(path, joinBufferEntries(remaining), "utf-8");
+}
+
+describe("consumeBufferEntries under a concurrent appender in another process", () => {
+  const APPENDS = 4000;
+
+  test("no entry appended during consumption is lost or duplicated", async () => {
+    // Runs the consume exactly as production does, grace window included:
+    // the window is what makes the invariant hold, and a loaded machine
+    // can deschedule the appender between its open and its write for
+    // longer than a token grace would cover. Larger passes keep the run
+    // short with the full grace paid per pass.
+    const outcome = await lostUnder(
+      (path, pass) => consumeBufferEntries(path, pass),
+      APPENDS,
+      500,
+    );
+    expect(outcome.passes).toBeGreaterThan(0);
+    expect(outcome.lost).toEqual([]);
+    expect(outcome.duplicated).toEqual([]);
+  }, 60_000);
+
+  test("the accounting reports an entry the naive consume destroys, and one a pass duplicates", async () => {
+    // Sensitivity check for the harness: the case above is only evidence if
+    // the accounting can see a loss. The losing interleaving is forced (an
+    // append lands between the naive consume's read and its write) rather
+    // than raced against another process, so whether it happens never
+    // depends on scheduling.
+    const tag = "sens";
+    writeFileSync(bufferPath, file(taggedEntry(tag, 0)));
+    const pass = entries(readFileSync(bufferPath, "utf-8"));
+
+    await naiveConsume(bufferPath, pass, () => {
+      appendFileSync(bufferPath, `${taggedEntry(tag, 1)}\n`, "utf-8");
+    });
+
+    expect(texts()).toEqual([]);
+    const consumed = pass.map(bufferEntryText);
+    expect(accountFor(2, tag, consumed)).toEqual({
+      lost: [taggedEntry(tag, 1)],
+      duplicated: [],
+    });
+
+    // A pass that consumed an entry the buffer still holds is a duplicate.
+    appendFileSync(bufferPath, `${taggedEntry(tag, 0)}\n`, "utf-8");
+    expect(accountFor(2, tag, consumed)).toEqual({
+      lost: [taggedEntry(tag, 1)],
+      duplicated: [taggedEntry(tag, 0)],
+    });
+  });
+});