factory-factory 0.4.6 → 0.4.8

package/dist/src/backend/services/session/service/acp/acp-runtime-supervisor.status.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp-runtime-supervisor.status.test.d.ts","sourceRoot":"","sources":["../../../../../../../src/backend/services/session/service/acp/acp-runtime-supervisor.status.test.ts"],"names":[],"mappings":""}

package/dist/src/backend/services/session/service/acp/acp-runtime-supervisor.status.test.js

@@ -0,0 +1,99 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createTestProcessHandle, defaultContext, defaultHandlers, defaultOptions, } from './acp-runtime-manager.test-helpers.js';
+import { AcpRuntimeSupervisor } from './acp-runtime-supervisor.js';
+function mockChildOf(handle) {
+    return handle.child;
+}
+function createHarness() {
+    const createClient = vi.fn(() => Promise.resolve(createTestProcessHandle()));
+    const supervisor = new AcpRuntimeSupervisor({
+        clientFactory: { createClient },
+        cancelPrompt: () => Promise.resolve(false),
+    });
+    return { supervisor, createClient };
+}
+describe('AcpRuntimeSupervisor status queries', () => {
+    it('reports installed runtime identity, liveness, work, and process snapshots', async () => {
+        const active = createTestProcessHandle({ provider: 'CLAUDE' });
+        const browse = createTestProcessHandle({ provider: 'CODEX' });
+        mockChildOf(browse).pid = 54_321;
+        const { supervisor, createClient } = createHarness();
+        createClient.mockResolvedValueOnce(active).mockResolvedValueOnce(browse);
+        await supervisor.getOrCreateClient('active-session', defaultOptions(), defaultHandlers(), defaultContext());
+        await supervisor.getOrCreateClient('browse-session', { ...defaultOptions(), purpose: 'browse' }, defaultHandlers(), defaultContext());
+        active.isPromptInFlight = true;
+        browse.isPromptInFlight = true;
+        expect(supervisor.isCurrentHandle('active-session', active)).toBe(true);
+        expect(supervisor.isCurrentHandle('active-session', browse)).toBe(false);
+        expect(supervisor.isSessionRunning('active-session')).toBe(true);
+        expect(supervisor.isSessionRunning('browse-session')).toBe(false);
+        expect(supervisor.isSessionWorking('browse-session')).toBe(false);
+        expect(supervisor.isAnySessionWorking(['missing', 'browse-session'])).toBe(false);
+        expect([...supervisor.getAllClients()]).toEqual([
+            ['active-session', active],
+            ['browse-session', browse],
+        ]);
+        expect(supervisor.getAllActiveProcesses()).toEqual([
+            {
+                sessionId: 'active-session',
+                pid: 12_345,
+                status: 'running',
+                isRunning: true,
+                isPromptInFlight: true,
+                provider: 'CLAUDE',
+            },
+            {
+                sessionId: 'browse-session',
+                pid: 54_321,
+                status: 'running',
+                isRunning: true,
+                isPromptInFlight: true,
+                provider: 'CODEX',
+            },
+        ]);
+        mockChildOf(browse).killed = true;
+        expect(supervisor.getBrowseClient('browse-session')).toBeUndefined();
+        expect(supervisor.getInstalledHandle('browse-session')).toBe(browse);
+        expect(supervisor.getAllActiveProcesses()[1]).toMatchObject({
+            status: 'stopped',
+            isRunning: false,
+        });
+    });
+    it('tracks task activity between prompts until the current runtime reports idle', async () => {
+        const handle = createTestProcessHandle();
+        const { supervisor, createClient } = createHarness();
+        createClient.mockImplementationOnce((params) => {
+            params.handlers.onAcpEvent?.('session-1', {
+                type: 'acp_task_status_changed',
+                active: true,
+            });
+            return Promise.resolve(handle);
+        });
+        await supervisor.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+        expect(supervisor.isSessionWorking('session-1')).toBe(true);
+        const runtimeHandlers = createClient.mock.calls[0]?.[0].handlers;
+        runtimeHandlers?.onAcpEvent?.('session-1', {
+            type: 'acp_task_status_changed',
+            active: false,
+        });
+        expect(supervisor.isSessionWorking('session-1')).toBe(false);
+    });
+    it('keeps browse task activity hidden until the runtime is promoted', async () => {
+        const handle = createTestProcessHandle();
+        const { supervisor, createClient } = createHarness();
+        createClient.mockImplementationOnce((params) => {
+            params.handlers.onAcpEvent?.('session-1', {
+                type: 'acp_task_status_changed',
+                active: true,
+            });
+            return Promise.resolve(handle);
+        });
+        await supervisor.getOrCreateClient('session-1', { ...defaultOptions(), purpose: 'browse' }, defaultHandlers(), defaultContext());
+        handle.isPromptInFlight = true;
+        expect(supervisor.isSessionWorking('session-1')).toBe(false);
+        await supervisor.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+        handle.isPromptInFlight = false;
+        expect(supervisor.isSessionWorking('session-1')).toBe(true);
+    });
+});
+//# sourceMappingURL=acp-runtime-supervisor.status.test.js.map

package/dist/src/backend/services/session/service/acp/acp-runtime-supervisor.status.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp-runtime-supervisor.status.test.js","sourceRoot":"","sources":["../../../../../../../src/backend/services/session/service/acp/acp-runtime-supervisor.status.test.ts"],"names":[],"mappings":"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"}

package/dist/src/backend/services/session/service/acp/acp-runtime-supervisor.termination.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=acp-runtime-supervisor.termination.test.d.ts.map

package/dist/src/backend/services/session/service/acp/acp-runtime-supervisor.termination.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp-runtime-supervisor.termination.test.d.ts","sourceRoot":"","sources":["../../../../../../../src/backend/services/session/service/acp/acp-runtime-supervisor.termination.test.ts"],"names":[],"mappings":""}

package/dist/src/backend/services/session/service/acp/acp-runtime-supervisor.termination.test.js

@@ -0,0 +1,517 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createDeferred, createTestProcessHandle, defaultContext, defaultHandlers, defaultOptions, exitChildAfterSigterm, exitChildWithCode, markChildKilledOnSignal, } from './acp-runtime-manager.test-helpers.js';
+import { AcpRuntimeSupervisor } from './acp-runtime-supervisor.js';
+const loggerMocks = vi.hoisted(() => {
+    const manager = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    };
+    const other = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    };
+    return {
+        manager,
+        other,
+        createLogger: vi.fn((category) => category === 'acp-runtime-manager' ? manager : other),
+    };
+});
+vi.mock('@/backend/services/logger.service', () => ({
+    createLogger: loggerMocks.createLogger,
+    getCurrentProcessEnv: () => ({}),
+}));
+function mockChildOf(handle) {
+    return handle.child;
+}
+function createHarness(implementation) {
+    const createClient = vi.fn(implementation ?? (() => Promise.resolve(createTestProcessHandle())));
+    const cancelPrompt = vi.fn(() => Promise.resolve(false));
+    const supervisor = new AcpRuntimeSupervisor({
+        clientFactory: { createClient },
+        cancelPrompt,
+    });
+    return { supervisor, createClient, cancelPrompt };
+}
+async function install(supervisor, sessionId = 'session-1') {
+    return await supervisor.getOrCreateClient(sessionId, { ...defaultOptions(), sessionId }, defaultHandlers(), defaultContext());
+}
+describe('AcpRuntimeSupervisor termination and shutdown ownership', () => {
+    beforeEach(() => {
+        vi.useRealTimers();
+        loggerMocks.manager.debug.mockClear();
+        loggerMocks.manager.info.mockClear();
+        loggerMocks.manager.warn.mockClear();
+        loggerMocks.manager.error.mockClear();
+        loggerMocks.other.debug.mockClear();
+        loggerMocks.other.info.mockClear();
+        loggerMocks.other.warn.mockClear();
+        loggerMocks.other.error.mockClear();
+    });
+    it('logs a deduplicated stop under the manager category', async () => {
+        const handle = createTestProcessHandle();
+        markChildKilledOnSignal(mockChildOf(handle));
+        const { supervisor } = createHarness(() => Promise.resolve(handle));
+        await install(supervisor);
+        const firstStop = supervisor.stopClient('session-1');
+        await vi.waitFor(() => expect(handle.child.kill).toHaveBeenCalledWith('SIGTERM'));
+        const duplicateStop = supervisor.stopClient('session-1');
+        expect(duplicateStop).toBe(firstStop);
+        expect(loggerMocks.manager.debug).toHaveBeenCalledWith('ACP session stop already in progress', {
+            sessionId: 'session-1',
+        });
+        mockChildOf(handle).exitCode = 0;
+        handle.child.emit('exit', 0, null);
+        await firstStop;
+    });
+    it('returns the identical stop promise and admits a replacement after cleanup', async () => {
+        const first = createTestProcessHandle();
+        const replacement = createTestProcessHandle();
+        exitChildWithCode(mockChildOf(first));
+        const { supervisor, createClient } = createHarness();
+        createClient.mockResolvedValueOnce(first).mockResolvedValueOnce(replacement);
+        const onRuntimeExit = vi.fn(() => Promise.resolve());
+        await supervisor.getOrCreateClient('session-1', defaultOptions(), { ...defaultHandlers(), onRuntimeExit }, defaultContext());
+        const firstStop = supervisor.stopClient('session-1');
+        const duplicateStop = supervisor.stopClient('session-1');
+        expect(duplicateStop).toBe(firstStop);
+        await firstStop;
+        await expect(install(supervisor)).resolves.toBe(replacement);
+        expect(first.child.kill).toHaveBeenCalledTimes(1);
+        expect(first.child.kill).toHaveBeenCalledWith('SIGTERM');
+        expect(createClient).toHaveBeenCalledTimes(2);
+        await vi.waitFor(() => expect(onRuntimeExit).toHaveBeenCalledOnce());
+        expect(onRuntimeExit).toHaveBeenCalledWith(expect.objectContaining({
+            sessionId: 'session-1',
+            managed: true,
+            purpose: 'active',
+            incarnationId: expect.any(String),
+        }));
+    });
+    it('preserves a first-stop failure when no creation barrier exists', async () => {
+        const handle = createTestProcessHandle();
+        mockChildOf(handle).kill = vi.fn(() => {
+            throw new Error('signal failed');
+        });
+        const { supervisor } = createHarness(() => Promise.resolve(handle));
+        await install(supervisor);
+        await expect(supervisor.stopAndQuiesce('session-1')).rejects.toThrow('signal failed');
+        expect(supervisor.isStopInProgress('session-1')).toBe(false);
+        expect(supervisor.getInstalledHandle('session-1')).toBe(handle);
+        exitChildAfterSigterm(mockChildOf(handle));
+        await supervisor.stopClient('session-1');
+        expect(supervisor.getInstalledHandle('session-1')).toBeUndefined();
+    });
+    it('retains the current handle when SIGTERM returns false and permits a retry', async () => {
+        const handle = createTestProcessHandle();
+        const child = mockChildOf(handle);
+        let signalAttempt = 0;
+        child.kill = vi.fn((signal) => {
+            signalAttempt += 1;
+            if (signalAttempt === 1) {
+                return false;
+            }
+            if (signal === 'SIGTERM') {
+                queueMicrotask(() => {
+                    child.signalCode = 'SIGTERM';
+                    child.emit('exit', null, 'SIGTERM');
+                });
+            }
+            return true;
+        });
+        const { supervisor } = createHarness(() => Promise.resolve(handle));
+        await install(supervisor);
+        vi.useFakeTimers();
+        try {
+            const firstStop = supervisor.stopClient('session-1').then(() => undefined, (error) => error);
+            await vi.advanceTimersByTimeAsync(5001);
+            await expect(firstStop).resolves.toMatchObject({
+                message: 'Failed to send SIGTERM to ACP process for session session-1',
+            });
+            expect(supervisor.getInstalledHandle('session-1')).toBe(handle);
+            await supervisor.stopClient('session-1');
+            expect(supervisor.getInstalledHandle('session-1')).toBeUndefined();
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('retries the retained runtime after a first-stop failure when a creation barrier completes', async () => {
+        const first = createTestProcessHandle();
+        const firstChild = mockChildOf(first);
+        firstChild.kill = vi
+            .fn()
+            .mockImplementationOnce(() => {
+            throw new Error('first signal failed');
+        })
+            .mockImplementation((signal) => {
+            if (signal === 'SIGTERM') {
+                queueMicrotask(() => {
+                    firstChild.signalCode = 'SIGTERM';
+                    firstChild.emit('exit', null, 'SIGTERM');
+                });
+            }
+            return true;
+        });
+        const barrier = createDeferred();
+        const { supervisor, createClient } = createHarness();
+        createClient.mockResolvedValueOnce(first);
+        await install(supervisor);
+        const creation = supervisor.runClientCreationOperation('session-1', 'active', async () => {
+            await barrier.promise;
+            return await install(supervisor);
+        });
+        const stopping = supervisor.stopAndQuiesce('session-1');
+        await vi.waitFor(() => expect(first.child.kill).toHaveBeenCalledWith('SIGTERM'));
+        barrier.resolve(undefined);
+        await expect(creation).resolves.toBe(first);
+        await expect(stopping).resolves.toBeUndefined();
+        expect(first.child.kill).toHaveBeenCalledTimes(2);
+        expect(createClient).toHaveBeenCalledOnce();
+        expect(supervisor.getInstalledHandle('session-1')).toBeUndefined();
+    });
+    it('makes a duplicate quiescing stop share identity while creation crosses an async boundary', async () => {
+        const handle = createTestProcessHandle();
+        exitChildAfterSigterm(mockChildOf(handle));
+        const factoryCreation = createDeferred();
+        const { supervisor } = createHarness(() => factoryCreation.promise);
+        const creation = supervisor.runClientCreationOperation('session-1', 'active', () => supervisor.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext()));
+        await vi.waitFor(() => expect(supervisor.getPendingClient('session-1')).toBeDefined());
+        const firstStop = supervisor.stopAndQuiesce('session-1');
+        const secondStop = supervisor.stopAndQuiesce('session-1');
+        expect(secondStop).toBe(firstStop);
+        factoryCreation.resolve(handle);
+        const [creationResult, stopResult] = await Promise.allSettled([creation, firstStop]);
+        expect(creationResult).toMatchObject({ status: 'rejected' });
+        expect(stopResult).toEqual({ status: 'fulfilled', value: undefined });
+        expect(handle.child.kill).toHaveBeenCalledWith('SIGTERM');
+        expect(supervisor.getInstalledHandle('session-1')).toBeUndefined();
+        expect(supervisor.getPendingClient('session-1')).toBeUndefined();
+    });
+    it('cancels an in-flight prompt before sending SIGTERM', async () => {
+        const handle = createTestProcessHandle();
+        handle.isPromptInFlight = true;
+        const order = [];
+        exitChildWithCode(mockChildOf(handle));
+        mockChildOf(handle).kill = vi.fn((signal) => {
+            order.push(signal ?? 'default');
+            mockChildOf(handle).exitCode = 0;
+            handle.child.emit('exit', 0, null);
+            return true;
+        });
+        const { supervisor, cancelPrompt } = createHarness(() => Promise.resolve(handle));
+        cancelPrompt.mockImplementation((sessionId, current) => {
+            expect(sessionId).toBe('session-1');
+            expect(current).toBe(handle);
+            order.push('cancel');
+            return Promise.resolve(true);
+        });
+        await install(supervisor);
+        await supervisor.stopClient('session-1');
+        expect(order).toEqual(['cancel', 'SIGTERM']);
+    });
+    it('escalates a live process from SIGTERM to SIGKILL after the grace period', async () => {
+        const handle = createTestProcessHandle();
+        const child = mockChildOf(handle);
+        const signals = [];
+        child.kill = vi.fn((signal) => {
+            signals.push(signal ?? 'default');
+            if (signal === 'SIGKILL') {
+                child.exitCode = 137;
+                child.emit('exit', 137, 'SIGKILL');
+            }
+            return true;
+        });
+        const { supervisor } = createHarness(() => Promise.resolve(handle));
+        await install(supervisor);
+        vi.useFakeTimers();
+        const stop = supervisor.stopClient('session-1');
+        await vi.advanceTimersByTimeAsync(5001);
+        await stop;
+        expect(signals).toEqual(['SIGTERM', 'SIGKILL']);
+        expect(supervisor.getInstalledHandle('session-1')).toBeUndefined();
+        expect(vi.getTimerCount()).toBe(0);
+    });
+    it('waits for the asynchronous process exit after sending SIGKILL', async () => {
+        const handle = createTestProcessHandle();
+        const child = mockChildOf(handle);
+        child.kill = vi.fn(() => true);
+        const { supervisor } = createHarness(() => Promise.resolve(handle));
+        await install(supervisor);
+        vi.useFakeTimers();
+        try {
+            let stopped = false;
+            const stop = supervisor.stopClient('session-1').then(() => {
+                stopped = true;
+            });
+            await vi.advanceTimersByTimeAsync(5001);
+            expect(child.kill).toHaveBeenCalledWith('SIGKILL');
+            expect(stopped).toBe(false);
+            expect(supervisor.getInstalledHandle('session-1')).toBe(handle);
+            child.signalCode = 'SIGKILL';
+            child.emit('exit', null, 'SIGKILL');
+            await stop;
+            expect(stopped).toBe(true);
+            expect(supervisor.getInstalledHandle('session-1')).toBeUndefined();
+            expect(vi.getTimerCount()).toBe(0);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('accepts a pending exit when SIGKILL reports that the process is already gone', async () => {
+        const handle = createTestProcessHandle();
+        const child = mockChildOf(handle);
+        const signals = [];
+        child.kill = vi.fn((signal) => {
+            signals.push(signal ?? 'default');
+            if (signal === 'SIGKILL') {
+                queueMicrotask(() => {
+                    child.signalCode = 'SIGTERM';
+                    child.emit('exit', null, 'SIGTERM');
+                });
+                return false;
+            }
+            return true;
+        });
+        const { supervisor } = createHarness(() => Promise.resolve(handle));
+        await install(supervisor);
+        vi.useFakeTimers();
+        try {
+            const stopResult = supervisor.stopClient('session-1').then(() => undefined, (error) => error);
+            await vi.advanceTimersByTimeAsync(5001);
+            await expect(stopResult).resolves.toBeUndefined();
+            expect(signals).toEqual(['SIGTERM', 'SIGKILL']);
+            expect(supervisor.getInstalledHandle('session-1')).toBeUndefined();
+            expect(vi.getTimerCount()).toBe(0);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('retains the runtime when SIGKILL fails without a confirmed exit', async () => {
+        const handle = createTestProcessHandle();
+        const child = mockChildOf(handle);
+        let retrying = false;
+        child.kill = vi.fn((signal) => {
+            if (retrying && signal === 'SIGTERM') {
+                queueMicrotask(() => {
+                    child.signalCode = 'SIGTERM';
+                    child.emit('exit', null, 'SIGTERM');
+                });
+                return true;
+            }
+            return signal !== 'SIGKILL';
+        });
+        const { supervisor } = createHarness(() => Promise.resolve(handle));
+        await install(supervisor);
+        vi.useFakeTimers();
+        try {
+            const firstStop = supervisor.stopClient('session-1').then(() => undefined, (error) => error);
+            await vi.advanceTimersByTimeAsync(5001);
+            await vi.advanceTimersByTimeAsync(5001);
+            await expect(firstStop).resolves.toMatchObject({
+                message: 'Failed to send SIGKILL to ACP process for session session-1',
+            });
+            expect(supervisor.getInstalledHandle('session-1')).toBe(handle);
+            retrying = true;
+            await supervisor.stopClient('session-1');
+            expect(supervisor.getInstalledHandle('session-1')).toBeUndefined();
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('does not escalate after the process exits from SIGTERM with a null exit code', async () => {
+        const handle = createTestProcessHandle();
+        exitChildAfterSigterm(mockChildOf(handle));
+        const { supervisor } = createHarness(() => Promise.resolve(handle));
+        await install(supervisor);
+        await supervisor.stopClient('session-1');
+        expect(handle.child.signalCode).toBe('SIGTERM');
+        expect(handle.child.kill).toHaveBeenCalledOnce();
+        expect(handle.child.kill).toHaveBeenCalledWith('SIGTERM');
+        expect(handle.child.kill).not.toHaveBeenCalledWith('SIGKILL');
+    });
+    it('omits managed late exits and stale runtime events without deleting a replacement', async () => {
+        const first = createTestProcessHandle();
+        markChildKilledOnSignal(mockChildOf(first));
+        const replacement = createTestProcessHandle();
+        const firstHandlers = {
+            ...defaultHandlers(),
+            onRuntimeExit: vi.fn(() => Promise.resolve()),
+        };
+        const { supervisor, createClient } = createHarness();
+        createClient.mockResolvedValueOnce(first).mockResolvedValueOnce(replacement);
+        await supervisor.getOrCreateClient('session-1', defaultOptions(), firstHandlers, defaultContext());
+        vi.useFakeTimers();
+        const stop = supervisor.stopClient('session-1');
+        await vi.advanceTimersByTimeAsync(10_001);
+        await stop;
+        vi.useRealTimers();
+        await install(supervisor);
+        mockChildOf(first).exitCode = 137;
+        first.child.emit('exit', 137, 'SIGKILL');
+        await new Promise((resolve) => setImmediate(resolve));
+        expect(firstHandlers.onRuntimeExit).not.toHaveBeenCalled();
+        expect(supervisor.getInstalledHandle('session-1')).toBe(replacement);
+    });
+    it('closes admission and inventories active, browse, pending, and barrier-only sessions', async () => {
+        const active = createTestProcessHandle();
+        const browse = createTestProcessHandle();
+        const pendingHandle = createTestProcessHandle();
+        exitChildAfterSigterm(mockChildOf(active));
+        exitChildAfterSigterm(mockChildOf(browse));
+        exitChildAfterSigterm(mockChildOf(pendingHandle));
+        const pending = createDeferred();
+        const barrier = createDeferred();
+        const { supervisor, createClient } = createHarness();
+        createClient
+            .mockResolvedValueOnce(active)
+            .mockResolvedValueOnce(browse)
+            .mockReturnValueOnce(pending.promise);
+        await install(supervisor, 'active-session');
+        await supervisor.getOrCreateClient('browse-session', { ...defaultOptions(), sessionId: 'browse-session', purpose: 'browse' }, defaultHandlers(), defaultContext());
+        const pendingCreation = supervisor.getOrCreateClient('pending-session', { ...defaultOptions(), sessionId: 'pending-session' }, defaultHandlers(), defaultContext());
+        await vi.waitFor(() => expect(supervisor.getPendingClient('pending-session')).toBeDefined());
+        const barrierOnly = supervisor.runClientCreationOperation('barrier-session', 'browse', () => barrier.promise);
+        expect(new Set(supervisor.beginShutdown())).toEqual(new Set(['active-session', 'browse-session', 'pending-session', 'barrier-session']));
+        const lateOperation = vi.fn(() => Promise.resolve(undefined));
+        await expect(supervisor.runClientCreationOperation('late-session', 'active', lateOperation)).rejects.toThrow('ACP runtime manager is shutting down');
+        await expect(install(supervisor, 'late-client')).rejects.toThrow('ACP runtime manager is shutting down');
+        expect(lateOperation).not.toHaveBeenCalled();
+        pending.resolve(pendingHandle);
+        await expect(pendingCreation).rejects.toThrow('ACP runtime manager is shutting down');
+        barrier.resolve(undefined);
+        await barrierOnly;
+        expect(pendingHandle.child.kill).toHaveBeenCalledWith('SIGTERM');
+    });
+    it('returns after the pending-creation timeout and clears creation registries', async () => {
+        const never = new Promise(() => undefined);
+        const { supervisor } = createHarness(() => never);
+        void supervisor.getOrCreateClient('pending-session', defaultOptions(), defaultHandlers(), defaultContext());
+        await vi.waitFor(() => expect(supervisor.getPendingClient('pending-session')).toBeDefined());
+        vi.useFakeTimers();
+        const stopping = supervisor.stopAllClients(50);
+        await vi.advanceTimersByTimeAsync(51);
+        await stopping;
+        expect(supervisor.getPendingClient('pending-session')).toBeUndefined();
+        expect(supervisor.isBrowseOnlySession('pending-session')).toBe(false);
+        expect(supervisor.beginShutdown()).toEqual([]);
+        expect([...supervisor.getAllClients()]).toEqual([]);
+        expect(vi.getTimerCount()).toBe(0);
+    });
+    it('waits for quiescence and performs a final stop sweep before clearing registries', async () => {
+        const first = createTestProcessHandle();
+        const late = createTestProcessHandle();
+        exitChildAfterSigterm(mockChildOf(first));
+        exitChildAfterSigterm(mockChildOf(late));
+        const reconciliation = createDeferred();
+        const { supervisor, createClient } = createHarness();
+        createClient.mockResolvedValueOnce(first).mockResolvedValueOnce(late);
+        await install(supervisor, 'session-1');
+        const operation = supervisor.runClientCreationOperation('late-session', 'active', async () => {
+            await reconciliation.promise;
+            return await install(supervisor, 'late-session');
+        });
+        const operationResult = operation.catch((error) => error);
+        const stopping = supervisor.stopAllClients(50);
+        let settled = false;
+        void stopping.then(() => {
+            settled = true;
+        });
+        await new Promise((resolve) => setTimeout(resolve, 60));
+        expect(settled).toBe(false);
+        reconciliation.resolve(undefined);
+        await stopping;
+        await expect(operationResult).resolves.toMatchObject({
+            message: expect.stringContaining('ACP runtime manager is shutting down'),
+        });
+        expect(first.child.kill).toHaveBeenCalledWith('SIGTERM');
+        expect(late.child.kill).not.toHaveBeenCalled();
+        expect(supervisor.hasClientCreationOperation('late-session')).toBe(false);
+        expect(supervisor.getPendingClient('late-session')).toBeUndefined();
+        expect(supervisor.beginShutdown()).toEqual([]);
+        expect([...supervisor.getAllClients()]).toEqual([]);
+    });
+    it('finishes shutdown cleanup and the final sweep before rethrowing a stop failure', async () => {
+        const failing = createTestProcessHandle();
+        mockChildOf(failing).kill = vi.fn(() => {
+            throw new Error('signal failed');
+        });
+        const slow = createTestProcessHandle();
+        markChildKilledOnSignal(mockChildOf(slow));
+        const barrier = createDeferred();
+        const { supervisor, createClient } = createHarness();
+        createClient.mockResolvedValueOnce(failing).mockResolvedValueOnce(slow);
+        await install(supervisor, 'failing-session');
+        await install(supervisor, 'slow-session');
+        const barrierOperation = supervisor.runClientCreationOperation('barrier-session', 'browse', () => barrier.promise);
+        vi.useFakeTimers();
+        let shutdownSettled = false;
+        const shutdownResult = supervisor.stopAllClients(20).then(() => undefined, (error) => error);
+        void shutdownResult.then(() => {
+            shutdownSettled = true;
+        });
+        await vi.advanceTimersByTimeAsync(20);
+        const settledAfterFirstPass = shutdownSettled;
+        barrier.resolve(undefined);
+        await barrierOperation;
+        await vi.advanceTimersByTimeAsync(20);
+        const shutdownError = await shutdownResult;
+        const remainingClients = [...supervisor.getAllClients()];
+        const remainingInventory = supervisor.beginShutdown();
+        const barrierStillTracked = supervisor.hasClientCreationOperation('barrier-session');
+        await vi.advanceTimersByTimeAsync(5001);
+        expect(settledAfterFirstPass).toBe(false);
+        expect(shutdownError).toMatchObject({ message: 'signal failed' });
+        expect(remainingClients).toEqual([]);
+        expect(remainingInventory).toEqual([]);
+        expect(barrierStillTracked).toBe(false);
+        expect(slow.child.kill).toHaveBeenCalledWith('SIGTERM');
+    });
+    it('uses the final sweep to wait for a stop that outlives the first shutdown pass', async () => {
+        const handle = createTestProcessHandle();
+        markChildKilledOnSignal(mockChildOf(handle));
+        const { supervisor } = createHarness(() => Promise.resolve(handle));
+        await install(supervisor);
+        vi.useFakeTimers();
+        let settled = false;
+        const stopping = supervisor.stopAllClients(50).then(() => {
+            settled = true;
+        });
+        await vi.advanceTimersByTimeAsync(50);
+        expect(settled).toBe(false);
+        mockChildOf(handle).exitCode = 0;
+        handle.child.emit('exit', 0, null);
+        await stopping;
+        expect(handle.child.kill).toHaveBeenCalledOnce();
+        expect(handle.child.kill).toHaveBeenCalledWith('SIGTERM');
+        expect([...supervisor.getAllClients()]).toEqual([]);
+        expect(vi.getTimerCount()).toBe(0);
+    });
+    it('stops active and browse clients and leaves no observable registry state', async () => {
+        const active = createTestProcessHandle();
+        const browse = createTestProcessHandle();
+        exitChildWithCode(mockChildOf(active));
+        exitChildWithCode(mockChildOf(browse));
+        const { supervisor, createClient } = createHarness();
+        createClient.mockResolvedValueOnce(active).mockResolvedValueOnce(browse);
+        await install(supervisor, 'active-session');
+        await supervisor.getOrCreateClient('browse-session', { ...defaultOptions(), sessionId: 'browse-session', purpose: 'browse' }, defaultHandlers(), defaultContext());
+        await supervisor.stopAllClients(500);
+        expect(active.child.kill).toHaveBeenCalledWith('SIGTERM');
+        expect(browse.child.kill).toHaveBeenCalledWith('SIGTERM');
+        expect(supervisor.getInstalledHandle('active-session')).toBeUndefined();
+        expect(supervisor.getInstalledHandle('browse-session')).toBeUndefined();
+        expect(supervisor.isBrowseOnlySession('browse-session')).toBe(false);
+        expect(supervisor.isStopInProgress('active-session')).toBe(false);
+        expect(supervisor.isStopInProgress('browse-session')).toBe(false);
+        expect(supervisor.getAllActiveProcesses()).toEqual([]);
+        expect(supervisor.beginShutdown()).toEqual([]);
+    });
+});
+//# sourceMappingURL=acp-runtime-supervisor.termination.test.js.map