@doingdev/opencode-claude-manager-plugin 0.1.58 → 0.1.60

package/dist/test/claude-manager.plugin.test.js

@@ -1,6 +1,10 @@
-import { describe, expect, it } from 'vitest';
+import { afterEach, 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 { AGENT_CTO, AGENT_TEAM_PLANNER, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from '../src/plugin/agent-hierarchy.js';
+import { clearPluginServices } from '../src/plugin/service-factory.js';
 describe('ClaudeManagerPlugin', () => {
     it('configures CTO with orchestration tools and question access', async () => {
         const plugin = await ClaudeManagerPlugin({
@@ -27,6 +31,8 @@ describe('ClaudeManagerPlugin', () => {
             question: 'allow',
             team_status: 'allow',
             reset_engineer: 'allow',
+            confirm_plan: 'allow',
+            advance_slice: 'allow',
             git_diff: 'allow',
             git_commit: 'allow',
             git_reset: 'allow',
@@ -121,6 +127,8 @@ describe('ClaudeManagerPlugin', () => {
         expect(tools['claude']).toBeDefined();
         expect(tools['team_status']).toBeDefined();
         expect(tools['plan_with_team']).toBeDefined();
+        expect(tools['confirm_plan']).toBeDefined();
+        expect(tools['advance_slice']).toBeDefined();
         expect(tools['reset_engineer']).toBeDefined();
         expect(tools['assign_engineer']).toBeUndefined();
     });
@@ -144,6 +152,63 @@ describe('ClaudeManagerPlugin', () => {
         expect(modelSchema.safeParse(undefined).success).toBe(true);
         expect(modelSchema.safeParse('claude-haiku-4-5').success).toBe(false);
     });
+    it('confirm_plan tool validates taskSize enum and requires summary', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        const confirmPlan = tools['confirm_plan'];
+        expect(confirmPlan).toBeDefined();
+        const summarySchema = confirmPlan.args.summary;
+        const taskSizeSchema = confirmPlan.args.taskSize;
+        const slicesSchema = confirmPlan.args.slices;
+        const preAuthorizedSchema = confirmPlan.args.preAuthorized;
+        expect(summarySchema.safeParse('Billing refactor').success).toBe(true);
+        expect(summarySchema.safeParse('').success).toBe(false);
+        expect(taskSizeSchema.safeParse('trivial').success).toBe(true);
+        expect(taskSizeSchema.safeParse('simple').success).toBe(true);
+        expect(taskSizeSchema.safeParse('large').success).toBe(true);
+        expect(taskSizeSchema.safeParse('medium').success).toBe(false);
+        expect(taskSizeSchema.safeParse('huge').success).toBe(false);
+        // slices is optional — absent and array both valid
+        expect(slicesSchema.safeParse(undefined).success).toBe(true);
+        expect(slicesSchema.safeParse(['slice A', 'slice B']).success).toBe(true);
+        // preAuthorized is optional boolean
+        expect(preAuthorizedSchema.safeParse(true).success).toBe(true);
+        expect(preAuthorizedSchema.safeParse(false).success).toBe(true);
+        expect(preAuthorizedSchema.safeParse(undefined).success).toBe(true);
+    });
+    it('advance_slice tool validates sliceIndex and optional status enum', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        const advanceSlice = tools['advance_slice'];
+        expect(advanceSlice).toBeDefined();
+        const sliceIndexSchema = advanceSlice.args.sliceIndex;
+        const statusSchema = advanceSlice.args.status;
+        expect(sliceIndexSchema.safeParse(0).success).toBe(true);
+        expect(sliceIndexSchema.safeParse(2).success).toBe(true);
+        expect(sliceIndexSchema.safeParse('0').success).toBe(false);
+        expect(statusSchema.safeParse('done').success).toBe(true);
+        expect(statusSchema.safeParse('skipped').success).toBe(true);
+        expect(statusSchema.safeParse(undefined).success).toBe(true);
+        expect(statusSchema.safeParse('in_progress').success).toBe(false);
+    });
+    it('confirm_plan and advance_slice are denied for engineers', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        for (const engineer of ENGINEER_AGENT_NAMES) {
+            const agentId = ENGINEER_AGENT_IDS[engineer];
+            const agent = agents[agentId];
+            expect(agent.permission['confirm_plan']).toBe('deny');
+            expect(agent.permission['advance_slice']).toBe('deny');
+        }
+    });
     it('exposes hooks for CTO team tracking and wrapper memory injection', async () => {
         const plugin = await ClaudeManagerPlugin({
             worktree: '/tmp/project',
@@ -270,3 +335,109 @@ describe('Agent ID normalization and lookup helpers', () => {
         expect(agents['browser-qa']).toBeDefined();
     });
 });
+describe('confirm_plan and advance_slice tool execution', () => {
+    let tempRoot;
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot) {
+            await rm(tempRoot, { recursive: true, force: true });
+        }
+    });
+    it('confirm_plan persists an active plan and returns it as JSON', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const tools = plugin.tool;
+        const context = {
+            sessionID: 'cto-sess-confirm',
+            worktree: tempRoot,
+            agent: AGENT_CTO,
+            metadata: vi.fn(),
+        };
+        const result = await tools['confirm_plan'].execute({
+            summary: 'Add billing history',
+            taskSize: 'large',
+            slices: ['user can view invoices', 'user can update payment method'],
+            preAuthorized: false,
+        }, context);
+        const activePlan = JSON.parse(result);
+        expect(activePlan['summary']).toBe('Add billing history');
+        expect(activePlan['taskSize']).toBe('large');
+        expect(activePlan['currentSliceIndex']).toBe(0);
+        expect(activePlan['preAuthorized']).toBe(false);
+        expect(activePlan['slices'].length).toBe(2);
+    });
+    it('advance_slice marks a slice done and returns updated plan state', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const tools = plugin.tool;
+        const context = {
+            sessionID: 'cto-sess-advance',
+            worktree: tempRoot,
+            agent: AGENT_CTO,
+            metadata: vi.fn(),
+        };
+        // Set up plan with two slices
+        await tools['confirm_plan'].execute({
+            summary: 'Two-slice task',
+            taskSize: 'large',
+            slices: ['user can log in', 'user can log out'],
+            preAuthorized: false,
+        }, context);
+        // Advance non-final slice 0
+        const result = await tools['advance_slice'].execute({ sliceIndex: 0, status: 'done' }, context);
+        const payload = JSON.parse(result);
+        const slices = payload.activePlan['slices'];
+        expect(slices[0]['status']).toBe('done');
+        expect(payload.activePlan['currentSliceIndex']).toBe(1);
+    });
+    it('advance_slice sets currentSliceIndex to null when completing the final slice', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const tools = plugin.tool;
+        const context = {
+            sessionID: 'cto-sess-final',
+            worktree: tempRoot,
+            agent: AGENT_CTO,
+            metadata: vi.fn(),
+        };
+        await tools['confirm_plan'].execute({
+            summary: 'Single-slice task',
+            taskSize: 'large',
+            slices: ['ship the feature'],
+            preAuthorized: true,
+        }, context);
+        const result = await tools['advance_slice'].execute({ sliceIndex: 0, status: 'done' }, context);
+        const payload = JSON.parse(result);
+        expect(payload.activePlan['currentSliceIndex']).toBeNull();
+    });
+    it('advance_slice throws when there is no active plan', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const tools = plugin.tool;
+        const context = {
+            sessionID: 'cto-sess-no-plan',
+            worktree: tempRoot,
+            agent: AGENT_CTO,
+            metadata: vi.fn(),
+        };
+        await expect(tools['advance_slice'].execute({ sliceIndex: 0 }, context)).rejects.toThrow('has no active plan');
+    });
+    it('advance_slice throws when the slice index is invalid', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const tools = plugin.tool;
+        const context = {
+            sessionID: 'cto-sess-bad-idx',
+            worktree: tempRoot,
+            agent: AGENT_CTO,
+            metadata: vi.fn(),
+        };
+        await tools['confirm_plan'].execute({
+            summary: 'Two-slice task',
+            taskSize: 'large',
+            slices: ['slice A', 'slice B'],
+            preAuthorized: false,
+        }, context);
+        await expect(tools['advance_slice'].execute({ sliceIndex: 99 }, context)).rejects.toThrow('slice index 99 does not exist');
+    });
+});

package/dist/test/cto-active-team.test.js

@@ -1,12 +1,19 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+/**
+ * Tests for the session-per-team CTO model:
+ * - Each CTO session ID is its own team ID (no shared repo-global state).
+ * - Same CTO session ID recovers the same team context across restarts.
+ * - A different CTO session ID in the same worktree creates an independent team.
+ * - Engineers spawned within a CTO session resolve to that CTO's team.
+ * - CTO task permissions do not allow self-delegation.
+ */
+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, getActiveTeamSession } from '../src/plugin/service-factory.js';
-import { AGENT_CTO } from '../src/plugin/agent-hierarchy.js';
-import { TeamStateStore } from '../src/state/team-state-store.js';
-describe('CTO chat.message — persisted active team', () => {
+import { clearPluginServices, getOrCreatePluginServices, getSessionTeam, getWrapperSessionMapping, registerParentSession, } from '../src/plugin/service-factory.js';
+import { AGENT_CTO, ENGINEER_AGENT_IDS } from '../src/plugin/agents/index.js';
+describe('CTO chat.message — session-per-team model', () => {
     let tempRoot;
     beforeEach(async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'cto-team-'));
@@ -18,35 +25,175 @@ describe('CTO chat.message — persisted active team', () => {
             await rm(tempRoot, { recursive: true, force: true });
         }
     });
-    it('persists the active team on the first CTO message', async () => {
+    it('CTO session ID is used directly as the team ID', async () => {
         const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
         const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'session-cto-1' });
-        const store = new TeamStateStore('.claude-manager');
-        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('session-cto-1');
-        expect(getActiveTeamSession(tempRoot)).toBe('session-cto-1');
-    });
-    it('a new CTO session adopts the already-persisted active team instead of overwriting it', async () => {
-        const store = new TeamStateStore('.claude-manager');
-        // Simulate a pre-existing persisted active team (e.g., from a previous process run).
-        await store.setActiveTeam(tempRoot, 'old-team-id');
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        expect(getSessionTeam('cto-session-1')).toBe('cto-session-1');
+    });
+    it('same CTO session ID recovers its team context after a process restart', async () => {
+        // Phase 1: CTO session 'cto-1' runs and a team record is created on disk.
+        const plugin1 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage1 = plugin1['chat.message'];
+        await chatMessage1({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        const services1 = getOrCreatePluginServices(tempRoot);
+        await services1.orchestrator.getOrCreateTeam(tempRoot, 'cto-1'); // persist team to disk
+        expect(getSessionTeam('cto-1')).toBe('cto-1');
+        // Phase 2: Simulate a process restart (all in-memory state is lost).
+        clearPluginServices();
+        // Phase 3: The same CTO session ID resumes — it should re-register itself.
+        const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage2 = plugin2['chat.message'];
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        expect(getSessionTeam('cto-1')).toBe('cto-1');
+        // The persisted team record from Phase 1 should still be accessible.
+        const services2 = getOrCreatePluginServices(tempRoot);
+        const team = await services2.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
+        expect(team.id).toBe('cto-1');
+    });
+    it('a different CTO session ID creates an independent team, not adopting prior state', async () => {
+        // Phase 1: CTO session 'cto-1' runs.
+        const plugin1 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage1 = plugin1['chat.message'];
+        await chatMessage1({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        const services1 = getOrCreatePluginServices(tempRoot);
+        await services1.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
+        // Phase 2: Process restart.
+        clearPluginServices();
+        // Phase 3: A brand-new CTO session 'cto-2' starts.
+        const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage2 = plugin2['chat.message'];
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
+        // Must use its OWN session ID as team — must NOT adopt 'cto-1'.
+        expect(getSessionTeam('cto-2')).toBe('cto-2');
+        expect(getSessionTeam('cto-1')).toBeUndefined(); // cleared by restart
+        // 'cto-1' team data remains on disk, untouched.
+        const services2 = getOrCreatePluginServices(tempRoot);
+        const team1 = await services2.teamStore.getTeam(tempRoot, 'cto-1');
+        expect(team1).not.toBeNull(); // still present
+        expect(team1.id).toBe('cto-1');
+    });
+    it('multiple chat.message calls from the same CTO session do not change the active team', async () => {
         const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
         const chatMessage = plugin['chat.message'];
-        // New CTO session with a different session ID.
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'brand-new-cto-session' });
-        // The persisted active team must NOT be overwritten.
-        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('old-team-id');
-        // The in-memory registry must point to the persisted team, NOT the new session.
-        expect(getActiveTeamSession(tempRoot)).toBe('old-team-id');
-    });
-    it('does not overwrite the persisted team across two CTO messages in the same session', async () => {
-        const store = new TeamStateStore('.claude-manager');
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        expect(getSessionTeam('cto-session-1')).toBe('cto-session-1');
+    });
+    it("engineers spawned during a CTO session resolve to that CTO session's team", async () => {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        // CTO session fires first, establishing the active team.
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-A' });
+        // Simulate session.created event: OpenCode fires this before chat.message for the engineer.
+        registerParentSession('wrapper-tom-1', 'cto-A');
+        // Engineer wrapper session fires (spawned by the CTO).
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-1' });
+        // The wrapper session must be mapped to the CTO's team, not a new orphan team.
+        const mapping = getWrapperSessionMapping(tempRoot, 'wrapper-tom-1');
+        expect(mapping).toBeDefined();
+        expect(mapping.teamId).toBe('cto-A');
+        expect(mapping.workerName).toBe('Tom');
+    });
+    it('two concurrent CTO sessions each bind their own engineers independently', async () => {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        // Two CTO sessions start concurrently in the same worktree.
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-alpha' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-beta' });
+        // Simulate session.created events: each CTO spawns one engineer sub-session.
+        // The event hook normally calls registerParentSession; call it directly here.
+        registerParentSession('wrapper-tom-alpha', 'cto-alpha');
+        registerParentSession('wrapper-sara-beta', 'cto-beta');
+        // Engineer wrapper sessions check in.
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-alpha' });
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Sara, sessionID: 'wrapper-sara-beta' });
+        // Tom must bind to cto-alpha's team, not cto-beta's.
+        const tomMapping = getWrapperSessionMapping(tempRoot, 'wrapper-tom-alpha');
+        expect(tomMapping).toBeDefined();
+        expect(tomMapping.teamId).toBe('cto-alpha');
+        // Sara must bind to cto-beta's team, not cto-alpha's.
+        const saraMapping = getWrapperSessionMapping(tempRoot, 'wrapper-sara-beta');
+        expect(saraMapping).toBeDefined();
+        expect(saraMapping.teamId).toBe('cto-beta');
+    });
+});
+describe('CTO task permissions — self-delegation', () => {
+    let tempRoot;
+    beforeEach(async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'cto-perms-'));
+        clearPluginServices();
+    });
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot)
+            await rm(tempRoot, { recursive: true, force: true });
+    });
+    it('CTO task permissions deny delegation to cto', async () => {
         const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        const cto = agents[AGENT_CTO];
+        const taskPerms = cto.permission.task;
+        // Default deny must apply, and cto must not be explicitly allowed.
+        expect(taskPerms['*']).toBe('deny');
+        expect(taskPerms['cto']).toBeUndefined();
+        expect(taskPerms['CTO']).toBeUndefined();
+    });
+});
+describe('CTO tool isolation — concurrent sessions', () => {
+    let tempRoot;
+    beforeEach(async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'cto-isolation-'));
+        clearPluginServices();
+    });
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot)
+            await rm(tempRoot, { recursive: true, force: true });
+    });
+    it('team_status called from CTO-A uses CTO-A team even after CTO-B has chatted', async () => {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        // CTO-A registers first, then CTO-B registers (simulating two concurrent sessions).
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-A' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-B' });
+        // Execute team_status as CTO-A (sessionID = 'cto-A').
+        const teamStatusTool = plugin.tool['team_status'];
+        const ctx = {
+            metadata: vi.fn(),
+            worktree: tempRoot,
+            sessionID: 'cto-A',
+            agent: AGENT_CTO,
+            abort: new AbortController().signal,
+        };
+        const result = JSON.parse(await teamStatusTool.execute({}, ctx));
+        // Must load cto-A's team, NOT cto-B's (last-write-wins global would give 'cto-B').
+        expect(result.id).toBe('cto-A');
+    });
+    it('resolves engineer team via live SDK lookup when session.created was not received', async () => {
+        // Simulate a client whose session.get returns parentID for the engineer session.
+        const mockClient = {
+            session: {
+                get: vi.fn().mockImplementation(async ({ path }) => {
+                    if (path.id === 'wrapper-tom-live') {
+                        return { data: { id: 'wrapper-tom-live', parentID: 'cto-live' } };
+                    }
+                    return { data: undefined };
+                }),
+            },
+        };
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot, client: mockClient });
         const chatMessage = plugin['chat.message'];
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'session-cto-1' });
-        await chatMessage({ agent: AGENT_CTO, sessionID: 'session-cto-1' });
-        // Still the original session — persisted.
-        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('session-cto-1');
-        expect(getActiveTeamSession(tempRoot)).toBe('session-cto-1');
+        // CTO registers its team via chat.message.
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-live' });
+        // No registerParentSession call — simulates session.created arriving late or being missed.
+        // Engineer wrapper fires; resolveTeamId must fall through to live SDK lookup.
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-live' });
+        const mapping = getWrapperSessionMapping(tempRoot, 'wrapper-tom-live');
+        expect(mapping?.teamId).toBe('cto-live');
+        expect(mockClient.session.get).toHaveBeenCalledWith({ path: { id: 'wrapper-tom-live' } });
     });
 });

package/dist/test/prompt-registry.test.js

@@ -45,6 +45,26 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.teamPlannerPrompt).toContain('auto-select');
         expect(managerPromptRegistry.teamPlannerPrompt).toContain('engineer');
     });
+    it('ctoSystemPrompt includes Confirm step in operating loop before Delegate', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Orient → Classify → Plan → Confirm → Delegate');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Confirm: Get user buy-in before implementing');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('recommendedQuestion');
+        // Confirm section must appear before Delegate section in the text
+        const confirmIdx = managerPromptRegistry.ctoSystemPrompt.indexOf('## Confirm:');
+        const delegateIdx = managerPromptRegistry.ctoSystemPrompt.indexOf('## Delegate:');
+        expect(confirmIdx).toBeGreaterThan(-1);
+        expect(confirmIdx).toBeLessThan(delegateIdx);
+    });
+    it('engineerAgentPrompt instructs engineers to surface plan deviations', () => {
+        expect(managerPromptRegistry.engineerAgentPrompt).toContain('deviation');
+        expect(managerPromptRegistry.engineerAgentPrompt).toContain('surface');
+    });
+    it('browserQaAgentPrompt instructs browser-qa to report scope mismatches', () => {
+        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('scope mismatch');
+    });
+    it('teamPlannerPrompt instructs planner to pass synthesis back unchanged', () => {
+        expect(managerPromptRegistry.teamPlannerPrompt).toContain('unchanged');
+    });
     it('ctoSystemPrompt delegates single work to named engineers via task() and dual work to team-planner', () => {
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('task(subagent_type:');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('single-engineer');
@@ -66,4 +86,36 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.browserQaSessionPrompt).not.toContain('implement');
         expect(managerPromptRegistry.browserQaSessionPrompt).not.toContain('write code');
     });
+    it('ctoSystemPrompt encodes task size classification (trivial/simple/large)', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('trivial');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('simple');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('large');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Task size');
+    });
+    it('ctoSystemPrompt mentions confirm_plan and advance_slice for large task lifecycle', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('confirm_plan');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('advance_slice');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('preAuthorized');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('vertical slice');
+    });
+    it('ctoSystemPrompt encodes warn-only context policy', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Context warnings');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('advisory');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('contextExhausted');
+    });
+    it('contextWarnings reflect warn-only policy for critical level', () => {
+        expect(managerPromptRegistry.contextWarnings.critical).toContain('near capacity');
+        expect(managerPromptRegistry.contextWarnings.critical).toContain('Warn only');
+    });
+    it('ctoSystemPrompt uses genuinely vertical slice examples, not horizontal layers', () => {
+        // Horizontal layer examples (internal plumbing only) must not appear
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"types + contracts"');
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"core logic"');
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"plugin tools"');
+        // Prompt must describe the end-to-end / user-testable property of a slice
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('end-to-end');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('user-testable');
+        // Horizontal layers must be explicitly called out as wrong
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Horizontal layer');
+    });
 });

package/dist/test/report-claude-event.test.js

@@ -8,7 +8,7 @@ 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, getActiveTeamSession, getOrCreatePluginServices, } from '../src/plugin/service-factory.js';
+import { clearPluginServices, getOrCreatePluginServices, getSessionTeam, registerParentSession, } from '../src/plugin/service-factory.js';
 import { AGENT_CTO, ENGINEER_AGENT_IDS } from '../src/plugin/agent-hierarchy.js';
 import { TeamStateStore } from '../src/state/team-state-store.js';
 import { TeamOrchestrator } from '../src/manager/team-orchestrator.js';
@@ -197,23 +197,25 @@ describe('second invocation continuity', () => {
         if (tempRoot)
             await rm(tempRoot, { recursive: true, force: true });
     });
-    it('wrapper memory is injected after clearPluginServices and a new plugin instance', async () => {
+    it('wrapper memory is injected after clearPluginServices and same CTO session resumes', async () => {
         // ── Phase 1: first task via orchestrator (no real SDK needed) ──────────
+        // Team ID = 'cto-1' (the CTO session ID that originally ran this work).
         const store = new TeamStateStore();
-        await store.setActiveTeam(tempRoot, 'cto-1');
         const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         await orchestrator.recordWrapperSession(tempRoot, 'cto-1', 'Tom', 'wrapper-tom-1');
         await orchestrator.recordWrapperExchange(tempRoot, 'cto-1', 'Tom', 'wrapper-tom-1', 'explore', 'Investigate the auth flow', 'Found two race conditions in the token refresh path.');
         // ── Phase 2: process restart ───────────────────────────────────────────
         clearPluginServices();
-        // ── Phase 3: new plugin instance, new CTO session ──────────────────────
+        // ── Phase 3: same CTO session resumes, engineers run a new wrapper ──────
         const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
         const chatMessage2 = plugin2['chat.message'];
         const systemTransform2 = plugin2['experimental.chat.system.transform'];
-        // New CTO session must adopt the persisted team, not create a new one.
-        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
-        expect(getActiveTeamSession(tempRoot)).toBe('cto-1');
-        // Tom's new wrapper session must be registered under the persisted team.
+        // Same CTO session ID resumes — re-registers itself as the team.
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        expect(getSessionTeam('cto-1')).toBe('cto-1');
+        // Simulate session.created: OpenCode fires this when cto-1 spawns the new wrapper.
+        registerParentSession('wrapper-tom-2', 'cto-1');
+        // Tom's new wrapper session is registered under the same team.
         await chatMessage2({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-2' });
         // Transform fires (after chat.message has registered the session mapping).
         const output = { system: [] };
@@ -224,9 +226,8 @@ describe('second invocation continuity', () => {
         expect(output.system[0]).toContain('Found two race conditions');
     });
     it('existing engineer Claude session is resumed on second invocation', async () => {
-        // ── Phase 1: pre-seed Tom with a claudeSessionId ───────────────────────
+        // ── Phase 1: pre-seed Tom with a claudeSessionId under team 'cto-1' ────
         const store = new TeamStateStore();
-        await store.setActiveTeam(tempRoot, 'cto-1');
         const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         await orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
         await store.updateTeam(tempRoot, 'cto-1', (team) => ({
@@ -235,10 +236,13 @@ describe('second invocation continuity', () => {
         }));
         // ── Phase 2: process restart ───────────────────────────────────────────
         clearPluginServices();
-        // ── Phase 3: new plugin, new CTO, engineer runs second task ───────────
+        // ── Phase 3: same CTO session resumes, engineer runs second task ───────
         const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
         const chatMessage2 = plugin2['chat.message'];
-        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
+        // Same CTO session ID — re-registers as the team so Tom can find his session.
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        // Simulate session.created: OpenCode fires this when cto-1 spawns the new wrapper.
+        registerParentSession('wrapper-tom-2', 'cto-1');
         await chatMessage2({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-2' });
         const services2 = getOrCreatePluginServices(tempRoot);
         // Mock at the session level so dispatchEngineer runs its real logic