@doingdev/opencode-claude-manager-plugin 0.1.64 → 0.1.66

package/dist/test/undo-propagation.test.js

@@ -1,837 +0,0 @@
-/**
- * Tests for coordinated CTO undo propagation.
- *
- * When the user undoes a CTO session turn (session.updated with revert marker):
- *   - Only CTO sessions trigger propagation (not engineer wrapper sessions).
- *   - The same revert marker is processed at most once per session (dedup).
- *   - Engineer wrapper sessions in OpenCode are reverted.
- *   - Inner Claude Code sessions receive /undo for each affected exchange.
- *   - Stale wrapper history entries are pruned from disk.
- *   - One engineer failure does not prevent other engineers from being processed.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { ClaudeManagerPlugin } from '../src/plugin/claude-manager.plugin.js';
-import { clearPluginServices, getOrCreatePluginServices, isRevertAlreadyProcessed, } from '../src/plugin/service-factory.js';
-import { AGENT_CTO } from '../src/plugin/agents/index.js';
-import { TeamStateStore } from '../src/state/team-state-store.js';
-function makeSessionUpdatedEvent(sessionId, revertMessageId) {
-    return {
-        type: 'session.updated',
-        properties: {
-            info: {
-                id: sessionId,
-                title: 'test session',
-                version: '1',
-                projectID: 'project-1',
-                directory: '/tmp',
-                time: { created: 1_000_000, updated: 2_000_000 },
-                ...(revertMessageId !== undefined && { revert: { messageID: revertMessageId } }),
-            },
-        },
-    };
-}
-/**
- * Build a lightweight mock OpenCode client.
- * `ctoMessageTimestamp` is the Unix-ms timestamp for the reverted CTO message.
- * `wrapperMessages` is what client.session.messages returns for wrapper sessions.
- */
-function buildMockClient(options) {
-    const { ctoMessageTimestamp = 1_500_000, wrapperMessages = [], revertSpy = vi.fn() } = options;
-    return {
-        session: {
-            get: vi.fn().mockResolvedValue({ data: undefined }),
-            message: vi.fn().mockResolvedValue({
-                data: {
-                    info: {
-                        id: 'msg-rev-1',
-                        role: 'user',
-                        sessionID: 'cto-1',
-                        time: { created: ctoMessageTimestamp },
-                    },
-                    parts: [],
-                },
-            }),
-            messages: vi.fn().mockResolvedValue({ data: wrapperMessages }),
-            revert: revertSpy,
-        },
-    };
-}
-function makeWrapperEntry(type, timestamp) {
-    return { timestamp, type, mode: 'implement', text: `${type} at ${timestamp}` };
-}
-// ---------------------------------------------------------------------------
-// Detection and filtering
-// ---------------------------------------------------------------------------
-describe('CTO undo propagation — detection and filtering', () => {
-    let tempRoot;
-    beforeEach(async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'undo-detect-'));
-        clearPluginServices();
-    });
-    afterEach(async () => {
-        clearPluginServices();
-        if (tempRoot)
-            await rm(tempRoot, { recursive: true, force: true });
-    });
-    it('does nothing when session.updated has no revert marker', async () => {
-        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        const eventFn = plugin.event;
-        // No error — event without revert is silently ignored
-        await expect(eventFn({ event: makeSessionUpdatedEvent('cto-1') })).resolves.toBeUndefined();
-        expect(isRevertAlreadyProcessed('cto-1', 'any-msg')).toBe(false);
-    });
-    it('skips session.updated for sessions not registered as CTO teams', async () => {
-        const mockClient = buildMockClient({});
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        // 'unknown-session' was never registered via chat.message for AGENT_CTO
-        const eventFn = plugin.event;
-        await eventFn({ event: makeSessionUpdatedEvent('unknown-session', 'msg-rev-1') });
-        // No propagation — message lookup should not have been attempted
-        expect(mockClient.session.message).not.toHaveBeenCalled();
-        expect(isRevertAlreadyProcessed('unknown-session', 'msg-rev-1')).toBe(false);
-    });
-    it('marks the revert as processed after handling a CTO session.updated event', async () => {
-        const mockClient = buildMockClient({ ctoMessageTimestamp: 1_500_000 });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        // Create the team so orchestrator.getOrCreateTeam doesn't fail
-        await getOrCreatePluginServices(tempRoot).orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const eventFn = plugin.event;
-        await eventFn({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-1') });
-        expect(isRevertAlreadyProcessed('cto-1', 'msg-rev-1')).toBe(true);
-    });
-    it('propagates undo for a CTO team found only on disk (in-memory registry empty after restart)', async () => {
-        const ctoMessageTimestamp = 1_500_000;
-        const mockClient = buildMockClient({ ctoMessageTimestamp });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        // Seed the team on disk WITHOUT registering it in the in-memory session-team registry
-        // (simulates a process restart where the registry was cleared but disk state persists)
-        const services = getOrCreatePluginServices(tempRoot);
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-persisted');
-        // Do NOT call chatMessage for AGENT_CTO — leaves sessionTeamRegistry empty
-        const eventFn = plugin.event;
-        await eventFn({ event: makeSessionUpdatedEvent('cto-persisted', 'msg-rev-1') });
-        // The persisted fallback should have found the team and attempted the CTO message lookup
-        expect(mockClient.session.message).toHaveBeenCalledOnce();
-        expect(isRevertAlreadyProcessed('cto-persisted', 'msg-rev-1')).toBe(true);
-    });
-    it('does not propagate when client is absent (no timestamp lookup possible)', async () => {
-        // Plugin created without a client — should not throw and should not mark as processed
-        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-no-client' });
-        await getOrCreatePluginServices(tempRoot).orchestrator.getOrCreateTeam(tempRoot, 'cto-no-client');
-        const eventFn = plugin.event;
-        await expect(eventFn({ event: makeSessionUpdatedEvent('cto-no-client', 'msg-rev-1') })).resolves.toBeUndefined();
-        // Cutoff resolution throws when client is absent; outer catch clears the marker
-        // so a subsequent event (e.g. after client becomes available) can retry.
-        expect(isRevertAlreadyProcessed('cto-no-client', 'msg-rev-1')).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// Deduplication lifecycle
-// ---------------------------------------------------------------------------
-describe('CTO undo propagation — dedup lifecycle (redo then undo again)', () => {
-    let tempRoot;
-    beforeEach(async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'undo-dedup-lifecycle-'));
-        clearPluginServices();
-    });
-    afterEach(async () => {
-        clearPluginServices();
-        if (tempRoot)
-            await rm(tempRoot, { recursive: true, force: true });
-    });
-    it('re-processes the same revert marker after a session.updated with no revert clears it', async () => {
-        const mockClient = buildMockClient({ ctoMessageTimestamp: 1_500_000 });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        await getOrCreatePluginServices(tempRoot).orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const eventFn = plugin.event;
-        // First undo: msg-rev-1 is processed once
-        await eventFn({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-1') });
-        expect(mockClient.session.message).toHaveBeenCalledTimes(1);
-        // Redo: revert marker disappears — should clear the dedup entry
-        await eventFn({ event: makeSessionUpdatedEvent('cto-1') });
-        expect(isRevertAlreadyProcessed('cto-1', 'msg-rev-1')).toBe(false);
-        // Undo again with the same message ID — must be processed again
-        await eventFn({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-1') });
-        expect(mockClient.session.message).toHaveBeenCalledTimes(2);
-    });
-});
-// ---------------------------------------------------------------------------
-// Deduplication
-// ---------------------------------------------------------------------------
-describe('CTO undo propagation — deduplication', () => {
-    let tempRoot;
-    beforeEach(async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'undo-dedup-'));
-        clearPluginServices();
-    });
-    afterEach(async () => {
-        clearPluginServices();
-        if (tempRoot)
-            await rm(tempRoot, { recursive: true, force: true });
-    });
-    it('processes the revert only once when session.updated fires multiple times', async () => {
-        const mockClient = buildMockClient({ ctoMessageTimestamp: 1_500_000 });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        await getOrCreatePluginServices(tempRoot).orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const eventFn = plugin.event;
-        const event = makeSessionUpdatedEvent('cto-1', 'msg-rev-1');
-        await eventFn({ event });
-        await eventFn({ event }); // Second call — should be deduped
-        await eventFn({ event }); // Third call — should also be deduped
-        // CTO message lookup must only happen once
-        expect(mockClient.session.message).toHaveBeenCalledOnce();
-    });
-    it('processes distinct revert markers independently', async () => {
-        const mockClient = buildMockClient({ ctoMessageTimestamp: 1_500_000 });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        await getOrCreatePluginServices(tempRoot).orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const eventFn = plugin.event;
-        await eventFn({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-A') });
-        await eventFn({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-B') });
-        // Two distinct revert markers → two message lookups
-        expect(mockClient.session.message).toHaveBeenCalledTimes(2);
-    });
-});
-// ---------------------------------------------------------------------------
-// Wrapper history pruning
-// ---------------------------------------------------------------------------
-describe('CTO undo propagation — wrapper history pruning', () => {
-    let tempRoot;
-    beforeEach(async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'undo-prune-'));
-        clearPluginServices();
-    });
-    afterEach(async () => {
-        clearPluginServices();
-        if (tempRoot)
-            await rm(tempRoot, { recursive: true, force: true });
-    });
-    it('prunes wrapper history entries that were added after the cutoff timestamp', async () => {
-        // CTO message timestamp: 1_500_000 ms → cutoffIso = new Date(1_500_000).toISOString()
-        const ctoMessageTimestamp = 1_500_000;
-        const cutoffIso = new Date(ctoMessageTimestamp).toISOString();
-        const beforeCutoff = new Date(ctoMessageTimestamp - 1000).toISOString();
-        const afterCutoff1 = new Date(ctoMessageTimestamp + 1000).toISOString();
-        const afterCutoff2 = new Date(ctoMessageTimestamp + 2000).toISOString();
-        const mockClient = buildMockClient({ ctoMessageTimestamp });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        const services = getOrCreatePluginServices(tempRoot);
-        // Seed the team with wrapper history spanning the cutoff
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        await services.orchestrator.recordWrapperSession(tempRoot, 'cto-1', 'Tom', 'wrapper-tom');
-        // Directly persist wrapper history via recordWrapperExchange (timestamps use Date.now internally)
-        // Instead write directly to the store to control timestamps precisely.
-        const store = new TeamStateStore();
-        await store.updateTeam(tempRoot, 'cto-1', (team) => ({
-            ...team,
-            engineers: team.engineers.map((eng) => eng.name === 'Tom'
-                ? {
-                    ...eng,
-                    wrapperSessionId: 'wrapper-tom',
-                    wrapperHistory: [
-                        makeWrapperEntry('assignment', beforeCutoff),
-                        makeWrapperEntry('result', beforeCutoff),
-                        makeWrapperEntry('assignment', afterCutoff1),
-                        makeWrapperEntry('result', afterCutoff1),
-                        makeWrapperEntry('assignment', afterCutoff2),
-                        makeWrapperEntry('result', afterCutoff2),
-                    ],
-                }
-                : eng),
-        }));
-        // Fire the undo event
-        const eventFn = plugin.event;
-        await eventFn({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-1') });
-        // Verify that only entries at or before the cutoff remain
-        const team = await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const tom = team.engineers.find((e) => e.name === 'Tom');
-        expect(tom?.wrapperHistory).toHaveLength(2);
-        expect(tom?.wrapperHistory.every((h) => h.timestamp <= cutoffIso)).toBe(true);
-    });
-    it('leaves wrapper history untouched when all entries are before the cutoff', async () => {
-        const ctoMessageTimestamp = 5_000_000;
-        const mockClient = buildMockClient({ ctoMessageTimestamp });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        const services = getOrCreatePluginServices(tempRoot);
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const early = new Date(1_000_000).toISOString();
-        const store = new TeamStateStore();
-        await store.updateTeam(tempRoot, 'cto-1', (team) => ({
-            ...team,
-            engineers: team.engineers.map((eng) => eng.name === 'Tom'
-                ? {
-                    ...eng,
-                    wrapperHistory: [
-                        makeWrapperEntry('assignment', early),
-                        makeWrapperEntry('result', early),
-                    ],
-                }
-                : eng),
-        }));
-        const eventFn = plugin.event;
-        await eventFn({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-2') });
-        const team = await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const tom = team.engineers.find((e) => e.name === 'Tom');
-        // Nothing after cutoff → all entries preserved
-        expect(tom?.wrapperHistory).toHaveLength(2);
-    });
-});
-// ---------------------------------------------------------------------------
-// Inner Claude session /undo calls
-// ---------------------------------------------------------------------------
-describe('CTO undo propagation — inner Claude session /undo', () => {
-    let tempRoot;
-    beforeEach(async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'undo-claude-'));
-        clearPluginServices();
-    });
-    afterEach(async () => {
-        clearPluginServices();
-        if (tempRoot)
-            await rm(tempRoot, { recursive: true, force: true });
-    });
-    it('sends /undo once per assignment exchange that occurred after the cutoff', async () => {
-        const ctoMessageTimestamp = 1_500_000;
-        const afterCutoff = new Date(ctoMessageTimestamp + 1000).toISOString();
-        const afterCutoff2 = new Date(ctoMessageTimestamp + 2000).toISOString();
-        const mockClient = buildMockClient({ ctoMessageTimestamp });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        const services = getOrCreatePluginServices(tempRoot);
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        // Set up Tom with 2 exchanges after cutoff and a claudeSessionId
-        const store = new TeamStateStore();
-        await store.updateTeam(tempRoot, 'cto-1', (team) => ({
-            ...team,
-            engineers: team.engineers.map((eng) => eng.name === 'Tom'
-                ? {
-                    ...eng,
-                    claudeSessionId: 'ses-claude-tom',
-                    wrapperHistory: [
-                        makeWrapperEntry('assignment', afterCutoff),
-                        makeWrapperEntry('result', afterCutoff),
-                        makeWrapperEntry('assignment', afterCutoff2),
-                        makeWrapperEntry('result', afterCutoff2),
-                    ],
-                }
-                : eng),
-        }));
-        // Spy on sessions.runTask to capture /undo calls
-        const mockRunTask = vi
-            .spyOn(services.sessions, 'runTask')
-            .mockResolvedValue({ sessionId: 'ses-claude-tom', events: [], finalText: '' });
-        const eventFn = plugin.event;
-        await eventFn({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-1') });
-        // Expect 2 /undo calls — one per assignment exchange
-        const undoCalls = mockRunTask.mock.calls.filter(([input]) => input.prompt === '/undo');
-        expect(undoCalls).toHaveLength(2);
-        for (const [input] of undoCalls) {
-            expect(input.resumeSessionId).toBe('ses-claude-tom');
-            expect(input.persistSession).toBe(true);
-            expect(input.maxTurns).toBe(1);
-        }
-    });
-    it('stops sending /undo for an engineer when runTask throws', async () => {
-        const ctoMessageTimestamp = 1_500_000;
-        const afterCutoff = new Date(ctoMessageTimestamp + 1000).toISOString();
-        const afterCutoff2 = new Date(ctoMessageTimestamp + 2000).toISOString();
-        const mockClient = buildMockClient({ ctoMessageTimestamp });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        const services = getOrCreatePluginServices(tempRoot);
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const store = new TeamStateStore();
-        await store.updateTeam(tempRoot, 'cto-1', (team) => ({
-            ...team,
-            engineers: team.engineers.map((eng) => eng.name === 'Tom'
-                ? {
-                    ...eng,
-                    claudeSessionId: 'ses-claude-tom',
-                    wrapperHistory: [
-                        makeWrapperEntry('assignment', afterCutoff),
-                        makeWrapperEntry('result', afterCutoff),
-                        makeWrapperEntry('assignment', afterCutoff2),
-                        makeWrapperEntry('result', afterCutoff2),
-                    ],
-                }
-                : eng),
-        }));
-        // First /undo call throws — should stop further attempts
-        const mockRunTask = vi
-            .spyOn(services.sessions, 'runTask')
-            .mockRejectedValueOnce(new Error('undo failed'))
-            .mockResolvedValue({ sessionId: 'ses-claude-tom', events: [], finalText: '' });
-        const eventFn = plugin.event;
-        // Event hook must not throw
-        await expect(eventFn({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-1') })).resolves.toBeUndefined();
-        // Only one /undo attempt — stopped after the first failure
-        const undoCalls = mockRunTask.mock.calls.filter(([input]) => input.prompt === '/undo');
-        expect(undoCalls).toHaveLength(1);
-    });
-});
-// ---------------------------------------------------------------------------
-// Wrapper session revert
-// ---------------------------------------------------------------------------
-describe('CTO undo propagation — wrapper session revert', () => {
-    let tempRoot;
-    beforeEach(async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'undo-wrapper-'));
-        clearPluginServices();
-    });
-    afterEach(async () => {
-        clearPluginServices();
-        if (tempRoot)
-            await rm(tempRoot, { recursive: true, force: true });
-    });
-    it('reverts the wrapper session to the first user message after the cutoff', async () => {
-        const ctoMessageTimestamp = 1_500_000;
-        const afterCutoff = new Date(ctoMessageTimestamp + 1000).toISOString();
-        const beforeCutoff = new Date(ctoMessageTimestamp - 1000).toISOString();
-        const revertSpy = vi.fn().mockResolvedValue({ data: {} });
-        const mockClient = buildMockClient({
-            ctoMessageTimestamp,
-            wrapperMessages: [
-                {
-                    info: {
-                        id: 'msg-wrapper-old',
-                        role: 'user',
-                        time: { created: ctoMessageTimestamp - 5000 },
-                    },
-                },
-                {
-                    info: {
-                        id: 'msg-wrapper-new',
-                        role: 'user',
-                        time: { created: ctoMessageTimestamp + 500 },
-                    },
-                },
-            ],
-            revertSpy,
-        });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        const services = getOrCreatePluginServices(tempRoot);
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const store = new TeamStateStore();
-        await store.updateTeam(tempRoot, 'cto-1', (team) => ({
-            ...team,
-            engineers: team.engineers.map((eng) => eng.name === 'Tom'
-                ? {
-                    ...eng,
-                    wrapperSessionId: 'wrapper-tom',
-                    wrapperHistory: [
-                        makeWrapperEntry('assignment', beforeCutoff),
-                        makeWrapperEntry('result', beforeCutoff),
-                        makeWrapperEntry('assignment', afterCutoff),
-                        makeWrapperEntry('result', afterCutoff),
-                    ],
-                }
-                : eng),
-        }));
-        vi.spyOn(services.sessions, 'runTask').mockResolvedValue({
-            sessionId: undefined,
-            events: [],
-            finalText: '',
-        });
-        const eventFn = plugin.event;
-        await eventFn({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-1') });
-        // Should revert to the first message after the CTO message timestamp
-        expect(revertSpy).toHaveBeenCalledWith(expect.objectContaining({
-            path: { id: 'wrapper-tom' },
-            body: { messageID: 'msg-wrapper-new' },
-        }));
-    });
-    it('skips wrapper session revert when no wrapper messages are after the cutoff', async () => {
-        const ctoMessageTimestamp = 1_500_000;
-        const afterCutoff = new Date(ctoMessageTimestamp + 1000).toISOString();
-        const revertSpy = vi.fn().mockResolvedValue({ data: {} });
-        const mockClient = buildMockClient({
-            ctoMessageTimestamp,
-            // All wrapper messages are before the cutoff
-            wrapperMessages: [
-                {
-                    info: {
-                        id: 'msg-wrapper-old',
-                        role: 'user',
-                        time: { created: ctoMessageTimestamp - 5000 },
-                    },
-                },
-            ],
-            revertSpy,
-        });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        const services = getOrCreatePluginServices(tempRoot);
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const store = new TeamStateStore();
-        await store.updateTeam(tempRoot, 'cto-1', (team) => ({
-            ...team,
-            engineers: team.engineers.map((eng) => eng.name === 'Tom'
-                ? {
-                    ...eng,
-                    wrapperSessionId: 'wrapper-tom',
-                    wrapperHistory: [makeWrapperEntry('assignment', afterCutoff)],
-                }
-                : eng),
-        }));
-        vi.spyOn(services.sessions, 'runTask').mockResolvedValue({
-            sessionId: undefined,
-            events: [],
-            finalText: '',
-        });
-        const eventFn = plugin.event;
-        await eventFn({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-1') });
-        // No wrapper messages after cutoff → no revert call
-        expect(revertSpy).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// Best-effort safety
-// ---------------------------------------------------------------------------
-describe('CTO undo propagation — best-effort safety', () => {
-    let tempRoot;
-    beforeEach(async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'undo-safety-'));
-        clearPluginServices();
-    });
-    afterEach(async () => {
-        clearPluginServices();
-        if (tempRoot)
-            await rm(tempRoot, { recursive: true, force: true });
-    });
-    it('processes all engineers even when one wrapper session revert throws', async () => {
-        const ctoMessageTimestamp = 1_500_000;
-        const afterCutoff = new Date(ctoMessageTimestamp + 1000).toISOString();
-        // First messages() call throws (for Tom's wrapper session), second succeeds (for John).
-        const mockClient = {
-            session: {
-                get: vi.fn().mockResolvedValue({ data: undefined }),
-                message: vi.fn().mockResolvedValue({
-                    data: {
-                        info: { id: 'msg-rev-1', role: 'user', time: { created: ctoMessageTimestamp } },
-                        parts: [],
-                    },
-                }),
-                messages: vi
-                    .fn()
-                    .mockRejectedValueOnce(new Error('wrapper session fetch failed'))
-                    .mockResolvedValue({ data: [] }),
-                revert: vi.fn().mockResolvedValue({ data: {} }),
-            },
-        };
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        const services = getOrCreatePluginServices(tempRoot);
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const store = new TeamStateStore();
-        await store.updateTeam(tempRoot, 'cto-1', (team) => ({
-            ...team,
-            engineers: team.engineers.map((eng) => {
-                if (eng.name === 'Tom') {
-                    return {
-                        ...eng,
-                        wrapperSessionId: 'wrapper-tom',
-                        claudeSessionId: 'ses-claude-tom',
-                        wrapperHistory: [
-                            makeWrapperEntry('assignment', afterCutoff),
-                            makeWrapperEntry('result', afterCutoff),
-                        ],
-                    };
-                }
-                if (eng.name === 'John') {
-                    return {
-                        ...eng,
-                        wrapperSessionId: 'wrapper-john',
-                        claudeSessionId: 'ses-claude-john',
-                        wrapperHistory: [
-                            makeWrapperEntry('assignment', afterCutoff),
-                            makeWrapperEntry('result', afterCutoff),
-                        ],
-                    };
-                }
-                return eng;
-            }),
-        }));
-        const mockRunTask = vi
-            .spyOn(services.sessions, 'runTask')
-            .mockResolvedValue({ sessionId: undefined, events: [], finalText: '' });
-        // Event hook must not throw even when Tom's wrapper session fetch fails
-        await expect(plugin.event({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-1') })).resolves.toBeUndefined();
-        // John's /undo was still attempted despite Tom's failure
-        const undoCalls = mockRunTask.mock.calls.filter(([input]) => input.prompt === '/undo');
-        expect(undoCalls.some(([input]) => input.resumeSessionId === 'ses-claude-john')).toBe(true);
-    });
-    it('runs inner /undo and history prune for an engineer even when wrapper session revert throws', async () => {
-        const ctoMessageTimestamp = 1_500_000;
-        const afterCutoff = new Date(ctoMessageTimestamp + 1000).toISOString();
-        // messages() throws so revertWrapperSession throws inside step 1
-        const mockClient = {
-            session: {
-                get: vi.fn().mockResolvedValue({ data: undefined }),
-                message: vi.fn().mockResolvedValue({
-                    data: {
-                        info: { id: 'msg-rev-1', role: 'user', time: { created: ctoMessageTimestamp } },
-                        parts: [],
-                    },
-                }),
-                messages: vi.fn().mockRejectedValue(new Error('wrapper fetch failed')),
-                revert: vi.fn().mockResolvedValue({ data: {} }),
-            },
-        };
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        const services = getOrCreatePluginServices(tempRoot);
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const store = new TeamStateStore();
-        await store.updateTeam(tempRoot, 'cto-1', (team) => ({
-            ...team,
-            engineers: team.engineers.map((eng) => eng.name === 'Tom'
-                ? {
-                    ...eng,
-                    wrapperSessionId: 'wrapper-tom',
-                    claudeSessionId: 'ses-claude-tom',
-                    wrapperHistory: [
-                        makeWrapperEntry('assignment', afterCutoff),
-                        makeWrapperEntry('result', afterCutoff),
-                    ],
-                }
-                : eng),
-        }));
-        const mockRunTask = vi
-            .spyOn(services.sessions, 'runTask')
-            .mockResolvedValue({ sessionId: 'ses-claude-tom', events: [], finalText: '' });
-        // Event hook must not throw
-        await expect(plugin.event({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-1') })).resolves.toBeUndefined();
-        // Step 2: /undo was still sent despite step 1 failing
-        const undoCalls = mockRunTask.mock.calls.filter(([input]) => input.prompt === '/undo');
-        expect(undoCalls.some(([input]) => input.resumeSessionId === 'ses-claude-tom')).toBe(true);
-        // Step 3: wrapper history was pruned
-        const team = await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const tom = team.engineers.find((e) => e.name === 'Tom');
-        expect(tom?.wrapperHistory).toHaveLength(0);
-    });
-    it('event hook resolves (does not throw) when CTO message fetch fails', async () => {
-        const mockClient = {
-            session: {
-                get: vi.fn().mockResolvedValue({ data: undefined }),
-                message: vi.fn().mockRejectedValue(new Error('network error')),
-                messages: vi.fn().mockResolvedValue({ data: [] }),
-                revert: vi.fn(),
-            },
-        };
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        await getOrCreatePluginServices(tempRoot).orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        await expect(plugin.event({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-err') })).resolves.toBeUndefined();
-        // Dedup marker must be cleared so the event can be retried after the network recovers.
-        expect(isRevertAlreadyProcessed('cto-1', 'msg-rev-err')).toBe(false);
-    });
-    it('clears the dedup marker when cutoff resolution returns no timestamp', async () => {
-        const mockClient = {
-            session: {
-                get: vi.fn().mockResolvedValue({ data: undefined }),
-                // Returns a message with no time.created field
-                message: vi
-                    .fn()
-                    .mockResolvedValue({
-                    data: { info: { id: 'msg-no-ts', role: 'user', time: {} }, parts: [] },
-                }),
-                messages: vi.fn().mockResolvedValue({ data: [] }),
-                revert: vi.fn(),
-            },
-        };
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        await getOrCreatePluginServices(tempRoot).orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        await expect(plugin.event({ event: makeSessionUpdatedEvent('cto-1', 'msg-no-ts') })).resolves.toBeUndefined();
-        // Missing timestamp is a non-permanent failure; marker must be cleared for retry.
-        expect(isRevertAlreadyProcessed('cto-1', 'msg-no-ts')).toBe(false);
-    });
-    it('resets the engineer Claude session reference and context snapshot when inner /undo fails', async () => {
-        const ctoMessageTimestamp = 1_500_000;
-        const afterCutoff = new Date(ctoMessageTimestamp + 1000).toISOString();
-        const mockClient = buildMockClient({ ctoMessageTimestamp });
-        const plugin = await ClaudeManagerPlugin({
-            worktree: tempRoot,
-            client: mockClient,
-        });
-        const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
-        const services = getOrCreatePluginServices(tempRoot);
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        // Seed Tom with a non-null claudeSessionId and a non-empty context snapshot.
-        const store = new TeamStateStore();
-        await store.updateTeam(tempRoot, 'cto-1', (team) => ({
-            ...team,
-            engineers: team.engineers.map((eng) => eng.name === 'Tom'
-                ? {
-                    ...eng,
-                    claudeSessionId: 'ses-claude-tom',
-                    wrapperHistory: [
-                        makeWrapperEntry('assignment', afterCutoff),
-                        makeWrapperEntry('result', afterCutoff),
-                    ],
-                    context: {
-                        sessionId: 'ses-claude-tom',
-                        totalTurns: 5,
-                        totalCostUsd: 0.12,
-                        latestInputTokens: 1000,
-                        latestOutputTokens: 500,
-                        contextWindowSize: 200000,
-                        estimatedContextPercent: 1,
-                        warningLevel: 'ok',
-                        compactionCount: 0,
-                    },
-                }
-                : eng),
-        }));
-        // /undo always fails
-        vi.spyOn(services.sessions, 'runTask').mockRejectedValue(new Error('undo unavailable'));
-        await expect(plugin.event({ event: makeSessionUpdatedEvent('cto-1', 'msg-rev-1') })).resolves.toBeUndefined();
-        // Both claudeSessionId and context snapshot must be cleared so the next
-        // assignment starts a truly fresh session with no stale context metrics.
-        const team = await services.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
-        const tom = team.engineers.find((e) => e.name === 'Tom');
-        expect(tom?.claudeSessionId).toBeNull();
-        expect(tom?.context.sessionId).toBeNull();
-        expect(tom?.context.totalTurns).toBe(0);
-        expect(tom?.context.totalCostUsd).toBe(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// pruneWrapperHistoryAfter (orchestrator unit tests)
-// ---------------------------------------------------------------------------
-describe('TeamOrchestrator.pruneWrapperHistoryAfter', () => {
-    let tempRoot;
-    afterEach(async () => {
-        if (tempRoot)
-            await rm(tempRoot, { recursive: true, force: true });
-    });
-    it('removes entries with timestamp strictly after the cutoff', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'prune-history-'));
-        clearPluginServices();
-        const services = getOrCreatePluginServices(tempRoot);
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        const cutoffIso = new Date(2_000_000).toISOString();
-        const before = new Date(1_000_000).toISOString();
-        const exact = cutoffIso;
-        const after = new Date(3_000_000).toISOString();
-        const store = new TeamStateStore();
-        await store.updateTeam(tempRoot, 'team-1', (team) => ({
-            ...team,
-            engineers: team.engineers.map((eng) => eng.name === 'Tom'
-                ? {
-                    ...eng,
-                    wrapperHistory: [
-                        makeWrapperEntry('assignment', before),
-                        makeWrapperEntry('result', before),
-                        makeWrapperEntry('assignment', exact),
-                        makeWrapperEntry('result', exact),
-                        makeWrapperEntry('assignment', after),
-                        makeWrapperEntry('result', after),
-                    ],
-                }
-                : eng),
-        }));
-        await services.orchestrator.pruneWrapperHistoryAfter(tempRoot, 'team-1', 'Tom', cutoffIso);
-        const team = await services.orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        const tom = team.engineers.find((e) => e.name === 'Tom');
-        // Entries at or before the cutoff remain; entries strictly after are removed.
-        expect(tom?.wrapperHistory).toHaveLength(4);
-        expect(tom?.wrapperHistory.some((h) => h.timestamp > cutoffIso)).toBe(false);
-    });
-    it('is a no-op when all entries are at or before the cutoff', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'prune-noop-'));
-        clearPluginServices();
-        const services = getOrCreatePluginServices(tempRoot);
-        await services.orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        const store = new TeamStateStore();
-        const early = new Date(500_000).toISOString();
-        await store.updateTeam(tempRoot, 'team-1', (team) => ({
-            ...team,
-            engineers: team.engineers.map((eng) => eng.name === 'Tom'
-                ? { ...eng, wrapperHistory: [makeWrapperEntry('assignment', early)] }
-                : eng),
-        }));
-        const cutoffIso = new Date(2_000_000).toISOString();
-        await services.orchestrator.pruneWrapperHistoryAfter(tempRoot, 'team-1', 'Tom', cutoffIso);
-        const team = await services.orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        const tom = team.engineers.find((e) => e.name === 'Tom');
-        expect(tom?.wrapperHistory).toHaveLength(1);
-    });
-});