@bevel-software/platform-core-backend 0.13.6 → 0.14.0

package/src/modules/workflow/__tests__/workflow.service.branch-in-use.test.ts

@@ -0,0 +1,337 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { drizzle } from 'drizzle-orm/pg-proxy';
+import { configureBranchModel } from '@bevel-software/platform-shared';
+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 { WorkspaceService } from '../../workspace/workspace.service.js';
+import type { IAccessControl } from '../../access/access-control.interface.js';
+import type { FileLockService } from '../file-lock.service.js';
+import type { PendingCommitsService } from '../pending-commits.service.js';
+import type { Database } from '../../database/connection.js';
+import { WorkflowService } from '../workflow.service.js';
+
+/**
+ * A branch is load-bearing for a change request at EITHER end.
+ *
+ * The regression: merging `X -> main` retired X while a second open request
+ * `Y -> X` still proposed INTO it. Every guard asked only "is X anybody's
+ * SOURCE?", so X was deleted and `Y -> X` became permanently unusable — it
+ * could not be read (the detail read resolves the target first), declined, or
+ * deleted, and the boot sweep looked at sources only, so it survived every
+ * restart.
+ *
+ * These tests run the REAL drizzle query against seeded rows (via the pg-proxy
+ * driver, which hands the generated SQL and its parameters to a callback)
+ * rather than a stub that answers by call order. That is deliberate: a mock
+ * blind to the `where` clause returns the same row whether the guard asks
+ * about one branch end or both, so it would pass just as happily against the
+ * source-only code this fixes — it could not detect the regression it exists
+ * for. Here, reverting `openChangeRequestOn` to a source-only lookup makes the
+ * seeded `Y -> X` row stop matching, and these tests fail.
+ */
+
+interface CrRow {
+  number: number;
+  source_branch: string;
+  target_branch: string;
+  state: string;
+}
+
+/**
+ * A `change_requests` table that answers the query it is actually given.
+ *
+ * The driver receives real SQL and real parameters, so the predicate is read
+ * back off the statement: every `"column" = $n` becomes a (column, value)
+ * pair. One value bound to SEVERAL columns is the either-end test and ORs
+ * across them (`source_branch = $1 or target_branch = $1`); distinct values
+ * AND together (`… and state = $2`). Non-`select` statements report one
+ * affected row, which is the guarded update in the sweep succeeding.
+ */
+function fakeDb(rows: CrRow[]) {
+  const statements: string[] = [];
+  const db = drizzle(async (sql: string, params: unknown[]) => {
+    statements.push(sql);
+    if (!/^\s*select/i.test(sql)) return { rows: [['row-id']] };
+
+    const projection = (/^\s*select\s+(.+?)\s+from\s/is.exec(sql)?.[1] ?? '')
+      .split(',')
+      .map((item) => item.trim().replace(/.*"(\w+)"$/, '$1'));
+
+    const byValue = new Map<unknown, string[]>();
+    for (const m of sql.matchAll(/"(\w+)"\s*=\s*\$(\d+)/g)) {
+      const value = params[Number(m[2]) - 1];
+      byValue.set(value, [...(byValue.get(value) ?? []), m[1]!]);
+    }
+
+    // Reading the predicate off the statement means the reader can go stale
+    // against a future drizzle that quotes, aliases or parameterises
+    // differently. That is survivable ONLY if it fails loudly: an unparsed
+    // WHERE would leave `byValue` empty, `every` over nothing is vacuously
+    // true, and every seeded row would match — which is exactly the blind
+    // mock this harness replaced, silently restored. So refuse to answer a
+    // statement this cannot actually read.
+    if (!projection.length || projection.some((c) => !/^\w+$/.test(c))) {
+      throw new Error(`fakeDb could not read the projection of: ${sql}`);
+    }
+    if (/\bwhere\b/i.test(sql) && byValue.size === 0) {
+      throw new Error(`fakeDb could not read the predicate of: ${sql}`);
+    }
+
+    const matched = rows.filter((row) =>
+      [...byValue].every(([value, columns]) =>
+        columns.some((c) => row[c as keyof CrRow] === value),
+      ),
+    );
+    return { rows: matched.map((row) => projection.map((c) => row[c as keyof CrRow])) };
+  });
+  return { db: db as unknown as Database, statements };
+}
+
+function makeService(db: Database, git: Partial<GitService>) {
+  return new WorkflowService(
+    db,
+    git as GitService,
+    { invalidateDetailCache: vi.fn() } as unknown as PullRequestService,
+    {} as IReviewWorkflowService,
+    {
+      getOrCreateForBranch: vi.fn(async () => ({ id: 'ws-target' })),
+      ensureRemotesFetched: vi.fn(async () => undefined),
+      hasBootstrappedWorkspace: vi.fn(async () => false),
+    } as unknown as WorkspaceService,
+    {} as IAccessControl,
+    {} as FileLockService,
+    {} as PendingCommitsService,
+    'knowledge-base',
+  );
+}
+
+const USER = { email: 'juan@example.com', name: 'Juan', id: 'u1' };
+
+/** The merged request, and a second one still proposing INTO its source. */
+const MERGED_23: CrRow = {
+  number: 23,
+  source_branch: 'juan/rfi',
+  target_branch: 'target-company-state',
+  state: 'merged',
+};
+const OPEN_24_INTO_RFI: CrRow = {
+  number: 24,
+  source_branch: 'juan/rfi-mock',
+  target_branch: 'juan/rfi',
+  state: 'open',
+};
+
+function retire(svc: WorkflowService, number: number, base: string) {
+  return (
+    svc as unknown as {
+      retireMergedSourceBranch(n: number, base: string, u: unknown): Promise<void>;
+    }
+  ).retireMergedSourceBranch(number, base, USER);
+}
+
+beforeEach(() => {
+  configureBranchModel({
+    defaultBranch: 'target-company-state',
+    protectedBranches: ['current-company-state', 'target-company-state'],
+  });
+});
+
+describe('post-merge branch retirement', () => {
+  it('keeps a branch another open request proposes INTO', async () => {
+    const deleted: string[] = [];
+    const { db, statements } = fakeDb([MERGED_23, OPEN_24_INTO_RFI]);
+    const svc = makeService(db, {
+      deleteBranch: vi.fn(async (_ws: string, name: string) => void deleted.push(name)),
+    });
+
+    await retire(svc, 23, 'target-company-state');
+
+    expect(deleted).toEqual([]);
+    // The guard must ask about both ends — a statement naming only
+    // `source_branch` is the regression.
+    expect(statements.some((q) => /target_branch/.test(q))).toBe(true);
+  });
+
+  it('still retires a branch nothing open needs', async () => {
+    const deleted: string[] = [];
+    // #24 is gone; only the merged request remains, so nothing needs the branch.
+    const { db } = fakeDb([MERGED_23]);
+    const svc = makeService(db, {
+      deleteBranch: vi.fn(async (_ws: string, name: string) => void deleted.push(name)),
+    });
+
+    await retire(svc, 23, 'target-company-state');
+
+    expect(deleted).toEqual(['juan/rfi']);
+  });
+
+  it('keeps a branch another open request proposes FROM', async () => {
+    const deleted: string[] = [];
+    const { db } = fakeDb([
+      MERGED_23,
+      { number: 25, source_branch: 'juan/rfi', target_branch: 'other', state: 'open' },
+    ]);
+    const svc = makeService(db, {
+      deleteBranch: vi.fn(async (_ws: string, name: string) => void deleted.push(name)),
+    });
+
+    await retire(svc, 23, 'target-company-state');
+
+    expect(deleted).toEqual([]);
+  });
+});
+
+describe('deleteBranch', () => {
+  it('refuses a branch an open request proposes INTO, naming who can act', async () => {
+    const { db } = fakeDb([OPEN_24_INTO_RFI]);
+    const svc = makeService(db, { deleteBranch: vi.fn() });
+
+    // Not "withdraw or decline it": the request belongs to someone else, and
+    // the branch owner may be authorized to do neither. The message has to
+    // say what the situation is and who can clear it.
+    await expect(svc.deleteBranch('ws', 'juan/rfi', USER)).rejects.toThrow(
+      /change request #24 proposes changes into "juan\/rfi"/,
+    );
+  });
+
+  it('refuses a branch an open request proposes FROM, offering the withdraw verb', async () => {
+    const { db } = fakeDb([
+      { number: 26, source_branch: 'juan/rfi', target_branch: 'target-company-state', state: 'open' },
+    ]);
+    const svc = makeService(db, { deleteBranch: vi.fn() });
+
+    await expect(svc.deleteBranch('ws', 'juan/rfi', USER)).rejects.toThrow(
+      /open change request \(#26\)\. Withdraw or decline it/,
+    );
+  });
+
+  it('allows a branch no open request names', async () => {
+    const deleted: string[] = [];
+    const { db } = fakeDb([OPEN_24_INTO_RFI]);
+    const svc = makeService(db, {
+      deleteBranch: vi.fn(async (_ws: string, name: string) => void deleted.push(name)),
+    });
+
+    await svc.deleteBranch('ws', 'juan/unrelated', USER);
+
+    expect(deleted).toEqual(['juan/unrelated']);
+  });
+});
+
+describe('runOnBranchPair', () => {
+  function deferred() {
+    let resolve!: () => void;
+    const promise = new Promise<void>((r) => { resolve = r; });
+    return { promise, resolve };
+  }
+
+  type LockInternals = {
+    branchLifecycle: { run(key: string, fn: () => Promise<void>): Promise<void> };
+    runOnBranchPair(source: string, target: string, fn: () => Promise<void>): Promise<void>;
+  };
+
+  function locks(svc: WorkflowService) {
+    return svc as unknown as LockInternals;
+  }
+
+  it('waits on an unprotected target: its key really is reserved', async () => {
+    const { db } = fakeDb([]);
+    const svc = locks(makeService(db, {}));
+    const order: string[] = [];
+    const release = deferred();
+
+    const holder = svc.branchLifecycle.run('branch:juan/rfi', async () => {
+      await release.promise;
+      order.push('holder');
+    });
+    await new Promise((r) => setImmediate(r));
+
+    const pair = svc.runOnBranchPair('juan/other', 'juan/rfi', async () => {
+      order.push('pair');
+    });
+    await new Promise((r) => setImmediate(r));
+    expect(order).toEqual([]);
+
+    release.resolve();
+    await Promise.all([holder, pair]);
+    expect(order).toEqual(['holder', 'pair']);
+  });
+
+  it('does not reserve a PROTECTED target key', async () => {
+    // No path in the system can delete a protected branch, so the key would
+    // exclude nothing while serializing every open into the default branch,
+    // which is where nearly all requests point. The pair operation must run
+    // even while something else holds the protected branch's key.
+    const { db } = fakeDb([]);
+    const svc = locks(makeService(db, {}));
+    const order: string[] = [];
+    const release = deferred();
+
+    const holder = svc.branchLifecycle.run('branch:target-company-state', async () => {
+      await release.promise;
+      order.push('holder');
+    });
+    await new Promise((r) => setImmediate(r));
+
+    await svc.runOnBranchPair('juan/other', 'target-company-state', async () => {
+      order.push('pair');
+    });
+    expect(order).toEqual(['pair']);
+
+    release.resolve();
+    await holder;
+  });
+
+  it('always reserves the source key', async () => {
+    const { db } = fakeDb([]);
+    const svc = locks(makeService(db, {}));
+    const order: string[] = [];
+    const release = deferred();
+
+    const holder = svc.branchLifecycle.run('branch:juan/other', async () => {
+      await release.promise;
+      order.push('holder');
+    });
+    await new Promise((r) => setImmediate(r));
+
+    const pair = svc.runOnBranchPair('juan/other', 'target-company-state', async () => {
+      order.push('pair');
+    });
+    await new Promise((r) => setImmediate(r));
+    expect(order).toEqual([]);
+
+    release.resolve();
+    await Promise.all([holder, pair]);
+    expect(order).toEqual(['holder', 'pair']);
+  });
+});
+
+describe('closeChangeRequestsWithDeletedBranches', () => {
+  it('closes a request whose TARGET branch is gone', async () => {
+    const { db } = fakeDb([OPEN_24_INTO_RFI]);
+    const svc = makeService(db, {
+      // #24's source lives on; its target `juan/rfi` is gone.
+      listBranches: vi.fn(async () => [
+        { name: 'target-company-state' },
+        { name: 'juan/rfi-mock' },
+      ]),
+    } as unknown as Partial<GitService>);
+
+    await expect(svc.closeChangeRequestsWithDeletedBranches()).resolves.toBe(1);
+  });
+
+  it('leaves a request whose branches both exist', async () => {
+    const { db } = fakeDb([
+      { ...OPEN_24_INTO_RFI, target_branch: 'target-company-state' },
+    ]);
+    const svc = makeService(db, {
+      listBranches: vi.fn(async () => [
+        { name: 'target-company-state' },
+        { name: 'juan/rfi-mock' },
+      ]),
+    } as unknown as Partial<GitService>);
+
+    await expect(svc.closeChangeRequestsWithDeletedBranches()).resolves.toBe(0);
+  });
+});

package/src/modules/workflow/__tests__/workflow.service.deleted-branch-sweep.test.ts

@@ -114,7 +114,13 @@ describe('closeChangeRequestsWithDeletedBranches', () => {
       { name: 'x' },
     ]);
     await svc.closeChangeRequestsWithDeletedBranches();
-    expect(git.listBranches).toHaveBeenCalledWith('target-company-state', { freshFetch: true });
+    expect(git.listBranches).toHaveBeenCalledWith('target-company-state', {
+      freshFetch: true,
+      // Strict: a fetch that cannot be proven fresh throws instead of serving
+      // stale refs, and the sweep's catch closes nothing. Without this, a
+      // branch created after the clone's last good fetch reads as "deleted".
+      strictFetch: true,
+    });
   });
 
   /**

package/src/modules/workflow/__tests__/workflow.service.facade.test.ts

@@ -16,14 +16,61 @@ import { PullRebaseConflictError } from '../../../shared/domain-errors.js';
 import type { Database } from '../../database/connection.js';
 
 // `deleteBranch`'s open-request guard is the only DB touch these tests
-// exercise: a chainable select→from→where→limit stub resolving `rows` covers
-// it (rows default to "no open request").
-function makeDb(rows: unknown[] = []): Database {
+// exercise. The stub ANSWERS FROM THE WHERE-CLAUSE rather than returning the
+// rows unfiltered — a guard that dropped the `state = 'open'` filter or asked
+// about only one branch end used to pass these tests anyway, because any row
+// came back regardless of the predicate.
+//
+// The evaluator walks the drizzle condition tree (duck-typing the
+// SQL/Column/Param/StringChunk shapes) and evaluates it against the row:
+// an `eq(column, value)` leaf compares the row's field, and a node combines
+// its children with whichever connector its literal chunks carry (`and` /
+// `or` — drizzle nests them, so one node never mixes both).
+function rowMatches(cond: unknown, row: Record<string, unknown>): boolean {
+  // snake_case column → camelCase row field (the stubs carry row objects in
+  // the service's own field names).
+  const field = (col: string) => col.replace(/_([a-z])/g, (_, ch: string) => ch.toUpperCase());
+  const evalNode = (node: unknown): boolean => {
+    const chunks = (node as { queryChunks?: unknown[] }).queryChunks;
+    if (!Array.isArray(chunks)) return true;
+    const results: boolean[] = [];
+    let anyOr = false;
+    let pendingColumn: string | null = null;
+    for (const c of chunks) {
+      if (!c || typeof c !== 'object') continue;
+      if ('queryChunks' in c) {
+        results.push(evalNode(c));
+      } else if ('name' in c && 'keyAsName' in c) {
+        pendingColumn = String((c as { name: unknown }).name);
+      } else if ('encoder' in c && 'value' in c) {
+        if (pendingColumn !== null) {
+          results.push(row[field(pendingColumn)] === (c as { value: unknown }).value);
+          pendingColumn = null;
+        }
+      } else if ('value' in c) {
+        if (String((c as { value: unknown }).value).includes(' or ')) anyOr = true;
+      }
+    }
+    // A node this walker cannot decompose (`inArray`, `isNull`, a future
+    // rewrite of the query) must NOT read as a match — `true` here would be
+    // the permissive direction, returning rows the real query excludes and
+    // masking exactly the guard regressions these tests exist to catch.
+    if (results.length === 0) return false;
+    return anyOr ? results.some(Boolean) : results.every(Boolean);
+  };
+  return evalNode(cond);
+}
+
+function makeDb(rows: Record<string, unknown>[] = []): Database {
+  let lastWhere: unknown;
   const chain = {
     select: vi.fn(() => chain),
     from: vi.fn(() => chain),
-    where: vi.fn(() => chain),
-    limit: vi.fn(async () => rows),
+    where: vi.fn((cond: unknown) => {
+      lastWhere = cond;
+      return chain;
+    }),
+    limit: vi.fn(async () => rows.filter((r) => rowMatches(lastWhere, r))),
   };
   return chain as unknown as Database;
 }
@@ -435,11 +482,27 @@ describe('WorkflowService — file lock delegation', () => {
   it('deleteBranch refuses while the branch carries an open change request', async () => {
     const git = makeGit();
     // One open request rides the branch — deleting it would strand the request.
-    const svc = new WorkflowService(makeDb([{ number: 7 }]), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), 'knowledge-base');
+    // `sourceBranch` matters to the guard now: it decides whether the refusal
+    // says "withdraw yours" (source) or names the other request's actors (target).
+    const svc = new WorkflowService(makeDb([{ number: 7, sourceBranch: 'feat/x', targetBranch: 'dev', state: 'open' }]), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), 'knowledge-base');
     await expect(svc.deleteBranch('w1', 'feat/x', makeUser())).rejects.toThrow(/open change request \(#7\)/);
     expect(git.deleteBranch).not.toHaveBeenCalled();
   });
 
+  it('deleteBranch refuses when an open request proposes INTO the branch (target end)', async () => {
+    const git = makeGit();
+    const svc = new WorkflowService(makeDb([{ number: 9, sourceBranch: 'other/y', targetBranch: 'feat/x', state: 'open' }]), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), 'knowledge-base');
+    await expect(svc.deleteBranch('w1', 'feat/x', makeUser())).rejects.toThrow(/proposes changes into/);
+    expect(git.deleteBranch).not.toHaveBeenCalled();
+  });
+
+  it('deleteBranch proceeds past a CLOSED request — the guard filters on state, not mere mention', async () => {
+    const git = makeGit();
+    const svc = new WorkflowService(makeDb([{ number: 7, sourceBranch: 'feat/x', targetBranch: 'dev', state: 'closed' }]), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), 'knowledge-base');
+    await expect(svc.deleteBranch('w1', 'feat/x', makeUser())).resolves.toBeUndefined();
+    expect(git.deleteBranch).toHaveBeenCalled();
+  });
+
   it('deleteBranch deletes when the branch has no open change request', async () => {
     const git = makeGit();
     const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), 'knowledge-base');
@@ -656,8 +719,9 @@ describe('WorkflowService — deleteChangeRequest (admin moderation verb)', () =
       set: vi.fn(() => chain),
       returning: vi.fn(async () => [{ id: 1 }]),
     });
-    const svc = new WorkflowService(chain as unknown as Database, git, prs, makeReviewWorkflow(), makeWorkspaceService(), access, makeFileLockService(), makePendingCommits(), 'knowledge-base');
-    return { svc, prs, db: chain, access };
+    const workspaces = makeWorkspaceService();
+    const svc = new WorkflowService(chain as unknown as Database, git, prs, makeReviewWorkflow(), workspaces, access, makeFileLockService(), makePendingCommits(), 'knowledge-base');
+    return { svc, prs, db: chain, access, workspaces };
   }
 
   it('refuses a non-admin with 403 and touches nothing', async () => {
@@ -678,4 +742,27 @@ describe('WorkflowService — deleteChangeRequest (admin moderation verb)', () =
     await expect(svc.deleteChangeRequest(9, makeUser())).rejects.toMatchObject({ status: 422 });
     expect(db.update).not.toHaveBeenCalled();
   });
+
+  it('kicks the deleted-branch sweep when the base workspace cannot be resolved', async () => {
+    const { svc, db, workspaces } = makeDeleteHarness({ isAdmin: true });
+    (workspaces.getOrCreateForBranch as ReturnType<typeof vi.fn>).mockRejectedValue(
+      new Error('Remote branch main not found in upstream origin'),
+    );
+    const sweep = vi.spyOn(svc, 'closeChangeRequestsWithDeletedBranches').mockResolvedValue(0);
+
+    // The failure still surfaces (it is not proven absence, so the verb must
+    // not pretend to succeed), but the sweep is kicked so a genuinely
+    // stranded request is closed without waiting for a restart.
+    await expect(svc.deleteChangeRequest(9, makeUser())).rejects.toThrow(/not found/);
+    expect(sweep).toHaveBeenCalledTimes(1);
+    expect(db.update).not.toHaveBeenCalled();
+  });
+
+  it('does not kick the sweep on a plain authorization refusal', async () => {
+    const { svc, db } = makeDeleteHarness({ isAdmin: false });
+    const sweep = vi.spyOn(svc, 'closeChangeRequestsWithDeletedBranches').mockResolvedValue(0);
+    await expect(svc.deleteChangeRequest(9, makeUser())).rejects.toMatchObject({ status: 403 });
+    expect(sweep).not.toHaveBeenCalled();
+    expect(db.update).not.toHaveBeenCalled();
+  });
 });

package/src/modules/workflow/git/__tests__/git.service.history-guards.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { GitService } from '../git.service.js';
+import { runGit, gitOut, stubWorkflowHooks, stubWorkspaceService } from './git-test-helpers.js';
+
+// The history surfaces are per-file: their read gate checked exactly one
+// path, but a directory pathspec walks every child — and `show <ref>:<dir>`
+// even prints the tree listing. A tree at the ref is refused; a file, and a
+// path absent at the ref, are served.
+
+describe('GitService history guards', () => {
+  let root: string;
+  const workspaceId = 'target-company-state';
+  let repo: string;
+  let sha: string;
+  let svc: GitService;
+
+  beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), 'bevel-git-histguard-'));
+    const workspaceDir = path.join(root, workspaceId);
+    repo = path.join(workspaceDir, 'knowledge-base');
+    await fs.mkdir(repo, { recursive: true });
+    await runGit(root, ['init', '-b', 'target-company-state', repo]);
+    await runGit(repo, ['config', 'user.email', 'workspace@bevel.test']);
+    await runGit(repo, ['config', 'user.name', 'bevel Workspace']);
+    await fs.mkdir(path.join(repo, 'docs'));
+    await fs.writeFile(path.join(repo, 'docs', 'child.md'), 'secret child\n');
+    await fs.writeFile(path.join(repo, 'top.md'), 'top\n');
+    await runGit(repo, ['add', '.']);
+    await runGit(repo, ['commit', '-m', 'seed']);
+    sha = await gitOut(repo, ['rev-parse', 'HEAD']);
+    svc = new GitService(
+      stubWorkspaceService({ [workspaceId]: workspaceDir }),
+      stubWorkflowHooks(),
+      'knowledge-base',
+    );
+  });
+
+  afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+  });
+
+  it('diffFileAtCommit refuses a directory and serves a file', async () => {
+    await expect(svc.diffFileAtCommit(workspaceId, 'knowledge-base/docs', sha)).rejects.toThrow(
+      /history is served per file/,
+    );
+    const diff = await svc.diffFileAtCommit(workspaceId, 'knowledge-base/top.md', sha);
+    expect(diff).toContain('top');
+  });
+
+  it('logForFile refuses a directory even when it was deleted before HEAD, and lists a file', async () => {
+    // A directory removed before HEAD is absent NOW — a HEAD-shape check
+    // passes — but `git log -- <dir>` still traverses its historical
+    // children. The proof comes from what the log touched.
+    await fs.rm(path.join(repo, 'docs'), { recursive: true });
+    await runGit(repo, ['add', '-A']);
+    await runGit(repo, ['commit', '-m', 'remove docs']);
+    await expect(svc.logForFile(workspaceId, 'knowledge-base/docs')).rejects.toThrow(
+      /history is served per file/,
+    );
+    const log = await svc.logForFile(workspaceId, 'knowledge-base/top.md');
+    expect(log.length).toBe(1);
+    expect(log[0]!.subject).toBe('seed');
+    expect(log[0]!.sha).toMatch(/^[0-9a-f]{40}$/);
+  });
+
+  it('fileContentsAtCommit refuses a directory and still serves a deleted file', async () => {
+    await expect(svc.fileContentsAtCommit(workspaceId, 'knowledge-base/docs', sha)).rejects.toThrow(
+      /history is served per file/,
+    );
+    // Delete the file; its history stays its own — absent is not a tree.
+    await fs.rm(path.join(repo, 'top.md'));
+    await runGit(repo, ['add', '-A']);
+    await runGit(repo, ['commit', '-m', 'remove top']);
+    const delSha = await gitOut(repo, ['rev-parse', 'HEAD']);
+    const { baseline, current } = await svc.fileContentsAtCommit(
+      workspaceId,
+      'knowledge-base/top.md',
+      delSha,
+    );
+    expect(baseline).toContain('top');
+    expect(current).toBeNull();
+  });
+});