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

package/dist/test/claude-manager.plugin.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,316 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { mkdtemp, readFile, 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_BROWSER_QA, 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({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        const cto = agents[AGENT_CTO];
-        expect(cto).toBeDefined();
-        expect(cto.mode).toBe('primary');
-        expect(cto.permission).toMatchObject({
-            '*': 'deny',
-            read: 'allow',
-            grep: 'allow',
-            glob: 'allow',
-            list: 'allow',
-            codesearch: 'allow',
-            webfetch: 'allow',
-            websearch: 'allow',
-            lsp: 'allow',
-            todowrite: 'allow',
-            todoread: 'allow',
-            question: 'allow',
-            team_status: 'allow',
-            reset_engineer: 'allow',
-            git_diff: 'allow',
-            git_commit: 'allow',
-            git_reset: 'allow',
-            git_status: 'allow',
-            git_log: 'allow',
-            claude: 'deny',
-        });
-        // Task permissions should include both uppercase (user-friendly) and lowercase (canonical) agent IDs.
-        expect(cto.permission.task).toEqual({
-            '*': 'deny',
-            Tom: 'allow',
-            tom: 'allow',
-            John: 'allow',
-            john: 'allow',
-            Maya: 'allow',
-            maya: 'allow',
-            Sara: 'allow',
-            sara: 'allow',
-            Alex: 'allow',
-            alex: 'allow',
-            BrowserQA: 'allow',
-            'browser-qa': 'allow',
-            'team-planner': 'allow',
-        });
-    });
-    it('allows CTO to delegate to engineers using both uppercase and lowercase agent IDs', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        const cto = agents[AGENT_CTO];
-        const taskPerms = cto.permission.task;
-        // Verify both uppercase and lowercase can be used for delegation.
-        // This prevents delegation failures when users write task(subagent_type: 'Maya') vs task(subagent_type: 'maya').
-        expect(taskPerms.Tom).toBe('allow');
-        expect(taskPerms.tom).toBe('allow');
-        expect(taskPerms.Maya).toBe('allow');
-        expect(taskPerms.maya).toBe('allow');
-    });
-    it('configures every named engineer with only the claude bridge tool', 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).toBeDefined();
-            expect(agent.mode).toBe('subagent');
-            expect(agent.description).toContain(engineer);
-            expect(agent.description).toContain('persistent engineer');
-            expect(agent.permission).toMatchObject({
-                '*': 'deny',
-                claude: 'allow',
-                git_diff: 'deny',
-                git_commit: 'deny',
-                reset_engineer: 'deny',
-            });
-            expect(agent.permission).not.toHaveProperty('read');
-            expect(agent.permission).not.toHaveProperty('grep');
-        }
-    });
-    it('configures team-planner as a thin planning wrapper subagent', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        const teamPlanner = agents[AGENT_TEAM_PLANNER];
-        expect(teamPlanner).toBeDefined();
-        expect(teamPlanner.mode).toBe('subagent');
-        expect(teamPlanner.description.toLowerCase()).toContain('plan');
-        expect(teamPlanner.permission).toMatchObject({
-            '*': 'deny',
-            plan_with_team: 'allow',
-            question: 'allow',
-            claude: 'deny',
-        });
-        expect(teamPlanner.permission).not.toHaveProperty('read');
-        expect(teamPlanner.permission).not.toHaveProperty('grep');
-        expect(teamPlanner.permission).not.toHaveProperty('glob');
-    });
-    it('registers the named engineer bridge and team status tools', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const tools = plugin.tool;
-        expect(tools['claude']).toBeDefined();
-        expect(tools['team_status']).toBeDefined();
-        expect(tools['plan_with_team']).toBeDefined();
-        expect(tools['reset_engineer']).toBeDefined();
-        expect(tools['assign_engineer']).toBeUndefined();
-    });
-    it('claude tool requires mode and message and supports optional model', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const tools = plugin.tool;
-        const claudeTool = tools['claude'];
-        const modeSchema = claudeTool.args.mode;
-        const messageSchema = claudeTool.args.message;
-        const modelSchema = claudeTool.args.model;
-        expect(modeSchema.safeParse('explore').success).toBe(true);
-        expect(modeSchema.safeParse('implement').success).toBe(true);
-        expect(modeSchema.safeParse('verify').success).toBe(true);
-        expect(modeSchema.safeParse('plan').success).toBe(false);
-        expect(messageSchema.safeParse('do the work').success).toBe(true);
-        expect(messageSchema.safeParse('').success).toBe(false);
-        expect(modelSchema.safeParse('claude-opus-4-6').success).toBe(true);
-        expect(modelSchema.safeParse('claude-sonnet-4-6').success).toBe(true);
-        expect(modelSchema.safeParse(undefined).success).toBe(true);
-        expect(modelSchema.safeParse('claude-haiku-4-5').success).toBe(false);
-    });
-    it('does not expose explicit plan tracking tools', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const tools = plugin.tool;
-        expect(tools['confirm_plan']).toBeUndefined();
-        expect(tools['advance_slice']).toBeUndefined();
-    });
-    it('exposes hooks for CTO team tracking and wrapper memory injection', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        expect(plugin['chat.message']).toBeTypeOf('function');
-        expect(plugin['experimental.chat.system.transform']).toBeTypeOf('function');
-    });
-});
-describe('Agent ID normalization and lookup helpers', () => {
-    it('normalizeAgentId converts mixed-case agent IDs to lowercase', async () => {
-        const { normalizeAgentId } = await import('../src/plugin/claude-manager.plugin.js');
-        expect(normalizeAgentId('Tom')).toBe('tom');
-        expect(normalizeAgentId('MAYA')).toBe('maya');
-        expect(normalizeAgentId('john')).toBe('john');
-        expect(normalizeAgentId('JoHn')).toBe('john');
-    });
-    it('engineerFromAgent resolves both uppercase and lowercase agent IDs', async () => {
-        const { engineerFromAgent } = await import('../src/plugin/claude-manager.plugin.js');
-        // Lowercase (canonical)
-        expect(engineerFromAgent('tom')).toBe('Tom');
-        expect(engineerFromAgent('maya')).toBe('Maya');
-        expect(engineerFromAgent('john')).toBe('John');
-        // Uppercase (normalized)
-        expect(engineerFromAgent('Tom')).toBe('Tom');
-        expect(engineerFromAgent('Maya')).toBe('Maya');
-        expect(engineerFromAgent('John')).toBe('John');
-        // Mixed case
-        expect(engineerFromAgent('JoHn')).toBe('John');
-        expect(engineerFromAgent('mAyA')).toBe('Maya');
-    });
-    it('engineerFromAgent throws on invalid agent IDs', async () => {
-        const { engineerFromAgent } = await import('../src/plugin/claude-manager.plugin.js');
-        expect(() => engineerFromAgent('invalid')).toThrow('The claude tool can only be used from a named engineer agent');
-        expect(() => engineerFromAgent('TomInvalid')).toThrow('The claude tool can only be used from a named engineer agent');
-    });
-    it('isEngineerAgent identifies both uppercase and lowercase agent IDs', async () => {
-        const { isEngineerAgent } = await import('../src/plugin/claude-manager.plugin.js');
-        // Lowercase (canonical)
-        expect(isEngineerAgent('tom')).toBe(true);
-        expect(isEngineerAgent('maya')).toBe(true);
-        expect(isEngineerAgent('john')).toBe(true);
-        expect(isEngineerAgent('sara')).toBe(true);
-        expect(isEngineerAgent('alex')).toBe(true);
-        // Uppercase (normalized)
-        expect(isEngineerAgent('Tom')).toBe(true);
-        expect(isEngineerAgent('Maya')).toBe(true);
-        expect(isEngineerAgent('John')).toBe(true);
-        expect(isEngineerAgent('Sara')).toBe(true);
-        expect(isEngineerAgent('Alex')).toBe(true);
-        // Mixed case
-        expect(isEngineerAgent('JoHn')).toBe(true);
-        expect(isEngineerAgent('mAyA')).toBe(true);
-        // Invalid
-        expect(isEngineerAgent('invalid')).toBe(false);
-        expect(isEngineerAgent('cto')).toBe(false);
-        expect(isEngineerAgent('team-planner')).toBe(false);
-    });
-    it('CTO agent config does not have direct assign_engineer access (delegates to named engineers)', async () => {
-        const { buildCtoAgentConfig } = await import('../src/plugin/agent-hierarchy.js');
-        const { managerPromptRegistry } = await import('../src/prompts/registry.js');
-        const ctoConfig = buildCtoAgentConfig(managerPromptRegistry);
-        const ctoPermissions = ctoConfig.permission;
-        // CTO should NOT have direct access to assign_engineer (uses task() to named engineers instead)
-        expect(ctoPermissions['assign_engineer']).not.toBe('allow');
-        // CTO should NOT have direct access to plan_with_team (must delegate to team-planner)
-        expect(ctoPermissions['plan_with_team']).not.toBe('allow');
-    });
-    it('browser-qa agent is registered with correct permissions', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        const { AGENT_BROWSER_QA } = await import('../src/plugin/agent-hierarchy.js');
-        const browserQa = agents[AGENT_BROWSER_QA];
-        expect(browserQa).toBeDefined();
-        expect(browserQa.permission).toBeDefined();
-        // BrowserQA should have access to claude tool
-        expect(browserQa.permission?.['claude']).toBe('allow');
-    });
-    it('browser-qa session prompt allows Playwright skill/command', async () => {
-        const { managerPromptRegistry } = await import('../src/prompts/registry.js');
-        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('Playwright skill');
-        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('real browser');
-        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('Allowed tools');
-    });
-    it('browser-qa agent prompt mentions PLAYWRIGHT_UNAVAILABLE sentinel', async () => {
-        const { managerPromptRegistry } = await import('../src/prompts/registry.js');
-        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('PLAYWRIGHT_UNAVAILABLE');
-        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('Playwright');
-    });
-    it('browser-qa agent is registered in ENGINEER_AGENT_IDS', async () => {
-        const { AGENT_BROWSER_QA, ENGINEER_AGENT_IDS } = await import('../src/plugin/agent-hierarchy.js');
-        // BrowserQA should be in the engineer IDs
-        const engineerIds = Object.values(ENGINEER_AGENT_IDS);
-        expect(engineerIds).toContain('browser-qa');
-        expect(ENGINEER_AGENT_IDS['BrowserQA']).toBe(AGENT_BROWSER_QA);
-    });
-    it('browser-qa agent config has restricted write access', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        const { AGENT_BROWSER_QA } = await import('../src/plugin/agent-hierarchy.js');
-        const browserQa = agents[AGENT_BROWSER_QA];
-        expect(browserQa).toBeDefined();
-        // Should allow claude tool (engineers can call claude)
-        expect(browserQa.permission?.['claude']).toBe('allow');
-        // Should deny most other tools
-        expect(browserQa.permission?.['read']).toBeUndefined(); // Falls back to deny
-        expect(browserQa.permission?.['write']).toBeUndefined(); // Falls back to deny
-    });
-    it('browserqa agent uses same engineer dispatch path', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        // BrowserQA should be configured as an agent
-        expect(agents['browser-qa']).toBeDefined();
-    });
-});
-describe('claude tool — engineer failure debug log', () => {
-    let tempRoot;
-    afterEach(async () => {
-        clearPluginServices();
-        if (tempRoot) {
-            await rm(tempRoot, { recursive: true, force: true });
-        }
-    });
-    it('appends an engineer_failure entry to debug.log when dispatchEngineer throws', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-failure-log-'));
-        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
-        const tools = plugin.tool;
-        const context = {
-            sessionID: 'wrapper-browserqa-fail',
-            worktree: tempRoot,
-            agent: AGENT_BROWSER_QA,
-            metadata: vi.fn(),
-        };
-        // BrowserQA in implement mode throws synchronously before running a session
-        await expect(tools['claude'].execute({ mode: 'implement', message: 'Write a feature' }, context)).rejects.toThrow('modeNotSupported');
-        const logPath = join(tempRoot, '.claude-manager', 'debug.log');
-        const content = await readFile(logPath, 'utf8');
-        const entry = JSON.parse(content.trim().split('\n')[0]);
-        expect(entry.type).toBe('engineer_failure');
-        expect(entry.engineer).toBe('BrowserQA');
-        expect(entry.mode).toBe('implement');
-        expect(entry.failureKind).toBe('modeNotSupported');
-        expect(typeof entry.message).toBe('string');
-        expect(typeof entry.ts).toBe('string');
-    });
-});

package/dist/test/context-tracker.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/context-tracker.test.js

@@ -1,130 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ContextTracker } from '../src/manager/context-tracker.js';
-describe('ContextTracker', () => {
-    it('starts with null estimates', () => {
-        const tracker = new ContextTracker();
-        const snap = tracker.snapshot();
-        expect(snap.estimatedContextPercent).toBeNull();
-        expect(snap.warningLevel).toBe('ok');
-        expect(snap.totalTurns).toBe(0);
-        expect(snap.totalCostUsd).toBe(0);
-        expect(snap.compactionCount).toBe(0);
-    });
-    it('estimates context % from input tokens (tier 1)', () => {
-        const tracker = new ContextTracker();
-        tracker.recordResult({
-            inputTokens: 100_000,
-            contextWindowSize: 200_000,
-            turns: 10,
-            totalCostUsd: 0.5,
-        });
-        const snap = tracker.snapshot();
-        expect(snap.estimatedContextPercent).toBe(50);
-        expect(snap.warningLevel).toBe('moderate');
-    });
-    it('estimates context % from cost (tier 2) when no token data', () => {
-        const tracker = new ContextTracker();
-        tracker.recordResult({
-            totalCostUsd: 0.5,
-            turns: 10,
-        });
-        const snap = tracker.snapshot();
-        // 0.5 * 130_000 = 65_000 / 200_000 = 32.5%
-        expect(snap.estimatedContextPercent).toBe(33);
-        expect(snap.warningLevel).toBe('ok');
-    });
-    it('estimates context % from turns (tier 3) when no cost or tokens', () => {
-        const tracker = new ContextTracker();
-        tracker.recordResult({ turns: 20 });
-        const snap = tracker.snapshot();
-        // 20 * 6_000 = 120_000 / 200_000 = 60%
-        expect(snap.estimatedContextPercent).toBe(60);
-        expect(snap.warningLevel).toBe('moderate');
-    });
-    it('caps at 100%', () => {
-        const tracker = new ContextTracker();
-        tracker.recordResult({
-            inputTokens: 300_000,
-            contextWindowSize: 200_000,
-        });
-        expect(tracker.estimateContextPercent()).toBe(100);
-    });
-    it('returns critical warning at 85%+', () => {
-        const tracker = new ContextTracker();
-        tracker.recordResult({
-            inputTokens: 180_000,
-            contextWindowSize: 200_000,
-        });
-        expect(tracker.warningLevel()).toBe('critical');
-    });
-    it('returns high warning at 70-85%', () => {
-        const tracker = new ContextTracker();
-        tracker.recordResult({
-            inputTokens: 150_000,
-            contextWindowSize: 200_000,
-        });
-        expect(tracker.warningLevel()).toBe('high');
-    });
-    it('detects compaction from input token drop', () => {
-        const tracker = new ContextTracker();
-        tracker.recordResult({
-            inputTokens: 150_000,
-            contextWindowSize: 200_000,
-        });
-        expect(tracker.snapshot().compactionCount).toBe(0);
-        // After compaction, input tokens drop significantly
-        tracker.recordResult({
-            inputTokens: 40_000,
-            contextWindowSize: 200_000,
-        });
-        expect(tracker.snapshot().compactionCount).toBe(1);
-        expect(tracker.estimateContextPercent()).toBe(20);
-    });
-    it('tracks explicit compaction events', () => {
-        const tracker = new ContextTracker();
-        tracker.recordCompaction();
-        tracker.recordCompaction();
-        expect(tracker.snapshot().compactionCount).toBe(2);
-    });
-    it('resets all state', () => {
-        const tracker = new ContextTracker();
-        tracker.recordResult({
-            sessionId: 'ses_123',
-            inputTokens: 100_000,
-            outputTokens: 5_000,
-            contextWindowSize: 200_000,
-            turns: 10,
-            totalCostUsd: 0.5,
-        });
-        tracker.recordCompaction();
-        tracker.reset();
-        const snap = tracker.snapshot();
-        expect(snap.sessionId).toBeNull();
-        expect(snap.totalTurns).toBe(0);
-        expect(snap.totalCostUsd).toBe(0);
-        expect(snap.latestInputTokens).toBeNull();
-        expect(snap.compactionCount).toBe(0);
-        expect(snap.estimatedContextPercent).toBeNull();
-    });
-    it('restores from persisted state', () => {
-        const tracker = new ContextTracker();
-        tracker.restore({
-            sessionId: 'ses_456',
-            totalTurns: 15,
-            totalCostUsd: 0.8,
-            estimatedContextPercent: 60,
-            contextWindowSize: 200_000,
-            latestInputTokens: 120_000,
-        });
-        const snap = tracker.snapshot();
-        expect(snap.sessionId).toBe('ses_456');
-        expect(snap.totalTurns).toBe(15);
-        expect(snap.totalCostUsd).toBe(0.8);
-        expect(snap.estimatedContextPercent).toBe(60);
-    });
-    it('accumulates session ID from results', () => {
-        const tracker = new ContextTracker();
-        tracker.recordResult({ sessionId: 'ses_abc' });
-        expect(tracker.snapshot().sessionId).toBe('ses_abc');
-    });
-});

package/dist/test/cto-active-team.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,199 +0,0 @@
-/**
- * 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, 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-'));
-        clearPluginServices();
-    });
-    afterEach(async () => {
-        clearPluginServices();
-        if (tempRoot) {
-            await rm(tempRoot, { recursive: true, force: true });
-        }
-    });
-    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: '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'];
-        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'];
-        // 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/file-run-state-store.test.d.ts

@@ -1 +0,0 @@
-export {};