factory-factory 0.4.0 → 0.4.2

package/dist/src/backend/interceptors/branch-naming.interceptor.test.js

@@ -0,0 +1,780 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(() => ({
+    clearAutoGeneratedBranch: vi.fn(),
+    extractMatchingCommands: vi.fn(),
+    findProjectById: vi.fn(),
+    findWorkspaceById: vi.fn(),
+    gitCommand: vi.fn(),
+    gitStateInvalidate: vi.fn(),
+    register: vi.fn(),
+    resetPRDiscoveryBackoff: vi.fn(),
+    setBranchNameAndClearAutoGenerated: vi.fn(),
+}));
+vi.mock('@/backend/services/workspace', () => ({
+    workspaceDataService: {
+        findById: (...args) => mocks.findWorkspaceById(...args),
+        clearAutoGeneratedBranch: (...args) => mocks.clearAutoGeneratedBranch(...args),
+        resetPRDiscoveryBackoff: (...args) => mocks.resetPRDiscoveryBackoff(...args),
+        setBranchNameAndClearAutoGenerated: (...args) => mocks.setBranchNameAndClearAutoGenerated(...args),
+    },
+    projectManagementService: {
+        findById: (...args) => mocks.findProjectById(...args),
+    },
+}));
+vi.mock('@/backend/lib/shell', () => ({
+    gitCommand: (...args) => mocks.gitCommand(...args),
+}));
+vi.mock('@/backend/services/logger.service', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        createLogger: () => ({
+            debug: vi.fn(),
+            info: vi.fn(),
+            warn: vi.fn(),
+            error: vi.fn(),
+        }),
+    };
+});
+vi.mock('@/backend/services/workspace-git-state.service', () => ({
+    workspaceGitStateService: { invalidate: mocks.gitStateInvalidate },
+}));
+vi.mock('./branch-rename.utils', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        extractMatchingCommands: (...args) => {
+            mocks.extractMatchingCommands(...args);
+            return actual.extractMatchingCommands(...args);
+        },
+    };
+});
+vi.mock('./registry', () => ({
+    interceptorRegistry: {
+        register: mocks.register,
+        start: vi.fn(),
+        stop: vi.fn(),
+    },
+}));
+import { branchNamingInterceptor, createBranchNamingInterceptor, } from './branch-naming.interceptor.js';
+import { extractMatchingCommands, generateBranchName } from './branch-rename.utils.js';
+import { registerInterceptors } from './index.js';
+const context = {
+    sessionId: 'session-1',
+    workspaceId: 'workspace-1',
+    workingDir: '/tmp/workspace',
+    timestamp: new Date('2026-07-26T00:00:00.000Z'),
+};
+function createEvent(overrides) {
+    return {
+        toolUseId: 'tool-1',
+        toolName: 'Bash',
+        input: {},
+        ...overrides,
+    };
+}
+describe('branchNamingInterceptor routing', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        branchNamingInterceptor.start?.();
+        mocks.findWorkspaceById.mockResolvedValue({
+            id: 'workspace-1',
+            name: 'Named branch',
+            branchName: 'chosen-name',
+            isAutoGeneratedBranch: false,
+            projectId: 'project-1',
+        });
+        mocks.findProjectById.mockResolvedValue({
+            id: 'project-1',
+            githubOwner: 'owner',
+        });
+        mocks.gitCommand.mockResolvedValue({ code: 0, stdout: '', stderr: '' });
+        mocks.clearAutoGeneratedBranch.mockResolvedValue({});
+        mocks.resetPRDiscoveryBackoff.mockResolvedValue(true);
+        mocks.setBranchNameAndClearAutoGenerated.mockResolvedValue({});
+    });
+    it('subscribes once to all tool events', () => {
+        expect(branchNamingInterceptor.tools).toBe('*');
+    });
+    it('extracts command content once across a tool-call lifecycle', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            input: { command: 'git push origin HEAD' },
+        });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'pushed', isError: false } }, context);
+        expect(mocks.extractMatchingCommands).toHaveBeenCalledOnce();
+    });
+    it('does not rescan unchanged manual rename input on completion', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            input: { command: 'git branch -m chosen-name' },
+        });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({
+            ...event,
+            input: { ...event.input },
+            output: { content: '', isError: false },
+        }, context);
+        expect(mocks.extractMatchingCommands).toHaveBeenCalledOnce();
+    });
+    it('dispatches every matching handler in table order', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        mocks.gitCommand.mockResolvedValue({
+            code: 0,
+            stdout: 'chosen-name\n',
+            stderr: '',
+        });
+        const event = createEvent({
+            toolUseId: 'rename-and-push',
+            input: { command: 'git branch -m chosen-name && git push origin HEAD' },
+        });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'pushed', isError: false } }, context);
+        expect(mocks.setBranchNameAndClearAutoGenerated).toHaveBeenCalledWith('workspace-1', 'chosen-name');
+        expect(mocks.resetPRDiscoveryBackoff).toHaveBeenCalledWith('workspace-1');
+    });
+    it('registers one unified branch-naming interceptor', () => {
+        registerInterceptors();
+        const registeredNames = mocks.register.mock.calls.map(([interceptor]) => interceptor.name);
+        expect(registeredNames.filter((name) => name === 'branch-naming')).toHaveLength(1);
+        expect(registeredNames).not.toContain('branch-rename');
+        expect(registeredNames).not.toContain('pre-push-rename');
+        expect(registeredNames).not.toContain('pre-pr-rename');
+    });
+});
+describe('extractMatchingCommands', () => {
+    it.each([
+        ['global', /git push/g],
+        ['sticky', /git push/y],
+    ])('matches every candidate with a %s regex', (_name, commandRegex) => {
+        const event = createEvent({
+            toolName: 'git push tool',
+            input: {
+                command: 'git push command',
+                cmd: 'git push cmd',
+                title: 'git push title',
+            },
+        });
+        expect(extractMatchingCommands(event, commandRegex)).toEqual([
+            'git push command',
+            'git push cmd',
+            'git push title',
+            'git push tool',
+        ]);
+        expect(commandRegex.lastIndex).toBe(0);
+    });
+});
+describe('manual branch rename handling', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mocks.gitCommand.mockResolvedValue({ code: 0, stdout: 'new-branch\n', stderr: '' });
+        mocks.setBranchNameAndClearAutoGenerated.mockResolvedValue({});
+    });
+    it('updates branch metadata after a successful git branch -m', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({ input: { command: 'git branch -m better-name' } });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: '', isError: false } }, context);
+        expect(mocks.gitCommand).toHaveBeenCalledWith(['rev-parse', '--abbrev-ref', 'HEAD'], '/tmp/workspace');
+        expect(mocks.setBranchNameAndClearAutoGenerated).toHaveBeenCalledWith('workspace-1', 'new-branch');
+        expect(mocks.gitStateInvalidate).toHaveBeenCalledWith('/tmp/workspace');
+    });
+    it('handles a manual rename completion when no start state was recorded', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            input: { command: 'git branch -m completion-only' },
+            output: { content: '', isError: false },
+        });
+        await interceptor.onToolComplete(event, context);
+        expect(mocks.gitCommand).toHaveBeenCalledWith(['rev-parse', '--abbrev-ref', 'HEAD'], '/tmp/workspace');
+        expect(mocks.setBranchNameAndClearAutoGenerated).toHaveBeenCalledWith('workspace-1', 'new-branch');
+        expect(mocks.gitStateInvalidate).toHaveBeenCalledWith('/tmp/workspace');
+    });
+    it('uses the completed tool input when a rename command arrives after start', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const startEvent = createEvent({
+            input: { title: 'Preparing git branch -m command' },
+        });
+        await interceptor.onToolStart(startEvent, context);
+        await interceptor.onToolComplete({
+            ...startEvent,
+            input: {
+                ...startEvent.input,
+                command: 'git branch -m completion-branch',
+            },
+            output: { content: '', isError: false },
+        }, context);
+        expect(mocks.gitCommand).toHaveBeenCalledWith(['rev-parse', '--abbrev-ref', 'HEAD'], '/tmp/workspace');
+        expect(mocks.setBranchNameAndClearAutoGenerated).toHaveBeenCalledWith('workspace-1', 'new-branch');
+        expect(mocks.gitStateInvalidate).toHaveBeenCalledWith('/tmp/workspace');
+    });
+    it('invalidates Git state but does not persist after a failed shell command', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({ toolName: 'git branch -m renamed && false' });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'failed', isError: true } }, context);
+        expect(mocks.gitStateInvalidate).toHaveBeenCalledWith('/tmp/workspace');
+        expect(mocks.gitCommand).not.toHaveBeenCalled();
+        expect(mocks.setBranchNameAndClearAutoGenerated).not.toHaveBeenCalled();
+    });
+    it.each([
+        'git branch -m codex-name',
+        'git status && git branch -m chained-name',
+        'false || git branch -m chained-name',
+        'git status; git branch -m chained-name',
+        'git status\ngit branch -m chained-name',
+        '   git branch -m nested-name',
+        '(git branch -m nested-name)',
+        'echo status && ( git branch -M nested-name )',
+        "bash -c 'git branch -m shell-name'",
+        'sh -c "git branch -M shell-name"',
+        "git status && bash -c 'git branch -m shell-name'",
+    ])('detects an executable rename in a Codex tool title: %s', async (toolName) => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({ toolName });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: '', isError: false } }, context);
+        expect(mocks.gitCommand).toHaveBeenCalledWith(['rev-parse', '--abbrev-ref', 'HEAD'], '/tmp/workspace');
+        expect(mocks.setBranchNameAndClearAutoGenerated).toHaveBeenCalledWith('workspace-1', 'new-branch');
+    });
+    it.each([
+        'echo git branch -m codex-name',
+        'echo "literal && git branch -m not-a-rename"',
+        'rg -n "git branch -m" .',
+        "rg -n '; git branch -m' .",
+        'Search git branch -m',
+        'echo \\; git branch -m escaped-name',
+        '#; git branch -m commented-name',
+        'git status # && git branch -m commented-name',
+        'echo "bash -c \'git branch -m quoted-name\'"',
+        'bash -c "echo \\"literal; git branch -m quoted-name\\""',
+    ])('ignores rename text that is not executed: %s', async (toolName) => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({ toolName });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: '', isError: false } }, context);
+        expect(mocks.gitCommand).not.toHaveBeenCalled();
+        expect(mocks.setBranchNameAndClearAutoGenerated).not.toHaveBeenCalled();
+    });
+    it('detects a rename after a shell comment ends', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolName: '# ignored git branch -m commented-name\n git branch -m after-comment',
+        });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: '', isError: false } }, context);
+        expect(mocks.setBranchNameAndClearAutoGenerated).toHaveBeenCalledWith('workspace-1', 'new-branch');
+    });
+    it('does not persist when branch lookup fails or returns an empty name', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const first = createEvent({
+            toolUseId: 'lookup-failed',
+            input: { command: 'git branch -M force-name' },
+        });
+        const second = createEvent({
+            toolUseId: 'lookup-empty',
+            input: { command: 'git branch -M force-name' },
+        });
+        mocks.gitCommand
+            .mockResolvedValueOnce({ code: 1, stdout: '', stderr: 'failed' })
+            .mockResolvedValueOnce({ code: 0, stdout: '   \n', stderr: '' });
+        await interceptor.onToolStart(first, context);
+        await interceptor.onToolComplete({ ...first, output: { content: '', isError: false } }, context);
+        await interceptor.onToolStart(second, context);
+        await interceptor.onToolComplete({ ...second, output: { content: '', isError: false } }, context);
+        expect(mocks.setBranchNameAndClearAutoGenerated).not.toHaveBeenCalled();
+        expect(mocks.gitStateInvalidate).toHaveBeenCalledTimes(2);
+    });
+});
+describe('automatic branch rename handling', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        branchNamingInterceptor.start?.();
+        mocks.findWorkspaceById.mockResolvedValue({
+            id: 'workspace-1',
+            name: 'Fix authentication bug',
+            branchName: 'owner/automatic-1',
+            isAutoGeneratedBranch: true,
+            projectId: 'project-1',
+        });
+        mocks.findProjectById.mockResolvedValue({
+            id: 'project-1',
+            githubOwner: 'owner',
+        });
+        mocks.gitCommand.mockResolvedValue({ code: 0, stdout: '', stderr: '' });
+        mocks.clearAutoGeneratedBranch.mockResolvedValue({});
+        mocks.resetPRDiscoveryBackoff.mockResolvedValue(true);
+        mocks.setBranchNameAndClearAutoGenerated.mockResolvedValue({});
+    });
+    it.each([
+        ['git push -u origin HEAD', 'push-workspace'],
+        ['gh pr create --title "Fix auth"', 'pr-workspace'],
+    ])('renames an auto-generated branch before %s', async (command, workspaceId) => {
+        const event = createEvent({ input: { command } });
+        await branchNamingInterceptor.onToolStart(event, {
+            ...context,
+            workspaceId,
+        });
+        expect(mocks.gitCommand).toHaveBeenCalledWith(['branch', '-m', 'owner/fix-authentication-bug'], '/tmp/workspace');
+        expect(mocks.setBranchNameAndClearAutoGenerated).toHaveBeenCalledWith(workspaceId, 'owner/fix-authentication-bug');
+        expect(mocks.gitStateInvalidate).toHaveBeenCalledWith('/tmp/workspace');
+    });
+    it('only clears the generated flag when the selected name already matches', async () => {
+        mocks.findWorkspaceById.mockResolvedValue({
+            id: 'workspace-1',
+            name: 'Fix authentication bug',
+            branchName: 'owner/fix-authentication-bug',
+            isAutoGeneratedBranch: true,
+            projectId: 'project-1',
+        });
+        const event = createEvent({ input: { command: 'git push origin HEAD' } });
+        await branchNamingInterceptor.onToolStart(event, {
+            ...context,
+            workspaceId: 'matching-name',
+        });
+        expect(mocks.gitCommand).not.toHaveBeenCalled();
+        expect(mocks.clearAutoGeneratedBranch).toHaveBeenCalledWith('matching-name');
+        expect(mocks.setBranchNameAndClearAutoGenerated).not.toHaveBeenCalled();
+        expect(mocks.gitStateInvalidate).not.toHaveBeenCalled();
+    });
+    it('skips missing and non-generated workspaces', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const missingEvent = createEvent({
+            toolUseId: 'missing',
+            input: { command: 'gh pr create --fill' },
+        });
+        const namedEvent = createEvent({
+            toolUseId: 'named',
+            input: { command: 'git push origin HEAD' },
+        });
+        mocks.findWorkspaceById.mockResolvedValueOnce(null).mockResolvedValueOnce({
+            id: 'workspace-1',
+            name: 'Named',
+            branchName: 'owner/named',
+            isAutoGeneratedBranch: false,
+            projectId: 'project-1',
+        });
+        await interceptor.onToolStart(missingEvent, context);
+        await interceptor.onToolStart(namedEvent, {
+            ...context,
+            workspaceId: 'workspace-2',
+        });
+        expect(mocks.gitCommand).not.toHaveBeenCalled();
+        expect(mocks.setBranchNameAndClearAutoGenerated).not.toHaveBeenCalled();
+    });
+    it('does not inspect workspace state for unrelated commands', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        await interceptor.onToolStart(createEvent({ input: { command: 'git status && gh pr list' } }), context);
+        expect(mocks.findWorkspaceById).not.toHaveBeenCalled();
+        expect(mocks.gitCommand).not.toHaveBeenCalled();
+    });
+    it('releases the rename claim after a Git rename failure', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        mocks.gitCommand
+            .mockResolvedValueOnce({ code: 1, stdout: '', stderr: 'branch exists' })
+            .mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+        const first = createEvent({
+            toolUseId: 'failed-rename',
+            input: { command: 'git push origin HEAD' },
+        });
+        const retry = createEvent({
+            toolUseId: 'retry-rename',
+            input: { command: 'git push origin HEAD' },
+        });
+        await interceptor.onToolStart(first, context);
+        await interceptor.onToolStart(retry, context);
+        expect(mocks.gitCommand).toHaveBeenCalledTimes(2);
+        expect(mocks.setBranchNameAndClearAutoGenerated).toHaveBeenCalledOnce();
+        expect(mocks.gitStateInvalidate).toHaveBeenCalledTimes(2);
+    });
+    it.each([
+        ['git push -u origin HEAD', 'push-cmd'],
+        ['gh pr create --fill', 'pr-cmd'],
+    ])('detects %s in the cmd field', async (cmd, workspaceId) => {
+        const interceptor = createBranchNamingInterceptor();
+        await interceptor.onToolStart(createEvent({ toolName: 'exec_command', input: { cmd } }), {
+            ...context,
+            workspaceId,
+        });
+        expect(mocks.gitCommand).toHaveBeenCalled();
+    });
+    it('generates a branch without a prefix when the project has no owner', async () => {
+        mocks.findProjectById.mockResolvedValue({ id: 'project-1', githubOwner: null });
+        const interceptor = createBranchNamingInterceptor();
+        await interceptor.onToolStart(createEvent({ input: { command: 'gh pr create --fill' } }), context);
+        expect(mocks.gitCommand).toHaveBeenCalledWith(['branch', '-m', 'fix-authentication-bug'], '/tmp/workspace');
+    });
+    it('renames once when two triggers race for one workspace', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        let releaseFirstLookup;
+        const firstLookupStarted = new Promise((resolveStarted) => {
+            mocks.findWorkspaceById.mockImplementationOnce(() => {
+                resolveStarted();
+                return new Promise((resolveLookup) => {
+                    releaseFirstLookup = () => resolveLookup({
+                        id: 'race-workspace',
+                        projectId: 'project-1',
+                        name: 'Race Workspace',
+                        branchName: 'auto-branch',
+                        isAutoGeneratedBranch: true,
+                    });
+                });
+            });
+        });
+        const first = interceptor.onToolStart(createEvent({ toolUseId: 'race-a', input: { command: 'git push' } }), { ...context, workspaceId: 'race-workspace' });
+        await firstLookupStarted;
+        const second = interceptor.onToolStart(createEvent({ toolUseId: 'race-b', input: { command: 'gh pr create --fill' } }), { ...context, workspaceId: 'race-workspace' });
+        releaseFirstLookup?.();
+        await Promise.all([first, second]);
+        expect(mocks.gitCommand).toHaveBeenCalledTimes(1);
+        expect(mocks.setBranchNameAndClearAutoGenerated).toHaveBeenCalledTimes(1);
+    });
+    it('keeps rename claims isolated between factory instances', async () => {
+        const first = createBranchNamingInterceptor();
+        const second = createBranchNamingInterceptor();
+        const event = createEvent({ input: { command: 'git push origin HEAD' } });
+        await first.onToolStart(event, context);
+        await second.onToolStart(event, context);
+        expect(mocks.gitCommand).toHaveBeenCalledTimes(2);
+    });
+});
+describe('push completion handling', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mocks.findWorkspaceById.mockResolvedValue({
+            id: 'workspace-1',
+            name: 'Named',
+            branchName: 'owner/named',
+            isAutoGeneratedBranch: false,
+            projectId: 'project-1',
+        });
+        mocks.resetPRDiscoveryBackoff.mockResolvedValue(true);
+    });
+    it('resets PR discovery after a successful push', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolUseId: 'successful-push',
+            input: { command: 'git push origin HEAD' },
+        });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'pushed', isError: false } }, context);
+        expect(mocks.resetPRDiscoveryBackoff).toHaveBeenCalledWith('workspace-1');
+    });
+    it('does not reset PR discovery after a failed push', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolUseId: 'failed-push',
+            input: { command: 'git push origin HEAD' },
+        });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'failed', isError: true } }, context);
+        expect(mocks.resetPRDiscoveryBackoff).not.toHaveBeenCalled();
+    });
+    it('swallows PR discovery reset failures', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolUseId: 'reset-failed',
+            input: { command: 'git push origin HEAD' },
+        });
+        mocks.resetPRDiscoveryBackoff.mockRejectedValue(new Error('database unavailable'));
+        await interceptor.onToolStart(event, context);
+        await expect(interceptor.onToolComplete({ ...event, output: { content: 'pushed', isError: false } }, context)).resolves.toBeUndefined();
+    });
+    it('tracks matching tool IDs independently across sessions', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolUseId: 'shared-tool-id',
+            input: { command: 'git push origin HEAD' },
+        });
+        const firstContext = { ...context, sessionId: 'session-1', workspaceId: 'workspace-1' };
+        const secondContext = { ...context, sessionId: 'session-2', workspaceId: 'workspace-2' };
+        await interceptor.onToolStart(event, firstContext);
+        await interceptor.onToolStart(event, secondContext);
+        await interceptor.onToolComplete({ ...event, output: { content: 'pushed', isError: false } }, firstContext);
+        await interceptor.onToolComplete({ ...event, output: { content: 'pushed', isError: false } }, secondContext);
+        expect(mocks.resetPRDiscoveryBackoff).toHaveBeenNthCalledWith(1, 'workspace-1');
+        expect(mocks.resetPRDiscoveryBackoff).toHaveBeenNthCalledWith(2, 'workspace-2');
+    });
+    it('consumes completion state once and clears it on stop', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolUseId: 'consumed-push',
+            input: { command: 'git push origin HEAD' },
+        });
+        const completion = { ...event, output: { content: 'pushed', isError: false } };
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete(completion, context);
+        await interceptor.onToolComplete(completion, context);
+        await interceptor.onToolStart({ ...event, toolUseId: 'stopped-push' }, context);
+        interceptor.stop();
+        await interceptor.onToolComplete({ ...completion, toolUseId: 'stopped-push' }, context);
+        expect(mocks.resetPRDiscoveryBackoff).toHaveBeenCalledOnce();
+    });
+    it('replaces pending state when a tool-use ID is reused in one session', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const push = createEvent({
+            toolUseId: 'reused-id',
+            input: { command: 'git push origin HEAD' },
+        });
+        const prCreate = createEvent({
+            toolUseId: 'reused-id',
+            input: { command: 'gh pr create --fill' },
+        });
+        await interceptor.onToolStart(push, context);
+        await interceptor.onToolStart(prCreate, context);
+        await interceptor.onToolComplete({ ...prCreate, output: { content: 'created', isError: false } }, context);
+        expect(mocks.resetPRDiscoveryBackoff).not.toHaveBeenCalled();
+    });
+    it('evicts the oldest pending tool call when state reaches its bound', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const events = Array.from({ length: 1001 }, (_, index) => createEvent({
+            toolUseId: `bounded-${index}`,
+            input: { command: 'git push origin HEAD' },
+        }));
+        await Promise.all(events.map((event) => interceptor.onToolStart(event, context)));
+        await interceptor.onToolComplete({ ...events[0], output: { content: 'pushed', isError: false } }, context);
+        await interceptor.onToolComplete({ ...events[1000], output: { content: 'pushed', isError: false } }, context);
+        expect(mocks.resetPRDiscoveryBackoff).toHaveBeenCalledOnce();
+    });
+    it('continues other completion handlers after one handler throws', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            input: { command: 'git branch -m chosen-name && git push origin HEAD' },
+        });
+        mocks.gitCommand.mockResolvedValue({
+            code: 0,
+            stdout: 'chosen-name\n',
+            stderr: '',
+        });
+        mocks.setBranchNameAndClearAutoGenerated.mockRejectedValue(new Error('database unavailable'));
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'pushed', isError: false } }, context);
+        expect(mocks.resetPRDiscoveryBackoff).toHaveBeenCalledWith('workspace-1');
+    });
+});
+describe('PR completion handling', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mocks.gitCommand.mockReset();
+        mocks.findWorkspaceById.mockResolvedValue({
+            id: 'workspace-1',
+            name: 'Fix authentication bug',
+            branchName: 'owner/automatic-1',
+            isAutoGeneratedBranch: true,
+            projectId: 'project-1',
+        });
+        mocks.findProjectById.mockResolvedValue({
+            id: 'project-1',
+            githubOwner: 'owner',
+        });
+        mocks.gitCommand.mockResolvedValue({ code: 0, stdout: '', stderr: '' });
+        mocks.setBranchNameAndClearAutoGenerated.mockResolvedValue({});
+    });
+    it.each([
+        {
+            name: 'in one shell command',
+            input: { command: 'git push origin HEAD && gh pr create --fill' },
+        },
+        {
+            name: 'in separate supported input fields',
+            input: { command: 'git push origin HEAD', title: 'gh pr create --fill' },
+        },
+    ])('retains the PR cleanup candidate when push and PR triggers appear $name', async ({ input, }) => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolUseId: 'combined-push-pr',
+            input,
+        });
+        mocks.gitCommand
+            .mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({
+            code: 0,
+            stdout: 'origin/owner/fix-authentication-bug\n',
+            stderr: '',
+        })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'created', isError: false } }, context);
+        expect(mocks.gitCommand).toHaveBeenCalledWith(['push', 'origin', '--delete', 'owner/automatic-1'], '/tmp/workspace');
+    });
+    it('deletes the old remote branch after successful PR creation when refs match', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolUseId: 'pr-cleanup',
+            input: { command: 'gh pr create --fill' },
+        });
+        mocks.gitCommand
+            .mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({
+            code: 0,
+            stdout: 'origin/owner/fix-authentication-bug\n',
+            stderr: '',
+        })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'created', isError: false } }, context);
+        expect(mocks.gitCommand).toHaveBeenCalledWith(['push', 'origin', '--delete', 'owner/automatic-1'], '/tmp/workspace');
+        expect(mocks.gitStateInvalidate).toHaveBeenCalledTimes(2);
+    });
+    it('normalizes remote-prefixed old branch names during cleanup', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        mocks.findWorkspaceById.mockResolvedValue({
+            id: 'workspace-1',
+            name: 'Fix authentication bug',
+            branchName: 'refs/remotes/origin/owner/automatic-1',
+            isAutoGeneratedBranch: true,
+            projectId: 'project-1',
+        });
+        const event = createEvent({
+            toolUseId: 'prefixed-cleanup',
+            input: { command: 'gh pr create --fill' },
+        });
+        mocks.gitCommand
+            .mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({
+            code: 0,
+            stdout: 'origin/owner/fix-authentication-bug\n',
+            stderr: '',
+        })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'created', isError: false } }, context);
+        expect(mocks.gitCommand).toHaveBeenNthCalledWith(4, ['rev-parse', '--verify', '--quiet', 'refs/remotes/origin/owner/automatic-1'], '/tmp/workspace');
+        expect(mocks.gitCommand).toHaveBeenNthCalledWith(6, ['push', 'origin', '--delete', 'owner/automatic-1'], '/tmp/workspace');
+    });
+    it.each([
+        {
+            reason: 'HEAD cannot be resolved',
+            cleanupResults: [{ code: 1, stdout: '', stderr: 'missing HEAD' }],
+        },
+        {
+            reason: 'HEAD resolves to an empty commit',
+            cleanupResults: [{ code: 0, stdout: ' \n', stderr: '' }],
+        },
+        {
+            reason: 'the upstream cannot be resolved',
+            cleanupResults: [
+                { code: 0, stdout: 'abc123\n', stderr: '' },
+                { code: 1, stdout: '', stderr: 'no upstream' },
+            ],
+        },
+        {
+            reason: 'the upstream does not identify a remote',
+            cleanupResults: [
+                { code: 0, stdout: 'abc123\n', stderr: '' },
+                { code: 0, stdout: 'origin\n', stderr: '' },
+            ],
+        },
+        {
+            reason: 'a remote ref is missing',
+            cleanupResults: [
+                { code: 0, stdout: 'abc123\n', stderr: '' },
+                { code: 0, stdout: 'origin/owner/fix-authentication-bug\n', stderr: '' },
+                { code: 1, stdout: '', stderr: 'missing old ref' },
+                { code: 0, stdout: 'abc123\n', stderr: '' },
+            ],
+        },
+        {
+            reason: 'a remote ref has diverged from HEAD',
+            cleanupResults: [
+                { code: 0, stdout: 'abc123\n', stderr: '' },
+                { code: 0, stdout: 'origin/owner/fix-authentication-bug\n', stderr: '' },
+                { code: 0, stdout: 'abc123\n', stderr: '' },
+                { code: 0, stdout: 'different\n', stderr: '' },
+            ],
+        },
+    ])('skips remote deletion when $reason', async ({ cleanupResults }) => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolUseId: 'unsafe-cleanup',
+            input: { command: 'gh pr create --fill' },
+        });
+        mocks.gitCommand.mockReset();
+        mocks.gitCommand.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+        for (const result of cleanupResults) {
+            mocks.gitCommand.mockResolvedValueOnce(result);
+        }
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'created', isError: false } }, context);
+        const attemptedDelete = mocks.gitCommand.mock.calls.some(([args]) => Array.isArray(args) && args[0] === 'push');
+        expect(attemptedDelete).toBe(false);
+    });
+    it('keeps the new branch when deleting the old remote branch fails', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolUseId: 'delete-failed',
+            input: { command: 'gh pr create --fill' },
+        });
+        mocks.gitCommand
+            .mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({
+            code: 0,
+            stdout: 'origin/owner/fix-authentication-bug\n',
+            stderr: '',
+        })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({ code: 0, stdout: 'abc123\n', stderr: '' })
+            .mockResolvedValueOnce({ code: 1, stdout: '', stderr: 'protected branch' });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'created', isError: false } }, context);
+        expect(mocks.gitStateInvalidate).toHaveBeenCalledTimes(2);
+        expect(mocks.setBranchNameAndClearAutoGenerated).toHaveBeenCalledWith('workspace-1', 'owner/fix-authentication-bug');
+    });
+    it('does not clean up after failed PR creation', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolUseId: 'failed-pr',
+            input: { command: 'gh pr create --fill' },
+        });
+        mocks.gitCommand.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+        await interceptor.onToolStart(event, context);
+        await interceptor.onToolComplete({ ...event, output: { content: 'failed', isError: true } }, context);
+        expect(mocks.gitCommand).toHaveBeenCalledTimes(1);
+    });
+    it('swallows remote cleanup exceptions', async () => {
+        const interceptor = createBranchNamingInterceptor();
+        const event = createEvent({
+            toolUseId: 'cleanup-error',
+            input: { command: 'gh pr create --fill' },
+        });
+        mocks.gitCommand.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+        await interceptor.onToolStart(event, context);
+        mocks.gitCommand.mockRejectedValueOnce(new Error('spawn ENOENT'));
+        await expect(interceptor.onToolComplete({ ...event, output: { content: 'created', isError: false } }, context)).resolves.toBeUndefined();
+    });
+});
+describe('generateBranchName', () => {
+    it.each([
+        [
+            { branchPrefix: 'owner', workspaceName: 'Fix Authentication Bug' },
+            'owner/fix-authentication-bug',
+        ],
+        [{ branchPrefix: '', workspaceName: 'Add user login' }, 'add-user-login'],
+        [
+            { branchPrefix: 'user', workspaceName: 'Fix: the @#$ weird (bug) [123]' },
+            'user/fix-the-weird-bug-123',
+        ],
+        [{ branchPrefix: 'user', workspaceName: '' }, ''],
+        [{ branchPrefix: '', workspaceName: '---hello world---' }, 'hello-world'],
+    ])('normalizes $workspaceName to $expected', (input, expected) => {
+        expect(generateBranchName(input)).toBe(expected);
+    });
+    it('limits the generated slug to 30 characters', () => {
+        expect(generateBranchName({
+            branchPrefix: '',
+            workspaceName: 'This is a very long workspace name that should be truncated',
+        })).toHaveLength(30);
+    });
+});
+//# sourceMappingURL=branch-naming.interceptor.test.js.map