@doingdev/opencode-claude-manager-plugin 0.1.46 → 0.1.49

package/dist/src/types/contracts.d.ts

@@ -1,7 +1,6 @@
 export interface ManagerPromptRegistry {
     ctoSystemPrompt: string;
-    engineerPlanPrompt: string;
-    engineerBuildPrompt: string;
+    engineerAgentPrompt: string;
     engineerSessionPrompt: string;
     modePrefixes: {
         plan: string;
@@ -14,6 +13,15 @@ export interface ManagerPromptRegistry {
     };
 }
 export type SessionMode = 'plan' | 'free';
+export declare const DEFAULT_ENGINEER_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
+export type EngineerName = (typeof DEFAULT_ENGINEER_NAMES)[number];
+export type EngineerWorkMode = 'explore' | 'implement' | 'verify';
+export interface WrapperHistoryEntry {
+    timestamp: string;
+    type: 'assignment' | 'result';
+    mode?: EngineerWorkMode;
+    text: string;
+}
 export interface ClaudeCommandMetadata {
     name: string;
     description: string;
@@ -97,6 +105,50 @@ export interface SessionContextSnapshot {
     warningLevel: ContextWarningLevel;
     compactionCount: number;
 }
+export interface TeamEngineerRecord {
+    name: EngineerName;
+    wrapperSessionId: string | null;
+    claudeSessionId: string | null;
+    busy: boolean;
+    lastMode: EngineerWorkMode | null;
+    lastTaskSummary: string | null;
+    lastUsedAt: string | null;
+    wrapperHistory: WrapperHistoryEntry[];
+    context: SessionContextSnapshot;
+}
+export interface TeamRecord {
+    id: string;
+    cwd: string;
+    createdAt: string;
+    updatedAt: string;
+    engineers: TeamEngineerRecord[];
+}
+export interface EngineerTaskResult {
+    teamId: string;
+    engineer: EngineerName;
+    mode: EngineerWorkMode;
+    sessionId?: string;
+    finalText: string;
+    turns?: number;
+    totalCostUsd?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    contextWindowSize?: number;
+    context: SessionContextSnapshot;
+}
+export interface PlanDraft extends EngineerTaskResult {
+    request: string;
+}
+export interface SynthesizedPlanResult {
+    teamId: string;
+    request: string;
+    leadEngineer: EngineerName;
+    challengerEngineer: EngineerName;
+    drafts: [PlanDraft, PlanDraft];
+    synthesis: string;
+    recommendedQuestion: string | null;
+    recommendedAnswer: string | null;
+}
 export interface GitDiffResult {
     hasDiff: boolean;
     diffText: string;
@@ -111,16 +163,6 @@ export interface GitOperationResult {
     output: string;
     error?: string;
 }
-export interface ActiveSessionState {
-    sessionId: string;
-    cwd: string;
-    startedAt: string;
-    totalTurns: number;
-    totalCostUsd: number;
-    estimatedContextPercent: number | null;
-    contextWindowSize: number | null;
-    latestInputTokens: number | null;
-}
 export type PersistentRunStatus = 'running' | 'completed' | 'failed';
 export interface PersistentRunMessageRecord {
     timestamp: string;
@@ -133,7 +175,7 @@ export interface PersistentRunMessageRecord {
 }
 export interface PersistentRunActionRecord {
     timestamp: string;
-    type: 'git_diff' | 'git_commit' | 'git_reset' | 'compact' | 'clear';
+    type: 'git_diff' | 'git_commit' | 'git_reset' | 'git_status' | 'git_log' | 'compact' | 'clear';
     result: string;
 }
 export interface PersistentRunRecord {

package/dist/src/types/contracts.js

@@ -1 +1 @@
-export {};
+export const DEFAULT_ENGINEER_NAMES = ['Tom', 'John', 'Maya', 'Sara', 'Alex'];

package/dist/state/team-state-store.d.ts

@@ -0,0 +1,17 @@
+import type { TeamRecord } from '../types/contracts.js';
+export declare class TeamStateStore {
+    private readonly baseDirectoryName;
+    private readonly writeQueues;
+    constructor(baseDirectoryName?: string);
+    saveTeam(team: TeamRecord): Promise<void>;
+    getTeam(cwd: string, teamId: string): Promise<TeamRecord | null>;
+    listTeams(cwd: string): Promise<TeamRecord[]>;
+    updateTeam(cwd: string, teamId: string, update: (team: TeamRecord) => TeamRecord): Promise<TeamRecord>;
+    getActiveTeam(cwd: string): Promise<string | null>;
+    setActiveTeam(cwd: string, teamId: string): Promise<void>;
+    private getTeamKey;
+    private getActiveTeamPath;
+    private getTeamsDirectory;
+    private getTeamPath;
+    private enqueueWrite;
+}

package/dist/state/team-state-store.js

@@ -0,0 +1,107 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { isFileNotFoundError, writeJsonAtomically } from '../util/fs-helpers.js';
+export class TeamStateStore {
+    baseDirectoryName;
+    writeQueues = new Map();
+    constructor(baseDirectoryName = '.claude-manager') {
+        this.baseDirectoryName = baseDirectoryName;
+    }
+    async saveTeam(team) {
+        await this.enqueueWrite(this.getTeamKey(team.cwd, team.id), async () => {
+            const filePath = this.getTeamPath(team.cwd, team.id);
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await writeJsonAtomically(filePath, team);
+        });
+    }
+    async getTeam(cwd, teamId) {
+        const filePath = this.getTeamPath(cwd, teamId);
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async listTeams(cwd) {
+        const directory = this.getTeamsDirectory(cwd);
+        try {
+            const entries = await fs.readdir(directory);
+            const teams = await Promise.all(entries
+                .filter((entry) => entry.endsWith('.json'))
+                .map(async (entry) => {
+                const content = await fs.readFile(path.join(directory, entry), 'utf8');
+                return JSON.parse(content);
+            }));
+            return teams.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async updateTeam(cwd, teamId, update) {
+        return this.enqueueWrite(this.getTeamKey(cwd, teamId), async () => {
+            const existing = await this.getTeam(cwd, teamId);
+            if (!existing) {
+                throw new Error(`Team ${teamId} does not exist.`);
+            }
+            const updated = update(existing);
+            const filePath = this.getTeamPath(cwd, teamId);
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await writeJsonAtomically(filePath, updated);
+            return updated;
+        });
+    }
+    async getActiveTeam(cwd) {
+        const filePath = this.getActiveTeamPath(cwd);
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            const parsed = JSON.parse(content);
+            return parsed.teamId ?? null;
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async setActiveTeam(cwd, teamId) {
+        const filePath = this.getActiveTeamPath(cwd);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await writeJsonAtomically(filePath, { teamId });
+    }
+    getTeamKey(cwd, teamId) {
+        return `${cwd}:${teamId}`;
+    }
+    getActiveTeamPath(cwd) {
+        return path.join(cwd, this.baseDirectoryName, 'active-team.json');
+    }
+    getTeamsDirectory(cwd) {
+        return path.join(cwd, this.baseDirectoryName, 'teams');
+    }
+    getTeamPath(cwd, teamId) {
+        return path.join(this.getTeamsDirectory(cwd), `${teamId}.json`);
+    }
+    async enqueueWrite(key, operation) {
+        const previous = this.writeQueues.get(key) ?? Promise.resolve();
+        const resultPromise = previous.catch(() => undefined).then(operation);
+        const settledPromise = resultPromise.then(() => undefined, () => undefined);
+        this.writeQueues.set(key, settledPromise);
+        try {
+            return await resultPromise;
+        }
+        finally {
+            if (this.writeQueues.get(key) === settledPromise) {
+                this.writeQueues.delete(key);
+            }
+        }
+    }
+}

package/dist/team/roster.d.ts

@@ -0,0 +1,5 @@
+import { type EngineerName, type TeamEngineerRecord, type TeamRecord } from '../types/contracts.js';
+export declare const TEAM_ENGINEERS: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
+export declare function isEngineerName(value: string): value is EngineerName;
+export declare function createEmptyTeamRecord(teamId: string, cwd: string): TeamRecord;
+export declare function createEmptyEngineerRecord(name: EngineerName): TeamEngineerRecord;

package/dist/team/roster.js

@@ -0,0 +1,38 @@
+import { DEFAULT_ENGINEER_NAMES, } from '../types/contracts.js';
+export const TEAM_ENGINEERS = DEFAULT_ENGINEER_NAMES;
+export function isEngineerName(value) {
+    return TEAM_ENGINEERS.includes(value);
+}
+export function createEmptyTeamRecord(teamId, cwd) {
+    const timestamp = new Date().toISOString();
+    return {
+        id: teamId,
+        cwd,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        engineers: TEAM_ENGINEERS.map((name) => createEmptyEngineerRecord(name)),
+    };
+}
+export function createEmptyEngineerRecord(name) {
+    return {
+        name,
+        wrapperSessionId: null,
+        claudeSessionId: null,
+        busy: false,
+        lastMode: null,
+        lastTaskSummary: null,
+        lastUsedAt: null,
+        wrapperHistory: [],
+        context: {
+            sessionId: null,
+            totalTurns: 0,
+            totalCostUsd: 0,
+            latestInputTokens: null,
+            latestOutputTokens: null,
+            contextWindowSize: null,
+            estimatedContextPercent: null,
+            warningLevel: 'ok',
+            compactionCount: 0,
+        },
+    };
+}

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

@@ -1,22 +1,8 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
+import { describe, expect, it } from 'vitest';
 import { ClaudeManagerPlugin } from '../src/plugin/claude-manager.plugin.js';
-import { AGENT_CTO, AGENT_ENGINEER_BUILD, AGENT_ENGINEER_PLAN, ALL_RESTRICTED_TOOL_IDS, } from '../src/plugin/agent-hierarchy.js';
-import { managerPromptRegistry } from '../src/prompts/registry.js';
-/** All engineer tools — none belong to CTO. */
-const ENGINEER_TOOL_IDS = [
-    'explore',
-    'implement',
-    'compact_context',
-    'clear_session',
-    'session_health',
-    'list_transcripts',
-    'list_history',
-];
+import { AGENT_CTO, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from '../src/plugin/agent-hierarchy.js';
 describe('ClaudeManagerPlugin', () => {
-    it('configures cto with git and approval tools but denies all engineer tools', async () => {
+    it('configures CTO with orchestration tools and question access', async () => {
         const plugin = await ClaudeManagerPlugin({
             worktree: '/tmp/project',
         });
@@ -26,66 +12,12 @@ describe('ClaudeManagerPlugin', () => {
         const cto = agents[AGENT_CTO];
         expect(cto).toBeDefined();
         expect(cto.mode).toBe('primary');
-        // CTO should have read-only codebase and utility tools
         expect(cto.permission).toMatchObject({
             '*': 'deny',
             read: 'allow',
             grep: 'allow',
             glob: 'allow',
-            codesearch: 'allow',
-            webfetch: 'allow',
-            websearch: 'allow',
-            todowrite: 'allow',
-            todoread: 'allow',
-            question: 'allow',
-        });
-        // CTO should have git tools allowed
-        expect(cto.permission).toHaveProperty('git_diff', 'allow');
-        expect(cto.permission).toHaveProperty('git_commit', 'allow');
-        expect(cto.permission).toHaveProperty('git_reset', 'allow');
-        // CTO should have approval tools allowed
-        expect(cto.permission).toHaveProperty('approval_policy', 'allow');
-        expect(cto.permission).toHaveProperty('approval_decisions', 'allow');
-        expect(cto.permission).toHaveProperty('approval_update', 'allow');
-        // CTO should have ALL engineer tools DENIED
-        for (const toolId of ENGINEER_TOOL_IDS) {
-            expect(cto.permission).toHaveProperty(toolId, 'deny');
-        }
-        // CTO should have task permission to spawn engineer subagents
-        expect(cto.permission).toHaveProperty('task');
-        expect(cto.permission['task']).toMatchObject({
-            '*': 'deny',
-            engineer_plan: 'allow',
-            engineer_build: 'allow',
-        });
-        // CTO should NOT have bash or edit
-        expect(cto.permission).not.toHaveProperty('bash');
-        expect(cto.permission).not.toHaveProperty('edit');
-    });
-    it('configures engineer_plan wrapper with only plan-mode send tool', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        const engineerPlan = agents[AGENT_ENGINEER_PLAN];
-        expect(engineerPlan).toBeDefined();
-        expect(engineerPlan.mode).toBe('subagent');
-        // Should allow explore and shared session tools
-        expect(engineerPlan.permission).toHaveProperty('explore', 'allow');
-        expect(engineerPlan.permission).toHaveProperty('compact_context', 'allow');
-        expect(engineerPlan.permission).toHaveProperty('session_health', 'allow');
-        // Should DENY the build-mode send
-        expect(engineerPlan.permission).toHaveProperty('implement', 'deny');
-        // Should deny git and approval tools
-        expect(engineerPlan.permission).toHaveProperty('git_diff', 'deny');
-        expect(engineerPlan.permission).toHaveProperty('approval_policy', 'deny');
-        // Should have read-only investigation tools
-        expect(engineerPlan.permission).toMatchObject({
-            read: 'allow',
-            grep: 'allow',
-            glob: 'allow',
+            list: 'allow',
             codesearch: 'allow',
             webfetch: 'allow',
             websearch: 'allow',
@@ -93,239 +25,82 @@ describe('ClaudeManagerPlugin', () => {
             todowrite: 'allow',
             todoread: 'allow',
             question: 'allow',
+            team_status: 'allow',
+            git_diff: 'allow',
+            git_commit: 'allow',
+            git_reset: 'allow',
+            git_status: 'allow',
+            git_log: 'allow',
+            claude: 'deny',
+        });
+        expect(cto.permission.task).toEqual({
+            '*': 'deny',
+            tom: 'allow',
+            john: 'allow',
+            maya: 'allow',
+            sara: 'allow',
+            alex: 'allow',
         });
     });
-    it('configures engineer_build wrapper with only build-mode send tool', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        const engineerBuild = agents[AGENT_ENGINEER_BUILD];
-        expect(engineerBuild).toBeDefined();
-        expect(engineerBuild.mode).toBe('subagent');
-        // Should allow implement and shared session tools
-        expect(engineerBuild.permission).toHaveProperty('implement', 'allow');
-        expect(engineerBuild.permission).toHaveProperty('compact_context', 'allow');
-        expect(engineerBuild.permission).toHaveProperty('session_health', 'allow');
-        // Should DENY the plan-mode send
-        expect(engineerBuild.permission).toHaveProperty('explore', 'deny');
-        // Should deny git and approval tools
-        expect(engineerBuild.permission).toHaveProperty('git_diff', 'deny');
-        expect(engineerBuild.permission).toHaveProperty('approval_policy', 'deny');
-        // Should have read-only investigation tools
-        expect(engineerBuild.permission).toMatchObject({
-            read: 'allow',
-            grep: 'allow',
-            glob: 'allow',
-            codesearch: 'allow',
-            webfetch: 'allow',
-            websearch: 'allow',
-            lsp: 'allow',
-            todowrite: 'allow',
-            todoread: 'allow',
-            question: 'allow',
-        });
-    });
-    it('CTO description reflects delegation-first behavior', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        expect(agents[AGENT_CTO].description).toContain('Delegates by default');
-        expect(agents[AGENT_CTO].description).toContain('minimal spot-checks');
-    });
-    it('engineer_plan description reflects thin wrapper dispatching to Claude Code', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        expect(agents[AGENT_ENGINEER_PLAN].description).toContain('Thin high-judgment wrapper');
-        expect(agents[AGENT_ENGINEER_PLAN].description).toContain('dispatches to Claude Code');
-    });
-    it('engineer_build description reflects thin wrapper dispatching to Claude Code', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        expect(agents[AGENT_ENGINEER_BUILD].description).toContain('Thin high-judgment wrapper');
-        expect(agents[AGENT_ENGINEER_BUILD].description).toContain('dispatches to Claude Code');
-    });
-    it('explore tool description marks it as preferred first step', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const tools = plugin.tool;
-        expect(tools['explore'].description).toContain('Preferred first step before implementation');
-    });
-    it('implement tool description marks it for code changes', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const tools = plugin.tool;
-        expect(tools['implement'].description).toContain('Implement code changes');
-    });
-    it('does not register old agent names', async () => {
+    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 ?? {});
-        expect(agents).not.toHaveProperty('claude-manager');
-        expect(agents).not.toHaveProperty('claude-manager-research');
-        expect(agents).not.toHaveProperty('claude-cto');
-        expect(agents).not.toHaveProperty('manager');
-    });
-    it('does not register any slash commands', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        expect(config).not.toHaveProperty('command');
+        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',
+            });
+            expect(agent.permission).not.toHaveProperty('read');
+            expect(agent.permission).not.toHaveProperty('grep');
+        }
     });
-    it('exposes freshSession argument on explore defaulting to false', async () => {
+    it('registers the named engineer bridge and team status tools', async () => {
         const plugin = await ClaudeManagerPlugin({
             worktree: '/tmp/project',
         });
         const tools = plugin.tool;
-        const exploreTool = tools['explore'];
-        expect(exploreTool).toBeDefined();
-        const freshSchema = exploreTool.args.freshSession;
-        expect(freshSchema).toBeDefined();
-        expect(freshSchema.parse(undefined)).toBe(false);
-        expect(freshSchema.safeParse(true).success).toBe(true);
-        expect(freshSchema.safeParse(false).success).toBe(true);
+        expect(tools['claude']).toBeDefined();
+        expect(tools['team_status']).toBeDefined();
+        expect(tools['assign_engineer']).toBeUndefined();
+        expect(tools['plan_with_team']).toBeUndefined();
     });
-    it('exposes model argument as enum of allowed models on implement', async () => {
+    it('claude tool requires mode and message and supports optional model', async () => {
         const plugin = await ClaudeManagerPlugin({
             worktree: '/tmp/project',
         });
         const tools = plugin.tool;
-        const implementTool = tools['implement'];
-        const modelSchema = implementTool.args.model;
-        expect(modelSchema).toBeDefined();
+        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('claude-sonnet-4-5').success).toBe(true);
         expect(modelSchema.safeParse(undefined).success).toBe(true);
         expect(modelSchema.safeParse('claude-haiku-4-5').success).toBe(false);
-        expect(modelSchema.safeParse('anything-else').success).toBe(false);
     });
-    it('exposes effort argument as enum defaulting to high on explore', async () => {
+    it('exposes hooks for CTO team tracking and wrapper memory injection', async () => {
         const plugin = await ClaudeManagerPlugin({
             worktree: '/tmp/project',
         });
-        const tools = plugin.tool;
-        const exploreTool = tools['explore'];
-        const effortSchema = exploreTool.args.effort;
-        expect(effortSchema).toBeDefined();
-        expect(effortSchema.safeParse('low').success).toBe(true);
-        expect(effortSchema.safeParse('medium').success).toBe(true);
-        expect(effortSchema.safeParse('high').success).toBe(true);
-        expect(effortSchema.safeParse('max').success).toBe(true);
-        expect(effortSchema.parse(undefined)).toBe('high');
-        expect(effortSchema.safeParse('turbo').success).toBe(false);
-    });
-    it('exposes compact_context tool', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const tools = plugin.tool;
-        expect(tools['compact_context']).toBeDefined();
-    });
-    it('exposes all tool IDs matching the hierarchy constants', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const tools = plugin.tool;
-        for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
-            expect(tools).toHaveProperty(toolId);
-        }
-    });
-    it('does not expose old claude_manager_* tool IDs', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const tools = plugin.tool;
-        const oldToolIds = [
-            'claude_manager_send',
-            'claude_manager_compact',
-            'claude_manager_git_diff',
-            'claude_manager_git_commit',
-            'claude_manager_git_reset',
-            'claude_manager_clear',
-            'claude_manager_status',
-            'claude_manager_metadata',
-            'claude_manager_sessions',
-            'claude_manager_runs',
-            'claude_manager_approval_policy',
-            'claude_manager_approval_decisions',
-            'claude_manager_approval_update',
-        ];
-        for (const oldId of oldToolIds) {
-            expect(tools).not.toHaveProperty(oldId);
-        }
-    });
-    describe('wrapper prompts include discovered Claude files', () => {
-        const tmpDirs = [];
-        async function makeTmp() {
-            const d = await mkdtemp(join(tmpdir(), 'plugin-test-'));
-            tmpDirs.push(d);
-            return d;
-        }
-        afterEach(async () => {
-            for (const d of tmpDirs) {
-                await rm(d, { recursive: true, force: true });
-            }
-            tmpDirs.length = 0;
-        });
-        it('injects project Claude files into engineer plan/build wrapper prompts', async () => {
-            const worktree = await makeTmp();
-            await writeFile(join(worktree, 'CLAUDE.md'), 'Use pnpm. No default exports.');
-            await mkdir(join(worktree, '.claude'), { recursive: true });
-            await writeFile(join(worktree, '.claude/settings.md'), 'Extra settings');
-            const plugin = await ClaudeManagerPlugin({ worktree });
-            const config = {};
-            await plugin.config?.(config);
-            const agents = config.agent;
-            const planPrompt = agents[AGENT_ENGINEER_PLAN].prompt;
-            const buildPrompt = agents[AGENT_ENGINEER_BUILD].prompt;
-            // Both wrapper prompts should contain discovered file content
-            expect(planPrompt).toContain('## Project Claude Files');
-            expect(planPrompt).toContain('### CLAUDE.md');
-            expect(planPrompt).toContain('Use pnpm. No default exports.');
-            expect(planPrompt).toContain('### .claude/settings.md');
-            expect(planPrompt).toContain('Extra settings');
-            expect(buildPrompt).toContain('## Project Claude Files');
-            expect(buildPrompt).toContain('### CLAUDE.md');
-            expect(buildPrompt).toContain('Use pnpm. No default exports.');
-        });
-        it('CTO prompt stays unchanged regardless of Claude files', async () => {
-            const worktree = await makeTmp();
-            await writeFile(join(worktree, 'CLAUDE.md'), 'project rules');
-            const plugin = await ClaudeManagerPlugin({ worktree });
-            const config = {};
-            await plugin.config?.(config);
-            const agents = config.agent;
-            expect(agents[AGENT_CTO].prompt).toBe(managerPromptRegistry.ctoSystemPrompt);
-        });
-        it('wrapper prompts equal base when no Claude files exist', async () => {
-            const worktree = await makeTmp();
-            const plugin = await ClaudeManagerPlugin({ worktree });
-            const config = {};
-            await plugin.config?.(config);
-            const agents = config.agent;
-            expect(agents[AGENT_ENGINEER_PLAN].prompt).toBe(managerPromptRegistry.engineerPlanPrompt);
-            expect(agents[AGENT_ENGINEER_BUILD].prompt).toBe(managerPromptRegistry.engineerBuildPrompt);
-        });
+        expect(plugin['chat.message']).toBeTypeOf('function');
+        expect(plugin['experimental.chat.system.transform']).toBeTypeOf('function');
     });
 });

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

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