@bevel-software/platform-core-backend 0.4.0 → 0.5.0

package/src/modules/workflow/__tests__/event-bus.test.ts

@@ -319,4 +319,39 @@ describe('WorkflowEventBus', () => {
       expect(bus.size()).toBe(0);
     });
   });
+
+  describe('onEmit — the server-side tap', () => {
+    it('sees every event, unfiltered by SSE scope, and unsubscribes cleanly', () => {
+      const bus = new WorkflowEventBus();
+      const seen: string[] = [];
+      const off = bus.onEmit((e) => seen.push(e.kind));
+      // A workspace-scoped event with NO matching SSE session still reaches
+      // the tap — scope filtering exists for sessions, not in-process
+      // consumers (write-time cache invalidation must never miss one).
+      bus.emit({ kind: 'fs-tree-changed', workspaceId: 'ws-1', branch: 'main' });
+      expect(seen).toEqual(['fs-tree-changed']);
+      off();
+      bus.emit({ kind: 'fs-tree-changed', workspaceId: 'ws-1', branch: 'main' });
+      expect(seen).toEqual(['fs-tree-changed']);
+    });
+
+    it('a throwing listener is contained — emit never propagates it', () => {
+      const bus = new WorkflowEventBus();
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      bus.onEmit(() => {
+        throw new Error('bad listener');
+      });
+      const after: string[] = [];
+      bus.onEmit((e) => after.push(e.kind));
+      expect(() =>
+        bus.emit({ kind: 'fs-tree-changed', workspaceId: 'ws-1', branch: 'main' }),
+      ).not.toThrow();
+      // …and the listeners after the bad one still ran.
+      expect(after).toEqual(['fs-tree-changed']);
+      // The containment is LOGGED, not silent — a listener dying quietly
+      // would be undebuggable.
+      expect(warn).toHaveBeenCalledWith('[event-bus] onEmit listener threw:', 'bad listener');
+      warn.mockRestore();
+    });
+  });
 });

package/src/modules/workflow/__tests__/pending-commits.enqueue-if-absent.test.ts

@@ -1,72 +1,82 @@
-import { describe, expect, it, vi } from 'vitest';
-import { PendingCommitsService } from '../pending-commits.service.js';
-import type { Database } from '../../database/connection.js';
-
-/**
- * `enqueueIfAbsent` backs the pull-conflict recovery dispatch: it must
- * insert only when NO row exists for the (workspace, branch, path) in ANY
- * status. A plain `enqueue` would refresh an existing pending row and reset
- * its retry counters — and the dispatch path fires on every sync attempt,
- * so those resets would starve the worker's ladder and the recovery agent
- * would never spawn. A `needs_attention` row must also block re-entry (the
- * ladder already escalated to a human; more agent runs are just a loop).
- *
- * Fake drizzle chain, same shape as the vault tests — the queue's SQL-level
- * behavior (claim fencing etc.) is covered elsewhere; this pins the
- * check-then-insert decision logic.
- */
-function makeFakeDb(existingCount: number) {
-  const inserted: unknown[] = [];
-  const selectChain: any = {};
-  selectChain.from = vi.fn(() => selectChain);
-  selectChain.where = vi.fn(() => selectChain);
-  selectChain.then = (onF: any, onR: any) =>
-    Promise.resolve([{ count: existingCount }]).then(onF, onR);
-  const insertChain: any = {};
-  insertChain.values = vi.fn((v: unknown) => {
-    inserted.push(v);
-    return insertChain;
-  });
-  insertChain.then = (onF: any, onR: any) => Promise.resolve(undefined).then(onF, onR);
-  const db = {
-    select: vi.fn(() => selectChain),
-    insert: vi.fn(() => insertChain),
-  } as unknown as Database;
-  return { db, inserted };
-}
-
-const INPUT = {
-  workspaceId: 'razvan.radulescu/feature',
-  branch: 'razvan.radulescu/feature',
-  path: 'PR-Overviews/PR-7.html',
-  authorEmail: 'Alice@Example.com',
-  authorName: 'Alice',
-};
-
-describe('PendingCommitsService.enqueueIfAbsent', () => {
-  it('inserts (canonical workspace id, lowercased email) when no row exists', async () => {
-    const { db, inserted } = makeFakeDb(0);
-    const svc = new PendingCommitsService(db);
-
-    await expect(svc.enqueueIfAbsent(INPUT)).resolves.toBe(true);
-
-    expect(inserted).toHaveLength(1);
-    expect(inserted[0]).toMatchObject({
-      // Same canonicalization as `enqueue` — the worker claims per the
-      // ENCODED `knownWorkspaces()` id, so a decoded id would never drain.
-      workspaceId: 'razvan.radulescu%2Ffeature',
-      branch: 'razvan.radulescu/feature',
-      path: 'PR-Overviews/PR-7.html',
-      authorEmail: 'alice@example.com',
-      authorName: 'Alice',
-    });
-  });
-
-  it('is a no-op when ANY row exists for the tuple (pending, running, or needs_attention)', async () => {
-    const { db, inserted } = makeFakeDb(1);
-    const svc = new PendingCommitsService(db);
-
-    await expect(svc.enqueueIfAbsent(INPUT)).resolves.toBe(false);
-    expect(inserted).toHaveLength(0);
-  });
-});
+import { describe, expect, it, vi } from 'vitest';
+import { PendingCommitsService } from '../pending-commits.service.js';
+import type { Database } from '../../database/connection.js';
+
+/**
+ * `enqueueIfAbsent` backs the pull-conflict recovery dispatch: it must
+ * insert only when NO row exists for the (workspace, branch, path) in ANY
+ * status. A plain `enqueue` would refresh an existing pending row and reset
+ * its retry counters — and the dispatch path fires on every sync attempt,
+ * so those resets would starve the worker's ladder and the recovery agent
+ * would never spawn. A `needs_attention` row must also block re-entry (the
+ * ladder already escalated to a human; more agent runs are just a loop).
+ *
+ * Fake drizzle chain, same shape as the vault tests — the queue's SQL-level
+ * behavior (claim fencing etc.) is covered elsewhere; this pins the
+ * check-then-insert decision logic.
+ */
+interface SelectChain extends PromiseLike<unknown> {
+  from: (...args: unknown[]) => SelectChain;
+  where: (...args: unknown[]) => SelectChain;
+}
+
+interface InsertChain extends PromiseLike<unknown> {
+  values: (...args: unknown[]) => InsertChain;
+}
+
+function makeFakeDb(existingCount: number) {
+  const inserted: unknown[] = [];
+  const selectChain: SelectChain = {
+    from: vi.fn(() => selectChain),
+    where: vi.fn(() => selectChain),
+    then: (onF, onR) => Promise.resolve([{ count: existingCount }]).then(onF, onR),
+  };
+  const insertChain: InsertChain = {
+    values: vi.fn((v: unknown) => {
+      inserted.push(v);
+      return insertChain;
+    }),
+    then: (onF, onR) => Promise.resolve(undefined).then(onF, onR),
+  };
+  const db = {
+    select: vi.fn(() => selectChain),
+    insert: vi.fn(() => insertChain),
+  } as unknown as Database;
+  return { db, inserted };
+}
+
+const INPUT = {
+  workspaceId: 'razvan.radulescu/feature',
+  branch: 'razvan.radulescu/feature',
+  path: 'PR-Overviews/PR-7.html',
+  authorEmail: 'Alice@Example.com',
+  authorName: 'Alice',
+};
+
+describe('PendingCommitsService.enqueueIfAbsent', () => {
+  it('inserts (canonical workspace id, lowercased email) when no row exists', async () => {
+    const { db, inserted } = makeFakeDb(0);
+    const svc = new PendingCommitsService(db);
+
+    await expect(svc.enqueueIfAbsent(INPUT)).resolves.toBe(true);
+
+    expect(inserted).toHaveLength(1);
+    expect(inserted[0]).toMatchObject({
+      // Same canonicalization as `enqueue` — the worker claims per the
+      // ENCODED `knownWorkspaces()` id, so a decoded id would never drain.
+      workspaceId: 'razvan.radulescu%2Ffeature',
+      branch: 'razvan.radulescu/feature',
+      path: 'PR-Overviews/PR-7.html',
+      authorEmail: 'alice@example.com',
+      authorName: 'Alice',
+    });
+  });
+
+  it('is a no-op when ANY row exists for the tuple (pending, running, or needs_attention)', async () => {
+    const { db, inserted } = makeFakeDb(1);
+    const svc = new PendingCommitsService(db);
+
+    await expect(svc.enqueueIfAbsent(INPUT)).resolves.toBe(false);
+    expect(inserted).toHaveLength(0);
+  });
+});

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

@@ -12,12 +12,20 @@ import type { IAccessControl } from '../../access/access-control.interface.js';
 import { FileLockService } from '../file-lock.service.js';
 import { PendingCommitsService } from '../pending-commits.service.js';
 import { WorkflowService } from '../workflow.service.js';
+import { PullRebaseConflictError } from '../workflow.errors.js';
 import type { Database } from '../../database/connection.js';
 
-// The facade tests never exercise `openChangeRequest` (the only method that
-// touches the DB), so a bare stub is enough to satisfy the constructor.
-function makeDb(): Database {
-  return {} as unknown as Database;
+// `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 {
+  const chain = {
+    select: vi.fn(() => chain),
+    from: vi.fn(() => chain),
+    where: vi.fn(() => chain),
+    limit: vi.fn(async () => rows),
+  };
+  return chain as unknown as Database;
 }
 
 function makeWorkspaceService(): WorkspaceService {
@@ -28,6 +36,9 @@ function makeWorkspaceService(): WorkspaceService {
     getWorkspacePath: vi.fn().mockResolvedValue('/tmp/ws'),
     sweepOrphanedWorkspaces: vi.fn().mockResolvedValue({ removed: [] }),
     getOrCreateForBranch: vi.fn(async (branch: string) => ({ id: encodeURIComponent(branch) })),
+    ensureRemotesFetched: vi.fn().mockResolvedValue(undefined),
+    hasBootstrappedWorkspace: vi.fn().mockResolvedValue(false),
+    deleteWorkspace: vi.fn().mockResolvedValue(undefined),
   } as unknown as WorkspaceService;
 }
 
@@ -50,6 +61,7 @@ function makePendingCommits(): PendingCommitsService {
   // behavior is covered by `pending-commits.service.test.ts`.
   return {
     enqueue: vi.fn().mockResolvedValue(undefined),
+    enqueueIfAbsent: vi.fn().mockResolvedValue(true),
     claimNext: vi.fn().mockResolvedValue(null),
     markSucceeded: vi.fn().mockResolvedValue(undefined),
     markTransientFailure: vi.fn().mockResolvedValue(undefined),
@@ -128,7 +140,6 @@ function makeGit(): GitService {
     diffStat: vi.fn(),
     pendingChanges: vi.fn(),
     resolveForkBase: vi.fn(),
-    revertCommit: vi.fn(),
     logForFile: vi.fn(),
     diffFileAtCommit: vi.fn(),
     diffFileBetweenBranches: vi.fn(),
@@ -327,6 +338,48 @@ describe('WorkflowService — change request delegation + cache invalidation', (
     );
     expect(prs.invalidateDetailCache).toHaveBeenCalledWith(4);
   });
+
+  it('mergeChangeRequest still merges when the post-merge pull conflicts, and queues recovery on the TARGET workspace', async () => {
+    const prs = makePrs();
+    const reviewWorkflow = makeReviewWorkflow();
+    const mergeResult = { prNumber: 4, sha: 'abc', mergedAt: 't' };
+    (reviewWorkflow.mergePr as ReturnType<typeof vi.fn>).mockResolvedValue(mergeResult);
+    (prs.getPr as ReturnType<typeof vi.fn>).mockResolvedValue({ branch: 'alice/feat', base: 'main' });
+
+    const git = makeGit();
+    const conflict = new PullRebaseConflictError(
+      'main',
+      // Deliberately unsorted — the representative row must be the smallest.
+      ['b-second.md', 'a-first.md'],
+      'git rebase failed: could not apply deadbee',
+    );
+    (git.pull as ReturnType<typeof vi.fn>).mockRejectedValue(conflict);
+    const workspaceService = makeWorkspaceService();
+    // Return an id that ISN'T derivable from the branch name, pinning that
+    // the dispatch uses the id `getOrCreateForBranch` returned rather than
+    // re-deriving it.
+    (workspaceService.getOrCreateForBranch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      id: 'resolved-target-ws',
+    });
+    const pending = makePendingCommits();
+    const svc = new WorkflowService(makeDb(), git, prs, reviewWorkflow, workspaceService, makeAccessControl(), makeFileLockService(), pending, 'knowledge-base');
+
+    const outcome = await svc.mergeChangeRequest(
+      4, makeUser(), 'sha', [], 'open', 'PR title', 'main', 'w1', { bypass: true },
+    );
+
+    // The merge already landed on origin — a stuck target workspace must not
+    // fail the response.
+    expect(outcome).toEqual({ kind: 'merged', result: mergeResult });
+    expect(pending.enqueueIfAbsent).toHaveBeenCalledTimes(1);
+    expect(pending.enqueueIfAbsent).toHaveBeenCalledWith({
+      workspaceId: 'resolved-target-ws',
+      branch: 'main',
+      path: 'a-first.md',
+      authorEmail: 'alice@example.com',
+      authorName: 'Alice',
+    });
+  });
 });
 
 describe('WorkflowService — file lock delegation', () => {
@@ -368,6 +421,48 @@ describe('WorkflowService — file lock delegation', () => {
     expect(fileLocks.release).toHaveBeenCalledWith('w1', 'feat', 'Foo.md', expect.any(Object));
   });
 
+  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');
+    await expect(svc.deleteBranch('w1', 'feat/x', makeUser())).rejects.toThrow(/open change request \(#7\)/);
+    expect(git.deleteBranch).not.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');
+    await expect(svc.deleteBranch('w1', 'feat/x', makeUser())).resolves.toBeUndefined();
+    expect(git.deleteBranch).toHaveBeenCalledWith('w1', 'feat/x', expect.objectContaining({ email: 'alice@example.com' }), undefined);
+  });
+
+  /**
+   * The lifecycle lock is what keeps merge-time retirement from deleting a
+   * branch mid-`openChangeRequest`. The full interleaving needs a real git
+   * repo + DB; what IS unit-testable is the lock's contract — two operations
+   * keyed on the same branch never overlap, the second fully waiting out the
+   * first.
+   */
+  it('serialises same-branch lifecycle operations', async () => {
+    const order: string[] = [];
+    const git = makeGit();
+    let releaseFirst!: () => void;
+    const gate = new Promise<void>((resolve) => { releaseFirst = resolve; });
+    vi.mocked(git.deleteBranch)
+      .mockImplementationOnce(async () => { order.push('first:start'); await gate; order.push('first:end'); })
+      .mockImplementationOnce(async () => { order.push('second'); });
+    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), 'knowledge-base');
+    const first = svc.deleteBranch('w1', 'feat/x', makeUser());
+    const second = svc.deleteBranch('w1', 'feat/x', makeUser());
+    // Only release the gate once the first operation is provably inside its
+    // critical section — otherwise a non-serialised second could sneak
+    // through before 'first:start' and the assertion would not distinguish.
+    await vi.waitFor(() => { expect(order).toContain('first:start'); });
+    releaseFirst();
+    await Promise.all([first, second]);
+    expect(order).toEqual(['first:start', 'first:end', 'second']);
+  });
+
   it('releaseLock refuses when the caller does not hold the lock', async () => {
     const git = makeGit();
     const fileLocks = makeFileLockService(); // default: get → null
@@ -378,3 +473,198 @@ describe('WorkflowService — file lock delegation', () => {
     expect(git.commitFile).not.toHaveBeenCalled();
   });
 });
+
+/**
+ * The reviewer's per-file scalpel, and the empty-close it can trigger. All
+ * collaborators stubbed — what's under test is the orchestration: the auth
+ * predicate, the restore→commit→push order, the lock discipline, and the
+ * authoritative emptiness re-check before anything closes.
+ */
+describe('WorkflowService — revertChangeRequestFile / closeEmptyChangeRequest', () => {
+  const SUMMARY = { number: 7, base: 'main', branch: 'ali/x', state: 'open' };
+
+  function makeRevertGit(overrides: Record<string, unknown> = {}): GitService {
+    return Object.assign(makeGit(), {
+      pull: vi.fn().mockResolvedValue(undefined),
+      changedPathsForPr: vi.fn().mockResolvedValue(['Docs/a.md', 'Docs/b.md']),
+      mergeBaseForPr: vi.fn().mockResolvedValue('mb-sha'),
+      restorePathFromRef: vi.fn().mockResolvedValue(undefined),
+      commitFile: vi.fn().mockResolvedValue({}),
+      push: vi.fn().mockResolvedValue(undefined),
+      ...overrides,
+    }) as unknown as GitService;
+  }
+
+  function makeHarness(opts: {
+    git?: GitService;
+    canWriteAtRef?: boolean | null;
+    prState?: string;
+    updateRows?: unknown[];
+  } = {}) {
+    const git = opts.git ?? makeRevertGit();
+    const prs = makePrs();
+    (prs.getPr as ReturnType<typeof vi.fn>).mockResolvedValue({
+      ...SUMMARY,
+      state: opts.prState ?? 'open',
+    });
+    const access = makeAccessControl();
+    (access.canWriteAtRef as ReturnType<typeof vi.fn>).mockResolvedValue(
+      opts.canWriteAtRef ?? true,
+    );
+    const fileLocks = makeFileLockService();
+    // The chainable stub answers SELECTs with [] (no open request rows) and
+    // UPDATE...returning with `updateRows` (default: one row = the close won).
+    const updateRows = opts.updateRows ?? [{ id: 1 }];
+    const chain: Record<string, unknown> = {};
+    Object.assign(chain, {
+      select: vi.fn(() => chain),
+      from: vi.fn(() => chain),
+      where: vi.fn(() => chain),
+      limit: vi.fn(async () => []),
+      update: vi.fn(() => chain),
+      set: vi.fn(() => chain),
+      returning: vi.fn(async () => updateRows),
+    });
+    const db = chain as unknown as Database;
+    const svc = new WorkflowService(db, git, prs, makeReviewWorkflow(), makeWorkspaceService(), access, fileLocks, makePendingCommits(), 'knowledge-base');
+    return { svc, git, prs, access, fileLocks, db: chain };
+  }
+
+  it('restores the merge-base copy on the source branch: restore, commit (validator skipped), push — under the file lock', async () => {
+    const { svc, git, prs, fileLocks } = makeHarness();
+    const result = await svc.revertChangeRequestFile(7, makeUser(), 'Docs/a.md');
+
+    expect(git.restorePathFromRef).toHaveBeenCalledWith('ali%2Fx', 'mb-sha', 'Docs/a.md');
+    expect(git.commitFile).toHaveBeenCalledWith(
+      'ali%2Fx',
+      expect.objectContaining({ email: 'alice@example.com' }),
+      'Docs/a.md',
+      expect.stringContaining('change request #7'),
+      true,
+    );
+    expect(git.push).toHaveBeenCalled();
+    expect(fileLocks.acquire).toHaveBeenCalledWith(
+      'ali%2Fx',
+      'ali/x',
+      'knowledge-base/Docs/a.md',
+      expect.anything(),
+    );
+    expect(fileLocks.release).toHaveBeenCalled();
+    expect(prs.invalidateDetailCache).toHaveBeenCalledWith(7);
+    // Both diffs answered two paths → one revert leaves one.
+    expect(result).toEqual({ closed: false, remainingPaths: ['Docs/a.md', 'Docs/b.md'] });
+  });
+
+  it('refuses a caller who could not approve the file — same permission, both verbs', async () => {
+    const { svc, git } = makeHarness({ canWriteAtRef: false });
+    await expect(svc.revertChangeRequestFile(7, makeUser(), 'Docs/a.md')).rejects.toMatchObject({
+      status: 403,
+    });
+    expect(git.restorePathFromRef).not.toHaveBeenCalled();
+    expect(git.push).not.toHaveBeenCalled();
+  });
+
+  it('refuses a path the request does not touch', async () => {
+    const { svc, git } = makeHarness();
+    await expect(svc.revertChangeRequestFile(7, makeUser(), 'Docs/elsewhere.md')).rejects.toMatchObject({
+      status: 422,
+    });
+    expect(git.restorePathFromRef).not.toHaveBeenCalled();
+  });
+
+  it('refuses a request that is no longer open', async () => {
+    const { svc } = makeHarness({ prState: 'closed' });
+    await expect(svc.revertChangeRequestFile(7, makeUser(), 'Docs/a.md')).rejects.toMatchObject({
+      status: 422,
+    });
+  });
+
+  it('closes the request when the LAST file is reverted', async () => {
+    const git = makeRevertGit({
+      changedPathsForPr: vi
+        .fn()
+        // in order: the pre-revert list, the post-revert remainder, and the
+        // close path's own authoritative re-check.
+        .mockResolvedValueOnce(['Docs/a.md'])
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([]),
+    });
+    const { svc, db } = makeHarness({ git });
+    const result = await svc.revertChangeRequestFile(7, makeUser(), 'Docs/a.md');
+    expect(result).toEqual({ closed: true, remainingPaths: [] });
+    expect(db.update).toHaveBeenCalled();
+  });
+
+  it('closeEmptyChangeRequest never closes on a FAILED diff', async () => {
+    const git = makeRevertGit({
+      changedPathsForPr: vi.fn().mockRejectedValue(new Error('git down')),
+    });
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const { svc, db } = makeHarness({ git });
+    await expect(svc.closeEmptyChangeRequest(7, makeUser())).resolves.toBe(false);
+    expect(db.update).not.toHaveBeenCalled();
+    warn.mockRestore();
+  });
+
+  it('closeEmptyChangeRequest leaves a request with real changes alone', async () => {
+    const { svc, db } = makeHarness();
+    await expect(svc.closeEmptyChangeRequest(7, makeUser())).resolves.toBe(false);
+    expect(db.update).not.toHaveBeenCalled();
+  });
+
+  it('closeEmptyChangeRequest closes an emptied request', async () => {
+    const git = makeRevertGit({ changedPathsForPr: vi.fn().mockResolvedValue([]) });
+    const { svc, db, prs } = makeHarness({ git });
+    await expect(svc.closeEmptyChangeRequest(7, makeUser())).resolves.toBe(true);
+    expect(db.update).toHaveBeenCalled();
+    expect(prs.invalidateDetailCache).toHaveBeenCalledWith(7);
+  });
+});
+
+describe('WorkflowService — deleteChangeRequest (admin moderation verb)', () => {
+  function makeDeleteHarness(opts: { isAdmin?: boolean; prState?: string } = {}) {
+    const git = Object.assign(makeGit(), {
+      changedPathsForPr: vi.fn().mockResolvedValue(['Docs/a.md']),
+    }) as unknown as GitService;
+    const prs = makePrs();
+    (prs.getPr as ReturnType<typeof vi.fn>).mockResolvedValue({
+      number: 9,
+      base: 'main',
+      branch: 'mallory/spam',
+      state: opts.prState ?? 'open',
+    });
+    const access = makeAccessControl();
+    (access.canWriteAtRef as ReturnType<typeof vi.fn>).mockResolvedValue(opts.isAdmin ?? false);
+    const chain: Record<string, unknown> = {};
+    Object.assign(chain, {
+      select: vi.fn(() => chain),
+      from: vi.fn(() => chain),
+      where: vi.fn(() => chain),
+      limit: vi.fn(async () => []),
+      update: vi.fn(() => chain),
+      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 };
+  }
+
+  it('refuses a non-admin with 403 and touches nothing', async () => {
+    const { svc, db } = makeDeleteHarness({ isAdmin: false });
+    await expect(svc.deleteChangeRequest(9, makeUser())).rejects.toMatchObject({ status: 403 });
+    expect(db.update).not.toHaveBeenCalled();
+  });
+
+  it('an admin closes the request (row flipped, cache dropped)', async () => {
+    const { svc, prs, db } = makeDeleteHarness({ isAdmin: true });
+    await svc.deleteChangeRequest(9, makeUser());
+    expect(db.update).toHaveBeenCalled();
+    expect(prs.invalidateDetailCache).toHaveBeenCalledWith(9);
+  });
+
+  it('refuses a merged request — applied history is not deletable', async () => {
+    const { svc, db } = makeDeleteHarness({ isAdmin: true, prState: 'merged' });
+    await expect(svc.deleteChangeRequest(9, makeUser())).rejects.toMatchObject({ status: 422 });
+    expect(db.update).not.toHaveBeenCalled();
+  });
+});

package/src/modules/workflow/agent-tools/workflow.tools.ts

@@ -7,7 +7,9 @@ import type { ToolHandlerFactory } from '../../tool-helpers/tool-handler.js';
 import { requireInternalSource } from '../../tool-auth/tool-auth.middleware.js';
 import { workspaceIdForBranch } from '../../workspace/workspace.service.js';
 
-const PROTECTED_INLINE = [...PROTECTED_BRANCHES].map((b) => `\`${b}\``).join(' / ');
+// A function, not a constant: the branch model is applied during boot, and a
+// module-scope capture would freeze this at the empty set that exists before it.
+const protectedInline = () => [...PROTECTED_BRANCHES].map((b) => `\`${b}\``).join(' / ');
 
 // Output sub-schemas for the git-aliased workflow payloads (Branch, Change,
 // ChangeRequestComment, …). Defined once and referenced by the individual tool
@@ -268,7 +270,7 @@ export function registerWorkflowTools(
     name: 'create_branch',
     description:
       'Create a new unprotected draft named `name`, forked from the existing branch `branch`. The ' +
-      `backend rejects protected names (${PROTECTED_INLINE}) and filesystem-invalid names — surface ` +
+      `backend rejects protected names (${protectedInline()}) and filesystem-invalid names — surface ` +
       'those errors verbatim. Convention: `<email-localpart>/<kebab-slug>`. Does NOT switch the ' +
       'agent onto the new draft.',
     // `branch` here is the fork BASE — its own meaning — so skip the generic

package/src/modules/workflow/event-bus.ts

@@ -91,6 +91,21 @@ export class WorkflowEventBus {
   private nextId = 1;
   private readonly buffer: WorkflowEvent[] = [];
   private readonly subscribers = new Map<string, Subscriber>();
+  private readonly emitListeners = new Set<(event: WorkflowEvent) => void>();
+
+  /**
+   * Server-side tap: called for EVERY emitted event, before the per-session
+   * scope filtering (which exists for SSE fan-out, not for in-process
+   * consumers). The composition root uses this for write-time cache
+   * invalidation — the routes emit `fs-tree-changed` the moment bytes hit a
+   * working tree, long before the async commit reaches `FileChangeNotifier`.
+   * Best-effort like SSE dispatch: a throwing listener is logged, never
+   * propagated to the emitter. Returns the unsubscribe.
+   */
+  onEmit(listener: (event: WorkflowEvent) => void): () => void {
+    this.emitListeners.add(listener);
+    return () => this.emitListeners.delete(listener);
+  }
 
   /**
    * Stamp `payload` with `id` + `ts`, append to the ring buffer, then fan
@@ -108,6 +123,16 @@ export class WorkflowEventBus {
     if (this.buffer.length > BUFFER_CAPACITY) {
       this.buffer.shift();
     }
+    for (const listener of this.emitListeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.warn(
+          '[event-bus] onEmit listener threw:',
+          err instanceof Error ? err.message : err,
+        );
+      }
+    }
     // Single-line emit log with all the fields most useful for tracing a
     // failed delivery: which event, which scope it'll filter on, and the
     // total subscriber pool size before fan-out. Per-subscriber matched/

package/src/modules/workflow/file-lock.service.ts

@@ -266,4 +266,21 @@ export class FileLockService {
     }
     return rowToFileLock(row);
   }
+
+  /**
+   * Is ANY unexpired lock held anywhere in this workspace? Feeds the git
+   * status sanity check: a held lock means a mutation is mid-flight — the
+   * file may already be changed (or deleted) on disk while its commit is only
+   * queued at RELEASE — so a dirty tree during that window is expected, not
+   * the "missed lock-release commit" the loud warning is for. Expired rows
+   * don't count (their holder is gone; they explain nothing).
+   */
+  async hasAnyActive(workspaceId: string): Promise<boolean> {
+    const rows = await this.db
+      .select({ path: fileLocks.path })
+      .from(fileLocks)
+      .where(and(eq(fileLocks.workspaceId, workspaceId), gt(fileLocks.expiresAt, new Date())))
+      .limit(1);
+    return rows.length > 0;
+  }
 }