test: a member's treatAsHistorical import cannot land a foreign comment pair; a row re-pointed mid-backfill keeps its re-pointed pair (ADR-0139 E7)

Claude-Session: https://claude.ai/code/session_01NX4Woa8XhvMs6xpqQpx8kK
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

packages/plugins/plugin-audit/src/comment-parent-pair.integration.test.ts

@@ -392,12 +392,13 @@ function findOr(where: any): any[] {
 describe('[ADR-0139 E7] backfillCommentParentPair', () => {
   let kernel: ObjectKernel;
   let engine: ObjectQL;
+  let driver: SqliteWasmDriver;
   const rowIds: string[] = [];
   const stampedAt = new Map<string, unknown>();
   const logger = () => ({ info: vi.fn(), warn: vi.fn() });
 
   beforeAll(async () => {
-    const driver = new SqliteWasmDriver({ filename: ':memory:' });
+    driver = new SqliteWasmDriver({ filename: ':memory:' });
     ({ kernel, engine } = await bootKernel(driver));
     engine.registry.registerObject(objectOf(DOC) as any, HARNESS_PACKAGE);
     await engine.syncSchemas();
@@ -451,6 +452,26 @@ describe('[ADR-0139 E7] backfillCommentParentPair', () => {
     expect(await all()).toEqual(before);
   });
 
+  it('a row re-pointed between the page read and the write keeps the re-pointed pair', async () => {
+    const doc = String((await engine.insert(DOC, { name: 'race' }, { context: SYS })).id);
+    const moved = String((await engine.insert(DOC, { name: 'race target' }, { context: SYS })).id);
+    const id = String((await engine.insert(COMMENT, commentOn(DOC, doc, 'race'), { context: SYS })).id);
+    await driver.update(COMMENT, id, { object_name: null, record_id: null });
+    // The engine the backfill drives re-points the row right after reading the page.
+    const racing = {
+      find: async (...args: any[]) => {
+        const page = await (engine.find as any)(...args);
+        await engine.update(COMMENT, { id, thread_id: `${DOC}:${moved}` }, { context: SYS });
+        return page;
+      },
+      update: (...args: any[]) => (engine.update as any)(...args),
+    };
+    await backfillCommentParentPair(racing as any, logger(), { apply: true, pageSize: 500 });
+    expect(await engine.findOne(COMMENT, { where: { id }, context: SYS })).toMatchObject({
+      thread_id: `${DOC}:${moved}`, object_name: DOC, record_id: moved,
+    });
+  });
+
   it('a read the table refuses is a failure, never a clean report', async () => {
     const log = logger();
     const failing = { find: vi.fn(async () => { throw new Error('no such table'); }), update: vi.fn() };

packages/qa/dogfood/test/comment-thread-parent-pair.dogfood.test.ts

@@ -277,6 +277,29 @@ describe('[ADR-0139 E7] the comment-thread gate leafs over the parent pair: ever
     expect(gatedWheres.some(hasLeaf)).toBe(true);
   });
 
+  it('a member’s historical import (treatAsHistorical) naming a foreign pair stores its thread’s pair', async () => {
+    const posted = await stack.apiAs(token.member, 'POST', `/data/${COMMENT}`, { thread_id: `${OBJ}:${id.mine}`, body: 'ctp import probe' });
+    expect(posted.status, 'fixture comment').toBeLessThan(300);
+    const j = (await posted.json()) as any;
+    const commentId = String(j.id ?? j.record?.id ?? j.data?.id);
+    const res = await stack.apiAs(token.member, 'POST', `/data/${COMMENT}/import`, {
+      format: 'json',
+      writeMode: 'update',
+      matchFields: ['id'],
+      treatAsHistorical: true,
+      rows: [{ id: commentId, object_name: OBJ, record_id: id.other }],
+    });
+    expect(res.status).toBe(200);
+    const report: any = await res.json();
+    const atRest = await ql.findOne(COMMENT, { where: { id: commentId }, context: { ...SYS } });
+    // The import updated the row, and the stored pair is still the thread's.
+    expect({ updated: report.updated, ok: report.results?.[0]?.ok }).toEqual({ updated: 1, ok: true });
+    expect({ object_name: atRest.object_name, record_id: atRest.record_id }).toEqual({ object_name: OBJ, record_id: id.mine });
+    // ...so the writer, who reads `id.other` and not `id.mine`, is not served it.
+    const writerScoped = await list('writer', `$filter=${filterOf({ id: commentId })}&$top=1`);
+    expect(writerScoped.rows).toEqual([]);
+  });
+
   it('a row the backfill has not reached is probed by its thread, not leafed: still served when readable, still hidden when not', async () => {
     const cleared = [...bulk.mine.slice(0, UNSTAMPED), ...bulk.other.slice(0, UNSTAMPED)];
     // Planted below the engine, as a row from before the upgrade is: every