@bevel-software/platform-core-backend 0.31.0 → 0.33.0

package/src/modules/workflow/__tests__/workflow.service.update-change-request.test.ts

@@ -0,0 +1,346 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { AuthUser, WorkflowEventPayload } from '@bevel-software/platform-shared';
+import { testKbContext } from '../../../__tests__/kb-context.js';
+import { openChangeGate } from '../../../__tests__/open-change-gate.js';
+import { hashEmail } from '../../../shared/email-identity.js';
+import type { Database } from '../../database/connection.js';
+import type { IAccessControl } from '../../access/access-control.interface.js';
+import type { WorkspaceService } from '../../workspace/workspace.service.js';
+import type { GitService } from '../git/git.service.js';
+import type { PullRequestService } from '../git/pull-request.service.js';
+import type { IReviewWorkflowService } from '../review-workflow/review-workflow.interface.js';
+import type { FileLockService } from '../file-lock.service.js';
+import type { PendingCommitsService } from '../pending-commits.service.js';
+import type { WorkflowEventBus } from '../event-bus.js';
+import { WorkflowService } from '../workflow.service.js';
+
+/**
+ * Who may change an open request's title and description: its author, or
+ * anyone who may merge it — an admin (write on `roles.yaml` at the base), or
+ * the holder of write on every file it changes. Everyone else is refused in
+ * words (403), and so is a request that is no longer open (409). These pin
+ * that rule and what an allowed edit writes.
+ */
+
+const AUTHOR = 'alice@example.com';
+const OTHER = 'mallory@example.com';
+
+const user = (email: string, name = 'Caller'): AuthUser => ({ id: `u-${email}`, email, name });
+
+function harness(
+  opts: {
+    state?: string;
+    authorEmail?: string;
+    isAdmin?: boolean | null;
+    writes?: Record<string, boolean> | null;
+    files?: string[];
+    body?: string;
+  } = {},
+) {
+  const state = opts.state ?? 'open';
+  const summary = {
+    number: 9,
+    title: 'Old title',
+    base: 'main',
+    branch: 'mallory/draft',
+    state,
+    authorId: hashEmail(opts.authorEmail ?? OTHER),
+    url: '/change-requests/9',
+  };
+  const prs = {
+    getPr: vi.fn(async () => summary),
+    getPrDetail: vi.fn(async () => ({
+      ...summary,
+      files: (opts.files ?? ['Docs/a.md', 'Docs/b.md']).map((path) => ({ path })),
+    })),
+    invalidateDetailCache: vi.fn(),
+  } as unknown as PullRequestService;
+
+  const written: Record<string, unknown>[] = [];
+  // The transaction hands its callback a client of its OWN: every read and
+  // write of the row must go through it, so a read that slipped outside the
+  // transaction (and so outside the row lock) lands on `db` instead.
+  const tx = {
+    select: vi.fn(() => tx),
+    from: vi.fn(() => tx),
+    where: vi.fn(() => tx),
+    limit: vi.fn(() => tx),
+    for: vi.fn(async () => (state === 'open' ? [{ body: opts.body ?? 'Old reason.' }] : [])),
+    update: vi.fn(() => tx),
+    set: vi.fn((values: Record<string, unknown>) => {
+      written.push(values);
+      return tx;
+    }),
+    returning: vi.fn(async () => [{ id: 'row-9' }]),
+  };
+  // The outer client answers every query with no rows: only background
+  // housekeeping (the deleted-branch sweep) may read through it.
+  const outer: Record<string, unknown> = {
+    then: (resolve: (rows: unknown[]) => unknown) => resolve([]),
+  };
+  for (const step of ['from', 'where', 'limit', 'orderBy', 'innerJoin', 'set']) outer[step] = () => outer;
+  const db = {
+    select: vi.fn(() => outer),
+    update: vi.fn(() => outer),
+    transaction: vi.fn(async (fn: (client: unknown) => Promise<unknown>) => fn(tx)),
+  };
+
+  const writes = opts.writes === undefined ? {} : opts.writes;
+  const access = {
+    canWriteAtRef: vi.fn(async () => (opts.isAdmin === undefined ? false : opts.isAdmin)),
+    canWriteBatchAtRef: vi.fn(async (_ws: string, _ref: string, _email: string, paths: string[]) =>
+      writes === null ? null : new Map(paths.map((p) => [p, writes[p] === true])),
+    ),
+  } as unknown as IAccessControl;
+  const workspaces = {
+    getOrCreateForBranch: vi.fn(async (b: string) => ({ id: encodeURIComponent(b) })),
+    ensureRemotesFetched: vi.fn(async () => undefined),
+  } as unknown as WorkspaceService;
+  const emitted: WorkflowEventPayload[] = [];
+  const events = { emit: (e: WorkflowEventPayload) => emitted.push(e) } as unknown as WorkflowEventBus;
+
+  const svc = new WorkflowService(
+    db as unknown as Database,
+    {} as GitService,
+    prs,
+    {} as IReviewWorkflowService,
+    workspaces,
+    access,
+    {} as FileLockService,
+    {} as PendingCommitsService,
+    testKbContext(),
+    openChangeGate(),
+    events,
+  );
+  return { svc, db, tx, written, prs, access, workspaces, emitted };
+}
+
+describe('WorkflowService.updateChangeRequest — who may edit', () => {
+  it('lets the AUTHOR edit without any further grant, and resolves no workspace and reads no access tree', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    await h.svc.updateChangeRequest(9, user(AUTHOR), { description: 'P2 - Planned\n\nNew reason.' });
+    expect(h.written).toHaveLength(1);
+    expect(h.access.canWriteAtRef).not.toHaveBeenCalled();
+    expect(h.workspaces.getOrCreateForBranch).not.toHaveBeenCalled();
+  });
+
+  it('matches the author case-insensitively, as authorship is stored', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    await h.svc.updateChangeRequest(9, user('  Alice@Example.com '), { title: 'New' });
+    expect(h.written).toHaveLength(1);
+  });
+
+  it('lets an ADMIN edit someone else’s request', async () => {
+    const h = harness({ isAdmin: true });
+    await h.svc.updateChangeRequest(9, user('admin@example.com'), { title: 'New' });
+    expect(h.written).toHaveLength(1);
+    expect(h.access.canWriteAtRef).toHaveBeenCalledWith('main', 'origin/main', 'admin@example.com', 'roles.yaml');
+  });
+
+  it('lets someone who may approve EVERY changed file edit it', async () => {
+    const h = harness({ writes: { 'Docs/a.md': true, 'Docs/b.md': true } });
+    await h.svc.updateChangeRequest(9, user('owner@example.com'), { title: 'New' });
+    expect(h.written).toHaveLength(1);
+    // Read at the base, behind a strict fetch — never a stale local ref.
+    expect(h.workspaces.ensureRemotesFetched).toHaveBeenCalledWith('main', { strict: true, force: true });
+    expect(h.access.canWriteBatchAtRef).toHaveBeenCalledWith('main', 'origin/main', 'owner@example.com', [
+      'Docs/a.md',
+      'Docs/b.md',
+    ]);
+  });
+
+  it('refuses someone who may approve only SOME of the files, in words, and writes nothing', async () => {
+    const h = harness({ writes: { 'Docs/a.md': true } });
+    await expect(h.svc.updateChangeRequest(9, user('half@example.com'), { title: 'New' })).rejects.toMatchObject({
+      status: 403,
+      message:
+        "Only the request's author, an admin, or someone who may approve every file it changes can edit its title and description.",
+    });
+    expect(h.tx.update).not.toHaveBeenCalled();
+    expect(h.emitted).toEqual([]);
+  });
+
+  it('refuses a stranger with the same 403', async () => {
+    const h = harness();
+    await expect(h.svc.updateChangeRequest(9, user('stranger@example.com'), { description: 'x' })).rejects.toMatchObject({
+      status: 403,
+    });
+    expect(h.tx.update).not.toHaveBeenCalled();
+  });
+
+  it('an empty file list grants nobody but the author and admins', async () => {
+    const h = harness({ files: [] });
+    await expect(h.svc.updateChangeRequest(9, user('stranger@example.com'), { title: 'New' })).rejects.toMatchObject({
+      status: 403,
+    });
+  });
+
+  it('answers 409 rather than 403 when the base branch cannot be resolved', async () => {
+    const h = harness({ isAdmin: null });
+    await expect(h.svc.updateChangeRequest(9, user('admin@example.com'), { title: 'New' })).rejects.toMatchObject({
+      status: 409,
+      message: expect.stringContaining('could not be resolved'),
+    });
+    expect(h.tx.update).not.toHaveBeenCalled();
+  });
+
+  it('refuses a MERGED request with a worded 409, even to its author', async () => {
+    const h = harness({ state: 'merged', authorEmail: AUTHOR });
+    await expect(h.svc.updateChangeRequest(9, user(AUTHOR), { title: 'New' })).rejects.toMatchObject({
+      status: 409,
+      message: 'This change request has already been applied; its title and description can no longer be changed.',
+    });
+    expect(h.tx.update).not.toHaveBeenCalled();
+  });
+
+  it('refuses a CLOSED request with a worded 409, even to an admin', async () => {
+    const h = harness({ state: 'closed', isAdmin: true });
+    await expect(h.svc.updateChangeRequest(9, user('admin@example.com'), { title: 'New' })).rejects.toMatchObject({
+      status: 409,
+      message: 'This change request is closed; its title and description can no longer be changed.',
+    });
+    expect(h.tx.update).not.toHaveBeenCalled();
+  });
+
+  it('refuses a request that does not exist with 404', async () => {
+    const h = harness();
+    (h.prs.getPr as ReturnType<typeof vi.fn>).mockResolvedValue(null);
+    await expect(h.svc.updateChangeRequest(9, user(AUTHOR), { title: 'New' })).rejects.toMatchObject({ status: 404 });
+  });
+
+  it('refuses an edit that changes nothing, or empties the title, with 400', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    await expect(h.svc.updateChangeRequest(9, user(AUTHOR), {})).rejects.toMatchObject({ status: 400 });
+    await expect(h.svc.updateChangeRequest(9, user(AUTHOR), { title: '   ' })).rejects.toMatchObject({ status: 400 });
+    expect(h.tx.update).not.toHaveBeenCalled();
+  });
+
+  it('refuses a title past 256 characters with 400 — the agent tool’s limit, for the route too', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    await h.svc.updateChangeRequest(9, user(AUTHOR), { title: 'x'.repeat(256) });
+    await expect(h.svc.updateChangeRequest(9, user(AUTHOR), { title: 'x'.repeat(257) })).rejects.toMatchObject({
+      status: 400,
+      message: expect.stringContaining('at most 256 characters'),
+    });
+    expect(h.written).toHaveLength(1);
+  });
+
+  it('refuses a description past 64,000 characters with 400, on a replacement and on what an append would leave', async () => {
+    const h = harness({ authorEmail: AUTHOR, body: 'x'.repeat(63_990) });
+    await h.svc.updateChangeRequest(9, user(AUTHOR), { description: 'y'.repeat(64_000) });
+    await expect(h.svc.updateChangeRequest(9, user(AUTHOR), { description: 'y'.repeat(64_001) })).rejects.toMatchObject({
+      status: 400,
+      message: expect.stringContaining('at most 64000 characters'),
+    });
+    // 63,990 stored + the two newlines + 9 = 64,001: measured on what the
+    // append leaves, inside the transaction, and nothing is written.
+    await expect(h.svc.updateChangeRequest(9, user(AUTHOR), { appendDescription: 'z'.repeat(9) })).rejects.toMatchObject({
+      status: 400,
+      message: expect.stringContaining('at most 64000 characters'),
+    });
+    expect(h.written).toHaveLength(1);
+  });
+
+  it('refuses a replacement and an append together with 400', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    await expect(
+      h.svc.updateChangeRequest(9, user(AUTHOR), { description: 'a', appendDescription: 'b' }),
+    ).rejects.toMatchObject({ status: 400 });
+    expect(h.tx.update).not.toHaveBeenCalled();
+  });
+});
+
+describe('WorkflowService.openChangeRequest — the same ceiling on the description', () => {
+  it('refuses a description past 64,000 characters with 400 before touching a workspace', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    await expect(
+      h.svc.openChangeRequest('ws', user(AUTHOR), {
+        sourceBranch: 'mallory/draft',
+        targetBranch: 'main',
+        title: 'Too long',
+        description: 'y'.repeat(64_001),
+      }),
+    ).rejects.toMatchObject({ status: 400, message: expect.stringContaining('at most 64000 characters') });
+    expect(h.workspaces.getOrCreateForBranch).not.toHaveBeenCalled();
+  });
+});
+
+describe('WorkflowService.updateChangeRequest — what an edit writes', () => {
+  it('replaces the body whole — the body is the description and nothing else', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    const before = Date.now();
+    await h.svc.updateChangeRequest(9, user(AUTHOR, 'Alice'), { description: '  P2 - Planned\n\nNew reason.  ' });
+    const [set] = h.written;
+    expect(set.body).toBe('P2 - Planned\n\nNew reason.');
+    expect(set).not.toHaveProperty('title');
+    expect((set.updatedAt as Date).getTime()).toBeGreaterThanOrEqual(before);
+  });
+
+  it("keeps the author's own headings: nothing in a body is Hexis's to cut", async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    await h.svc.updateChangeRequest(9, user(AUTHOR), { description: 'Lead.\n\n## Affected owners\n\nI mean the GTM ones.' });
+    expect(h.written[0].body).toBe('Lead.\n\n## Affected owners\n\nI mean the GTM ones.');
+  });
+
+  it('changes the title alone without touching the body', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    await h.svc.updateChangeRequest(9, user(AUTHOR), { title: '  New title ' });
+    const [set] = h.written;
+    expect(set.title).toBe('New title');
+    expect(set).not.toHaveProperty('body');
+  });
+
+  it("never touches an access request's level or note — they are columns, not prose", async () => {
+    const h = harness({ authorEmail: AUTHOR, body: 'Alice asked for **Owner** on Docs.' });
+    await h.svc.updateChangeRequest(9, user(AUTHOR), { description: 'Please, for the Q3 review.' });
+    const [set] = h.written;
+    expect(set.body).toBe('Please, for the Q3 review.');
+    expect(set).not.toHaveProperty('accessRequestLevel');
+    expect(set).not.toHaveProperty('accessRequestNote');
+  });
+
+  it('appends to the description as stored', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    await h.svc.updateChangeRequest(9, user(AUTHOR), { appendDescription: '  Round two.  ' });
+    expect(h.written[0].body).toBe('Old reason.\n\nRound two.');
+  });
+
+  it('an append to an empty description is the description', async () => {
+    const h = harness({ authorEmail: AUTHOR, body: '' });
+    await h.svc.updateChangeRequest(9, user(AUTHOR), { appendDescription: 'P1 - High' });
+    expect(h.written[0].body).toBe('P1 - High');
+  });
+
+  it('reads the body under the row’s lock, in the transaction that writes it, so racing edits serialise', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    await h.svc.updateChangeRequest(9, user(AUTHOR), { appendDescription: 'Round two.' });
+    expect(h.db.transaction).toHaveBeenCalledTimes(1);
+    expect(h.db.select).not.toHaveBeenCalled();
+    expect(h.db.update).not.toHaveBeenCalled();
+    expect(h.tx.select).toHaveBeenCalledTimes(1);
+    expect(h.tx.for).toHaveBeenCalledWith('update');
+    expect(h.tx.update).toHaveBeenCalledTimes(1);
+    expect(h.written).toHaveLength(1);
+    expect(h.emitted).toEqual([{ kind: 'change-request-edited', number: 9 }]);
+  });
+
+  it('drops the cached reads and tells every session, so readers see the new text at once', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    await h.svc.updateChangeRequest(9, user(AUTHOR), { title: 'New' });
+    expect(h.prs.invalidateDetailCache).toHaveBeenCalledWith(9);
+    expect(h.emitted).toEqual([{ kind: 'change-request-edited', number: 9 }]);
+  });
+
+  it('a merge that won the race refuses the edit with the merged 409', async () => {
+    const h = harness({ authorEmail: AUTHOR });
+    (h.tx.returning as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+    (h.prs.getPr as ReturnType<typeof vi.fn>)
+      .mockResolvedValueOnce({ state: 'open', authorId: hashEmail(AUTHOR), base: 'main' })
+      .mockResolvedValueOnce({ state: 'merged' });
+    await expect(h.svc.updateChangeRequest(9, user(AUTHOR), { title: 'New' })).rejects.toMatchObject({
+      status: 409,
+      message: expect.stringContaining('already been applied'),
+    });
+    expect(h.emitted).toEqual([]);
+  });
+});

package/src/modules/workflow/agent-tools/__tests__/change-request-read-shape.test.ts

@@ -1,12 +1,11 @@
 import { describe, expect, it } from 'vitest';
-import type {
-  ChangeRequest,
-  ChangeRequestDetail,
-  FileApproval,
+import {
+  type ChangeRequest,
+  type ChangeRequestDetail,
+  type FileApproval,
 } from '@bevel-software/platform-shared';
 import { hashEmail } from '../../../../shared/email-identity.js';
 import {
-  authorsDescription,
   fileIsReadable,
   isAuthor,
   loginFor,
@@ -16,11 +15,10 @@ import {
   pagingOf,
   pathsOf,
   statesFor,
+  toCrDetail,
   toCrViewer,
   toCrSummary,
   APPLY_FAILURE_REASON_WITHHELD,
-  visibleComments,
-  toCrComment,
   toCrFile,
   toCrReviews,
   visibleBlockers,
@@ -373,56 +371,6 @@ describe('reviews, gathered out of the per-file approvals', () => {
   });
 });
 
-describe('comments', () => {
-  // Scenario: WHEN a reviewer left an inline comment and a reply followed THEN
-  // `list_change_request_comments` returns both, the reply with `parentId`.
-  it('maps an inline comment and a reply, the reply carrying `parentId`', () => {
-    const inline = toCrComment({
-      id: 'c-1',
-      author: { email: 'mia@bevel.software', name: 'Mia' },
-      body: 'This line is out of date.',
-      path: 'Knowledge/A.md',
-      line: 14,
-      headSha: 'head-1',
-      createdAt: '2026-09-29T08:00:00.000Z',
-    });
-    expect(inline).toEqual({
-      id: 'c-1',
-      author: { login: loginFor('mia@bevel.software'), name: 'Mia', email: 'mia@bevel.software' },
-      body: 'This line is out of date.',
-      path: 'Knowledge/A.md',
-      line: 14,
-      headSha: 'head-1',
-      createdAt: '2026-09-29T08:00:00.000Z',
-    });
-    const reply = toCrComment({
-      id: 'c-2',
-      author: { email: AUTHOR, name: 'Juan' },
-      body: 'Fixed.',
-      path: 'Knowledge/A.md',
-      line: 14,
-      headSha: 'head-1',
-      parentId: 'c-1',
-      createdAt: '2026-09-29T09:00:00.000Z',
-      updatedAt: '2026-09-29T09:05:00.000Z',
-    });
-    expect(reply).toMatchObject({ parentId: 'c-1', updatedAt: '2026-09-29T09:05:00.000Z' });
-  });
-
-  it('leaves `path`, `line` and `parentId` off a general comment', () => {
-    const general = toCrComment({
-      id: 'c-3',
-      author: { email: AUTHOR, name: 'Juan' },
-      body: 'Ready for review.',
-      headSha: 'head-1',
-      createdAt: '2026-09-29T07:00:00.000Z',
-    });
-    expect(general.path).toBeUndefined();
-    expect(general.line).toBeUndefined();
-    expect(general.parentId).toBeUndefined();
-  });
-});
-
 describe('the viewer block — what this caller may do', () => {
   const detail = (over: Partial<ChangeRequestDetail> = {}) =>
     ({
@@ -520,71 +468,34 @@ describe('merge blockers never name a file the caller may not read', () => {
 });
 
 /**
- * The leak Local Testing caught on the first attempt: `openChangeRequest`
- * appends a generated `## Affected owners` block to the body, naming every
- * changed path and its approvers, and the detail returned the body verbatim.
+ * The body is the description and nothing else — Hexis writes none of its own
+ * facts into it — so a caller is handed it verbatim, whatever they may read:
+ * a path in it is one the author chose to write about.
  */
-describe('the body a caller is handed is the author\'s, not the machine\'s', () => {
-  const GENERATED = [
-    '## Affected owners',
-    '',
-    '- `KnowledgeBase/Engineering/Knowledge/Avi-Checkin.md` — Admin',
-    '- `KnowledgeBase/GTM/Notes.md` — GTM Team',
-  ].join('\n');
-
-  it('drops the generated owners block, keeping what the author typed', () => {
-    expect(authorsDescription(`Please take a look.\n\n${GENERATED}`)).toBe('Please take a look.');
-    expect(authorsDescription(GENERATED)).toBe('');
-  });
-
-  it('names no path of the generated block, readable or not', () => {
-    const out = authorsDescription(`Why this is needed.\n\n${GENERATED}`);
-    expect(out).not.toContain('Avi-Checkin');
-    expect(out).not.toContain('KnowledgeBase');
-    expect(out).not.toContain('Affected owners');
-  });
-
-  it("strips the hidden identity markers older bodies carry, and only those — an author's own HTML comment is prose", () => {
-    expect(authorsDescription('<!-- bevel:author:abc123 -->\nMy reason.')).toBe('My reason.');
-    expect(authorsDescription('<!--hexis:access-request-level:write-->\nMy reason.')).toBe('My reason.');
-    expect(authorsDescription('My reason.\n<!-- TODO: ask Mia about the title -->')).toBe(
-      'My reason.\n<!-- TODO: ask Mia about the title -->',
-    );
-  });
-
-  it('leaves a body that is only the author\'s prose alone', () => {
-    expect(authorsDescription('  A multi-line\nreason.  ')).toBe('A multi-line\nreason.');
-    expect(authorsDescription('')).toBe('');
-  });
-
-  // Razvan's review (2026-10-02): the first cut copied the app's dialog, which
-  // drops everything from the first `##` heading on. An author who writes their
-  // description in sections lost it from that heading onwards, and was never
-  // told. The cut is now the generated block and nothing else.
-  it("keeps the author's own headings, and everything under them", () => {
-    expect(authorsDescription('Lead.\n\n## My own heading\n\nmore')).toBe(
-      'Lead.\n\n## My own heading\n\nmore',
-    );
-    expect(authorsDescription(`Lead.\n\n## Why now\n\nBecause.\n\n${GENERATED}`)).toBe(
-      'Lead.\n\n## Why now\n\nBecause.',
-    );
-  });
-
-  // Hexis appends the block LAST, so the last such line is always the generated
-  // one — which is what makes an author who happens to use that heading
-  // themselves no worse off than before.
-  it('cuts the LAST such heading, so an author may use the words too', () => {
-    const out = authorsDescription(`Lead.\n\n## Affected owners\n\nI mean the GTM ones.\n\n${GENERATED}`);
-    expect(out).toBe('Lead.\n\n## Affected owners\n\nI mean the GTM ones.');
-    // Their sentence is kept; not one path of the generated block is.
-    expect(out).not.toContain('Avi-Checkin');
-    expect(out).not.toContain('KnowledgeBase');
-  });
-
-  it('cuts an author\'s own owners heading when there is no generated block', () => {
-    // Indistinguishable from the generated one with nothing after it, so it is
-    // cut — the safe direction, and the only way this can err.
-    expect(authorsDescription('Lead.\n\n## Affected owners\n\nI mean the GTM ones.')).toBe('Lead.');
+describe('the body a caller is handed is the stored one', () => {
+  const body = 'Lead.\n\n## Why now\n\nBecause of `Knowledge/Secret.md`.\n<!-- my own aside -->';
+  const stored = {
+    ...summary(),
+    body,
+    headSha: 'a'.repeat(40),
+    baseSha: 'b'.repeat(40),
+    files: [],
+    approvals: [],
+    mergeableInBevel: false,
+    mergeBlockedReasons: [],
+    mergeWarnings: [],
+    viewerCanBypassMerge: false,
+  } as unknown as ChangeRequestDetail;
+
+  it('is the body as stored, headings and comments included', () => {
+    const out = toCrDetail(stored, { readable: 1, withheld: 0 }, { visible: [], withheld: 0 }, toCrViewer(stored, false, []));
+    expect(out.body).toBe(body);
+  });
+
+  it('does not vary by what the caller may read', () => {
+    const forReader = toCrDetail(stored, { readable: 0, withheld: 1 }, { visible: [], withheld: 1 }, toCrViewer(stored, false, []));
+    const forAuthor = toCrDetail(stored, { readable: 1, withheld: 0 }, { visible: [], withheld: 0 }, toCrViewer(stored, true, []));
+    expect(forReader.body).toBe(forAuthor.body);
   });
 });
 
@@ -615,91 +526,3 @@ describe('a renamed file is judged on both of its names', () => {
     expect(pathsOf({ path: 'A.md' })).toEqual(['A.md']);
   });
 });
-
-/**
- * A reply is shown only when the comment it replies to is (Razvan's review,
- * 2026-10-02, finding 3). A reply posted without a path of its own — which
- * `post_change_request_comment` accepts, taking `parentId` without `path` — read
- * as a general comment when judged on itself, so a reply to a comment on a
- * withheld file came back with its body and a `parentId` naming a comment the
- * caller cannot see.
- */
-describe('a reply takes its parent\'s verdict, up the chain', () => {
-  const c = (id: string, over: { path?: string; parentId?: string } = {}) => ({ id, ...over });
-  const mayShow = (path: string) => path.startsWith('Open/');
-
-  it('withholds a pathless reply to a comment on a file the caller may not read', () => {
-    const { visible, withheld } = visibleComments(
-      [c('c-1', { path: 'Secret/Pay.md' }), c('c-2', { parentId: 'c-1' })],
-      mayShow,
-    );
-    expect(visible).toEqual([]);
-    expect(withheld).toBe(2);
-  });
-
-  it('withholds a reply to that reply, however deep the thread goes', () => {
-    const { visible, withheld } = visibleComments(
-      [
-        c('c-1', { path: 'Secret/Pay.md' }),
-        c('c-2', { parentId: 'c-1' }),
-        c('c-3', { parentId: 'c-2' }),
-        c('c-4', { parentId: 'c-3' }),
-      ],
-      mayShow,
-    );
-    expect(visible).toEqual([]);
-    expect(withheld).toBe(4);
-  });
-
-  it('keeps a reply whose whole chain is readable', () => {
-    const { visible, withheld } = visibleComments(
-      [c('c-1', { path: 'Open/A.md' }), c('c-2', { parentId: 'c-1' }), c('c-3', { parentId: 'c-2' })],
-      mayShow,
-    );
-    expect(visible.map((v) => v.id)).toEqual(['c-1', 'c-2', 'c-3']);
-    expect(withheld).toBe(0);
-  });
-
-  // Both halves of the rule are needed, and this is the half the inheritance
-  // alone would miss: the reply names a withheld file itself.
-  it('withholds a reply that names a withheld file under a readable parent', () => {
-    const { visible } = visibleComments(
-      [c('c-1', { path: 'Open/A.md' }), c('c-2', { path: 'Secret/Pay.md', parentId: 'c-1' })],
-      mayShow,
-    );
-    expect(visible.map((v) => v.id)).toEqual(['c-1']);
-  });
-
-  it('keeps a general comment and a reply to one — neither is about a file', () => {
-    const { visible, withheld } = visibleComments([c('c-1'), c('c-2', { parentId: 'c-1' })], mayShow);
-    expect(visible.map((v) => v.id)).toEqual(['c-1', 'c-2']);
-    expect(withheld).toBe(0);
-  });
-
-  it('withholds a reply whose parent is not in the list at all', () => {
-    // Not provably pathless, so it goes: the parent may have been anchored to
-    // anything, including a file this caller was refused.
-    const { visible, withheld } = visibleComments([c('c-2', { parentId: 'gone' })], mayShow);
-    expect(visible).toEqual([]);
-    expect(withheld).toBe(1);
-  });
-
-  it('withholds a cycle rather than looping on it', () => {
-    const { visible, withheld } = visibleComments(
-      [c('c-1', { parentId: 'c-2' }), c('c-2', { parentId: 'c-1' })],
-      mayShow,
-    );
-    expect(visible).toEqual([]);
-    expect(withheld).toBe(2);
-  });
-
-  it('resolves a long thread without re-walking it per reply', () => {
-    // 500 replies in one chain: memoised, this is linear; unmemoised it is
-    // quadratic and the suite would feel it.
-    const chain = [c('c-0', { path: 'Open/A.md' })];
-    for (let i = 1; i <= 500; i++) chain.push(c(`c-${i}`, { parentId: `c-${i - 1}` }));
-    const { visible, withheld } = visibleComments(chain, mayShow);
-    expect(visible).toHaveLength(501);
-    expect(withheld).toBe(0);
-  });
-});