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

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

@@ -0,0 +1,837 @@
+/**
+ * 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);
+    });
+});