@doingdev/opencode-claude-manager-plugin 0.1.47 → 0.1.50

package/dist/src/prompts/registry.js

@@ -1,52 +1,57 @@
 export const managerPromptRegistry = {
     ctoSystemPrompt: [
-        'You are the CTO. Own the outcome, not just the request.',
+        'You are a principal engineer orchestrating a team of AI-powered engineers.',
+        'You multiply your output by delegating precisely and reviewing critically.',
+        'Every prompt you send to an engineer costs time and tokens. Make each one count.',
         '',
-        'Default behavior:',
-        '- Find requirement gaps before implementation.',
-        '- Ask at most one high-leverage question when the answer changes architecture, scope, or destructive behavior.',
-        '- Use the Task tool to delegate to named engineer subagents.',
-        '- For medium or large work, spawn two engineers in parallel, compare both plans, and synthesize the strongest path.',
-        '- Reuse the same named engineer when follow-up work belongs to their prior context.',
-        '- Review diffs with `git_diff`, inspect changed files with `git_status`, and use `git_log` for recent context.',
-        '- Use the built-in `question` tool whenever you need a user decision and provide a recommendation.',
+        'Understand first:',
+        '- Ask questions. If the request is ambiguous, underspecified, or has multiple valid interpretations, ask before building. Any question whose answer would change what you build or how you build it is worth asking.',
+        '- Use the `question` tool to surface decisions with a concrete recommendation. Prefer one precise question over many vague ones.',
+        '- Identify what already exists in the codebase before creating anything new.',
+        '- Think about what could go wrong and address it upfront.',
+        '',
+        'Plan and decompose:',
+        '- Break work into independent pieces that can run in parallel. Two engineers exploring in parallel then synthesizing beats one engineer doing everything sequentially.',
+        '- For medium or large tasks, dispatch two engineers with complementary perspectives (lead plan + challenger review), then synthesize.',
+        '- Define clear success criteria before delegating. A good assignment includes: what to do, why, which files/areas are relevant, and how to verify it worked.',
         '',
-        'Team model:',
-        '- Tom, John, Maya, Sara, and Alex are persistent engineers.',
-        '- Each engineer keeps one Claude Code session for the active CTO team.',
-        '- The plugin maps engineer work back to the active CTO session automatically.',
-        '- Only one implementing engineer should modify the worktree at a time.',
+        'Delegate through the Task tool:',
+        '- Tom, John, Maya, Sara, and Alex are persistent engineers. Each keeps a Claude Code session that remembers prior turns.',
+        '- Reuse the same engineer when follow-up work belongs to their prior context.',
+        '- Only one implementing engineer should modify the worktree at a time. Parallelize exploration freely.',
+        '- Do not delegate without telling the engineer what done looks like.',
+        '',
+        'Review and iterate:',
+        '- Review diffs with `git_diff`, inspect changed files with `git_status`, and use `git_log` for recent context.',
+        '- Give specific, actionable feedback. Not "this could be better" but "this is wrong because X, fix it by doing Y."',
+        '- Trust engineer findings but verify critical claims. Do not re-examine every file they already reviewed.',
+        '- If something fails, figure out what you missed in the assignment, not just what the engineer got wrong.',
         '',
-        'Do not:',
-        '- Do not edit files or run bash directly.',
-        '- Do not expose session babysitting to the user.',
-        '- Do not delegate without clear success criteria.',
+        'Constraints:',
+        '- Do not edit files or run bash directly. Engineers do the hands-on work.',
+        '- Do not read files or grep when an engineer can answer the question faster.',
+        '- Communicate proactively. If the plan changes or you discover something unexpected, tell the user.',
     ].join('\n'),
     engineerAgentPrompt: [
-        'You are a named engineer working for the CTO.',
-        'Use the `claude` tool for all real work.',
-        'The tool remembers prior turns for this engineer inside the active CTO team.',
-        'Your prior wrapper context is also reloaded automatically so you can frame Claude requests better over time.',
-        'Choose the mode that matches the assignment: explore, implement, or verify.',
-        'Return the tool result directly unless a short clarification is truly required.',
+        "You are a named engineer on the CTO's team.",
+        'Your job is to run assignments through the `claude` tool, which connects to a persistent Claude Code session that remembers your prior turns.',
+        '',
+        'Frame each assignment well:',
+        '- Include relevant context, file paths, and constraints the CTO provided.',
+        '- Specify the work mode: explore (investigate, no edits), implement (make changes and verify), or verify (run checks and report).',
+        "- If the CTO's assignment is unclear, ask for clarification before sending it to Claude Code.",
+        '',
+        'Your wrapper context from prior turns is reloaded automatically. Use it to avoid repeating work or re-explaining context that Claude Code already knows.',
+        "Return the tool result directly. Add your own commentary only when something was unexpected or needs the CTO's attention.",
     ].join('\n'),
     engineerSessionPrompt: [
         'You are an expert software engineer working inside Claude Code.',
-        'Execute directly. No preamble.',
-        'Follow repository conventions and relevant project instructions.',
-        'Use the minimum necessary investigation before acting.',
-        'Verify your own work before reporting done.',
-        'Report blockers clearly and include exact command output on failure.',
+        'Start with the smallest investigation that resolves the key uncertainty, then act.',
+        'Follow repository conventions, AGENTS.md, and any project-level instructions.',
+        'Verify your own work before reporting done. Run the most relevant check (test, lint, typecheck, build) for what you changed.',
+        'Report blockers immediately with exact error output. Do not retry silently more than once.',
         'Do not run git commit, git push, git reset, git checkout, or git stash.',
     ].join('\n'),
-    modePrefixes: {
-        plan: [
-            '[PLAN MODE] Read-only.',
-            'Do not create or edit files.',
-            'Analyze the codebase and return the plan inline.',
-        ].join(' '),
-        free: '',
-    },
     contextWarnings: {
         moderate: 'Engineer context is getting full ({percent}% estimated). Reuse is still fine, but keep the next prompt focused.',
         high: 'Engineer context is heavy ({percent}% estimated, {turns} turns, ${cost}). Prefer a narrowly scoped follow-up or internal compaction.',

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

@@ -7,7 +7,10 @@ export declare class TeamStateStore {
     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/src/state/team-state-store.js

@@ -31,12 +31,15 @@ export class TeamStateStore {
         const directory = this.getTeamsDirectory(cwd);
         try {
             const entries = await fs.readdir(directory);
-            const teams = await Promise.all(entries
+            const results = await Promise.allSettled(entries
                 .filter((entry) => entry.endsWith('.json'))
                 .map(async (entry) => {
                 const content = await fs.readFile(path.join(directory, entry), 'utf8');
                 return JSON.parse(content);
             }));
+            const teams = results
+                .filter((r) => r.status === 'fulfilled')
+                .map((r) => r.value);
             return teams.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
         }
         catch (error) {
@@ -59,9 +62,31 @@ export class TeamStateStore {
             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');
     }

package/dist/src/team/roster.js

@@ -19,6 +19,7 @@ export function createEmptyEngineerRecord(name) {
         wrapperSessionId: null,
         claudeSessionId: null,
         busy: false,
+        busySince: null,
         lastMode: null,
         lastTaskSummary: null,
         lastUsedAt: null,

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

@@ -2,10 +2,6 @@ export interface ManagerPromptRegistry {
     ctoSystemPrompt: string;
     engineerAgentPrompt: string;
     engineerSessionPrompt: string;
-    modePrefixes: {
-        plan: string;
-        free: string;
-    };
     contextWarnings: {
         moderate: string;
         high: string;
@@ -110,12 +106,21 @@ export interface TeamEngineerRecord {
     wrapperSessionId: string | null;
     claudeSessionId: string | null;
     busy: boolean;
+    busySince: string | null;
     lastMode: EngineerWorkMode | null;
     lastTaskSummary: string | null;
     lastUsedAt: string | null;
     wrapperHistory: WrapperHistoryEntry[];
     context: SessionContextSnapshot;
 }
+export type EngineerFailureKind = 'sdkError' | 'contextExhausted' | 'toolDenied' | 'aborted' | 'engineerBusy' | 'unknown';
+export interface EngineerFailureResult {
+    teamId: string;
+    engineer: EngineerName;
+    mode: EngineerWorkMode;
+    failureKind: EngineerFailureKind;
+    message: string;
+}
 export interface TeamRecord {
     id: string;
     cwd: string;
@@ -163,51 +168,6 @@ export interface GitOperationResult {
     output: string;
     error?: string;
 }
-export type PersistentRunStatus = 'running' | 'completed' | 'failed';
-export interface PersistentRunMessageRecord {
-    timestamp: string;
-    direction: 'sent' | 'received';
-    text: string;
-    turns?: number;
-    totalCostUsd?: number;
-    inputTokens?: number;
-    outputTokens?: number;
-}
-export interface PersistentRunActionRecord {
-    timestamp: string;
-    type: 'git_diff' | 'git_commit' | 'git_reset' | 'git_status' | 'git_log' | 'compact' | 'clear';
-    result: string;
-}
-export interface PersistentRunRecord {
-    id: string;
-    cwd: string;
-    task: string;
-    status: PersistentRunStatus;
-    createdAt: string;
-    updatedAt: string;
-    sessionId: string | null;
-    sessionHistory: string[];
-    messages: PersistentRunMessageRecord[];
-    actions: PersistentRunActionRecord[];
-    commits: string[];
-    context: SessionContextSnapshot;
-    finalSummary?: string;
-}
-export interface PersistentRunResult {
-    run: PersistentRunRecord;
-}
-export interface LiveTailEvent {
-    type: 'line' | 'error' | 'end';
-    sessionId: string;
-    data?: unknown;
-    rawLine?: string;
-    error?: string;
-}
-export interface ToolOutputPreview {
-    toolUseId: string;
-    content: string;
-    isError: boolean;
-}
 export interface DiscoveredClaudeFile {
     /** Relative path from the project root (forward slashes, deterministic order). */
     relativePath: string;

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

@@ -7,7 +7,10 @@ export declare class TeamStateStore {
     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

@@ -31,12 +31,15 @@ export class TeamStateStore {
         const directory = this.getTeamsDirectory(cwd);
         try {
             const entries = await fs.readdir(directory);
-            const teams = await Promise.all(entries
+            const results = await Promise.allSettled(entries
                 .filter((entry) => entry.endsWith('.json'))
                 .map(async (entry) => {
                 const content = await fs.readFile(path.join(directory, entry), 'utf8');
                 return JSON.parse(content);
             }));
+            const teams = results
+                .filter((r) => r.status === 'fulfilled')
+                .map((r) => r.value);
             return teams.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
         }
         catch (error) {
@@ -59,9 +62,31 @@ export class TeamStateStore {
             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');
     }

package/dist/team/roster.js

@@ -19,6 +19,7 @@ export function createEmptyEngineerRecord(name) {
         wrapperSessionId: null,
         claudeSessionId: null,
         busy: false,
+        busySince: null,
         lastMode: null,
         lastTaskSummary: null,
         lastUsedAt: null,

package/dist/test/claude-agent-sdk-adapter.test.js

@@ -253,17 +253,6 @@ describe('ClaudeAgentSdkAdapter', () => {
         });
         expect(result.events.map((event) => event.type)).toEqual(['init', 'result']);
     });
-    it('probes supported commands, agents, and models', async () => {
-        const adapter = new ClaudeAgentSdkAdapter({
-            query: () => createFakeQuery([]),
-            listSessions: async () => [],
-            getSessionMessages: async () => [],
-        });
-        const capabilities = await adapter.probeCapabilities('/tmp/project');
-        expect(capabilities.commands[0]).toMatchObject({ name: 'review' });
-        expect(capabilities.agents[0]).toMatchObject({ name: 'researcher' });
-        expect(capabilities.models).toEqual(['claude-sonnet-4-5']);
-    });
     it('defaults permissionMode to acceptEdits when omitted', async () => {
         let capturedPermissionMode;
         const adapter = new ClaudeAgentSdkAdapter({

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

@@ -26,6 +26,8 @@ describe('ClaudeManagerPlugin', () => {
             todoread: 'allow',
             question: 'allow',
             team_status: 'allow',
+            plan_with_team: 'allow',
+            reset_engineer: 'allow',
             git_diff: 'allow',
             git_commit: 'allow',
             git_reset: 'allow',
@@ -61,6 +63,8 @@ describe('ClaudeManagerPlugin', () => {
                 claude: 'allow',
                 git_diff: 'deny',
                 git_commit: 'deny',
+                plan_with_team: 'deny',
+                reset_engineer: 'deny',
             });
             expect(agent.permission).not.toHaveProperty('read');
             expect(agent.permission).not.toHaveProperty('grep');
@@ -73,8 +77,9 @@ describe('ClaudeManagerPlugin', () => {
         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();
-        expect(tools['plan_with_team']).toBeUndefined();
     });
     it('claude tool requires mode and message and supports optional model', async () => {
         const plugin = await ClaudeManagerPlugin({

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

@@ -122,14 +122,6 @@ describe('ContextTracker', () => {
         expect(snap.totalCostUsd).toBe(0.8);
         expect(snap.estimatedContextPercent).toBe(60);
     });
-    it('checks token threshold', () => {
-        const tracker = new ContextTracker();
-        expect(tracker.isAboveTokenThreshold()).toBe(false);
-        tracker.recordResult({ inputTokens: 150_000 });
-        expect(tracker.isAboveTokenThreshold(200_000)).toBe(false);
-        tracker.recordResult({ inputTokens: 210_000 });
-        expect(tracker.isAboveTokenThreshold(200_000)).toBe(true);
-    });
     it('accumulates session ID from results', () => {
         const tracker = new ContextTracker();
         tracker.recordResult({ sessionId: 'ses_abc' });

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

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

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

@@ -0,0 +1,52 @@
+import { afterEach, beforeEach, describe, expect, it } 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', () => {
+    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('persists the active team on the first CTO message', 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');
+        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');
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        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');
+    });
+});

package/dist/test/git-operations.test.js

@@ -59,27 +59,6 @@ describe('GitOperations', () => {
         const diff = await git.diff();
         expect(diff.hasDiff).toBe(false);
     });
-    it('returns current branch', async () => {
-        const dir = await createTestRepo();
-        const git = new GitOperations(dir);
-        const branch = await git.currentBranch();
-        // Could be 'main' or 'master' depending on git config
-        expect(branch.length).toBeGreaterThan(0);
-    });
-    it('returns recent commits', async () => {
-        const dir = await createTestRepo();
-        const git = new GitOperations(dir);
-        const log = await git.recentCommits(1);
-        expect(log).toContain('initial');
-    });
-    it('returns diffStat output', async () => {
-        const dir = await createTestRepo();
-        await writeFile(join(dir, 'README.md'), '# Changed\n');
-        const git = new GitOperations(dir);
-        const stat = await git.diffStat();
-        expect(stat).toContain('README.md');
-        expect(stat).toContain('changed');
-    });
     it('handles commit failure on clean repo', async () => {
         const dir = await createTestRepo();
         const git = new GitOperations(dir);