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

package/dist/src/manager/team-orchestrator.js

@@ -1,5 +1,6 @@
 import { createEmptyEngineerRecord, createEmptyTeamRecord } from '../team/roster.js';
 import { ContextTracker } from './context-tracker.js';
+const BUSY_LEASE_MS = 15 * 60 * 1000;
 export class TeamOrchestrator {
     sessions;
     teamStore;
@@ -77,6 +78,16 @@ export class TeamOrchestrator {
         }
         return null;
     }
+    async resetEngineer(cwd, teamId, engineer, options) {
+        await this.updateEngineer(cwd, teamId, engineer, (entry) => ({
+            ...entry,
+            busy: false,
+            busySince: null,
+            claudeSessionId: options?.clearSession ? null : entry.claudeSessionId,
+            wrapperHistory: options?.clearHistory ? [] : entry.wrapperHistory,
+            context: options?.clearSession ? createEmptyEngineerRecord(engineer).context : entry.context,
+        }));
+    }
     async dispatchEngineer(input) {
         const team = await this.getOrCreateTeam(input.cwd, input.teamId);
         const engineerState = this.getEngineerState(team, input.engineer);
@@ -124,6 +135,7 @@ export class TeamOrchestrator {
                 ...entry,
                 claudeSessionId: result.sessionId ?? engineerState.claudeSessionId,
                 busy: false,
+                busySince: null,
                 lastMode: input.mode,
                 lastTaskSummary: summarizeMessage(input.message),
                 lastUsedAt: new Date().toISOString(),
@@ -147,10 +159,38 @@ export class TeamOrchestrator {
             await this.updateEngineer(input.cwd, input.teamId, input.engineer, (engineer) => ({
                 ...engineer,
                 busy: false,
+                busySince: null,
             }));
             throw error;
         }
     }
+    static classifyError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        let failureKind = 'unknown';
+        if (message.includes('already working on another assignment')) {
+            failureKind = 'engineerBusy';
+        }
+        else if (message.includes('context') || message.includes('token limit')) {
+            failureKind = 'contextExhausted';
+        }
+        else if (message.includes('denied') || message.includes('not allowed')) {
+            failureKind = 'toolDenied';
+        }
+        else if (message.includes('abort') || message.includes('cancel')) {
+            failureKind = 'aborted';
+        }
+        else {
+            failureKind = 'sdkError';
+        }
+        return {
+            teamId: '',
+            engineer: 'Tom',
+            mode: 'explore',
+            failureKind,
+            message,
+            cause: error,
+        };
+    }
     async planWithTeam(input) {
         if (input.leadEngineer === input.challengerEngineer) {
             throw new Error('Choose two different engineers for plan synthesis.');
@@ -221,15 +261,21 @@ export class TeamOrchestrator {
             const normalized = this.normalizeTeamRecord(team);
             const engineer = this.getEngineerState(normalized, engineerName);
             if (engineer.busy) {
-                throw new Error(`${engineerName} is already working on another assignment.`);
+                const leaseExpired = engineer.busySince !== null &&
+                    Date.now() - new Date(engineer.busySince).getTime() > BUSY_LEASE_MS;
+                if (!leaseExpired) {
+                    throw new Error(`${engineerName} is already working on another assignment.`);
+                }
             }
+            const now = new Date().toISOString();
             return {
                 ...normalized,
-                updatedAt: new Date().toISOString(),
+                updatedAt: now,
                 engineers: normalized.engineers.map((entry) => entry.name === engineerName
                     ? {
                         ...entry,
                         busy: true,
+                        busySince: now,
                     }
                     : entry),
             };
@@ -272,11 +318,24 @@ export class TeamOrchestrator {
 function buildModeInstruction(mode) {
     switch (mode) {
         case 'explore':
-            return 'Work in planning mode. Investigate, reason, and write the plan inline. Do not make file edits.';
+            return [
+                'Investigation mode.',
+                'Read, search, and reason about the codebase.',
+                'Produce a concrete plan with specific file paths and an approach.',
+                'Do not create or edit files.',
+            ].join(' ');
         case 'implement':
-            return 'Work in implementation mode. Make the changes, verify them, and report clearly.';
+            return [
+                'Implementation mode.',
+                'Make the changes, run the most relevant verification (tests, lint, typecheck), and report what changed and what you verified.',
+            ].join(' ');
         case 'verify':
-            return 'Work in verification mode. Run the narrowest useful checks first, then broaden only if needed.';
+            return [
+                'Verification mode.',
+                'Run targeted checks in order of relevance.',
+                'Report pass/fail with evidence.',
+                'Escalate failures with exact output.',
+            ].join(' ');
     }
 }
 function summarizeMessage(message) {
@@ -292,8 +351,8 @@ function appendWrapperHistoryEntries(existing, nextEntries) {
 }
 function buildPlanDraftRequest(perspective, request) {
     const posture = perspective === 'lead'
-        ? 'Propose the most direct workable plan.'
-        : 'Challenge weak assumptions, find missing decisions, and propose a stronger alternative if needed.';
+        ? 'You are the lead planner. Propose the most direct workable plan with concrete file paths and clear next steps.'
+        : 'You are the challenger. Stress-test assumptions, surface missing decisions, and propose a stronger alternative when the lead plan is weak.';
     return [
         posture,
         '',
@@ -310,10 +369,10 @@ function buildPlanDraftRequest(perspective, request) {
 }
 function buildSynthesisSystemPrompt() {
     return [
-        'You are the CTO synthesis engine.',
-        'Combine two independent engineering plans into one better plan.',
-        'Prefer the clearest, simplest, highest-leverage path.',
-        'If one user decision is still required, surface exactly one recommended question and one recommended answer.',
+        'You are synthesizing two independent engineering plans into one stronger plan.',
+        'Compare them on clarity, feasibility, risk, and fit to the user request.',
+        'Prefer the simplest path that fully addresses the goal.',
+        'If the plans disagree on something only the user can decide, surface exactly one recommended question and one recommended answer.',
         'Use this output format exactly:',
         '## Synthesis',
         '<combined plan>',

package/dist/src/plugin/agent-hierarchy.d.ts

@@ -8,7 +8,7 @@ export declare const ENGINEER_AGENT_IDS: {
     readonly Alex: "alex";
 };
 export declare const ENGINEER_AGENT_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
-export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "claude"];
+export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "plan_with_team", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "claude"];
 type ToolPermission = 'allow' | 'ask' | 'deny';
 type AgentPermission = {
     '*'?: ToolPermission;

package/dist/src/plugin/agent-hierarchy.js

@@ -10,6 +10,8 @@ export const ENGINEER_AGENT_IDS = {
 export const ENGINEER_AGENT_NAMES = TEAM_ENGINEERS;
 const CTO_ONLY_TOOL_IDS = [
     'team_status',
+    'plan_with_team',
+    'reset_engineer',
     'list_transcripts',
     'list_history',
     'git_diff',
@@ -70,7 +72,7 @@ function buildEngineerPermissions() {
 }
 export function buildCtoAgentConfig(prompts) {
     return {
-        description: 'Technical orchestrator. Finds missing requirements, explicitly assigns engineers, compares plans, reviews diffs, and owns the final outcome.',
+        description: 'Principal engineer who orchestrates AI-powered engineers. Decomposes work, asks clarifying questions, delegates precisely, reviews diffs, and owns the outcome.',
         mode: 'primary',
         color: '#D97757',
         permission: buildCtoPermissions(),

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

@@ -1,6 +1,7 @@
 import { tool } from '@opencode-ai/plugin';
 import { managerPromptRegistry } from '../prompts/registry.js';
 import { isEngineerName } from '../team/roster.js';
+import { TeamOrchestrator } from '../manager/team-orchestrator.js';
 import { discoverProjectClaudeFiles } from '../util/project-context.js';
 import { AGENT_CTO, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, buildCtoAgentConfig, buildEngineerAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
 import { getActiveTeamSession, getOrCreatePluginServices, getPersistedActiveTeam, getWrapperSessionMapping, setActiveTeamSession, setPersistedActiveTeam, setWrapperSessionMapping, } from './service-factory.js';
@@ -9,6 +10,7 @@ const MODE_ENUM = ['explore', 'implement', 'verify'];
 export const ClaudeManagerPlugin = async ({ worktree }) => {
     const claudeFiles = await discoverProjectClaudeFiles(worktree);
     const services = getOrCreatePluginServices(worktree, claudeFiles);
+    await services.approvalManager.loadPersistedPolicy();
     return {
         config: async (config) => {
             config.agent ??= {};
@@ -103,6 +105,69 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify(team, null, 2);
                 },
             }),
+            plan_with_team: tool({
+                description: 'Run dual-engineer plan synthesis. Two engineers explore in parallel (lead + challenger), then their plans are synthesized into one stronger plan.',
+                args: {
+                    request: tool.schema.string().min(1),
+                    leadEngineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex']),
+                    challengerEngineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex']),
+                    model: tool.schema.enum(MODEL_ENUM).optional(),
+                },
+                async execute(args, context) {
+                    const teamId = getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    annotateToolRun(context, 'Running dual-engineer plan synthesis', {
+                        teamId,
+                        lead: args.leadEngineer,
+                        challenger: args.challengerEngineer,
+                    });
+                    const result = await services.orchestrator.planWithTeam({
+                        teamId,
+                        cwd: context.worktree,
+                        request: args.request,
+                        leadEngineer: args.leadEngineer,
+                        challengerEngineer: args.challengerEngineer,
+                        model: args.model,
+                        abortSignal: context.abort,
+                    });
+                    context.metadata({
+                        title: '✅ Plan synthesis complete',
+                        metadata: {
+                            teamId: result.teamId,
+                            lead: result.leadEngineer,
+                            challenger: result.challengerEngineer,
+                            hasQuestion: result.recommendedQuestion !== null,
+                        },
+                    });
+                    return JSON.stringify({
+                        synthesis: result.synthesis,
+                        recommendedQuestion: result.recommendedQuestion,
+                        recommendedAnswer: result.recommendedAnswer,
+                    }, null, 2);
+                },
+            }),
+            reset_engineer: tool({
+                description: 'Reset a stuck or corrupted engineer. Clears the busy flag. Optionally clears the Claude session (starts fresh) and/or wrapper history.',
+                args: {
+                    engineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex']),
+                    clearSession: tool.schema.boolean().optional(),
+                    clearHistory: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    const teamId = getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    annotateToolRun(context, `Resetting ${args.engineer}`, {
+                        teamId,
+                        clearSession: args.clearSession,
+                        clearHistory: args.clearHistory,
+                    });
+                    await services.orchestrator.resetEngineer(context.worktree, teamId, args.engineer, {
+                        clearSession: args.clearSession,
+                        clearHistory: args.clearHistory,
+                    });
+                    const team = await services.orchestrator.getOrCreateTeam(context.worktree, teamId);
+                    const engineer = team.engineers.find((e) => e.name === args.engineer);
+                    return JSON.stringify({ reset: true, engineer: engineer ?? args.engineer }, null, 2);
+                },
+            }),
             git_diff: tool({
                 description: 'Show diff of uncommitted changes. Use paths to filter to specific files or use ref to compare against another branch, tag, or commit.',
                 args: {
@@ -125,13 +190,17 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             git_commit: tool({
-                description: 'Stage all changes and create a commit with the given message.',
+                description: 'Create a commit. Stages all changes by default, or only the specified paths if provided.',
                 args: {
                     message: tool.schema.string().min(1),
+                    paths: tool.schema.string().array().optional(),
                 },
                 async execute(args, context) {
-                    annotateToolRun(context, 'Committing changes', { message: args.message });
-                    const result = await services.manager.gitCommit(args.message);
+                    annotateToolRun(context, 'Committing changes', {
+                        message: args.message,
+                        paths: args.paths,
+                    });
+                    const result = await services.manager.gitCommit(args.message, args.paths);
                     return JSON.stringify(result, null, 2);
                 },
             }),
@@ -249,7 +318,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                                 error: 'addRule requires ruleId, toolPattern, and ruleAction',
                             });
                         }
-                        services.approvalManager.addRule({
+                        await services.approvalManager.addRule({
                             id: args.ruleId,
                             toolPattern: args.toolPattern,
                             inputPattern: args.inputPattern,
@@ -262,20 +331,20 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         if (!args.ruleId) {
                             return JSON.stringify({ error: 'removeRule requires ruleId' });
                         }
-                        const removed = services.approvalManager.removeRule(args.ruleId);
+                        const removed = await services.approvalManager.removeRule(args.ruleId);
                         return JSON.stringify({ removed }, null, 2);
                     }
                     else if (args.action === 'setDefault') {
                         if (!args.defaultAction) {
                             return JSON.stringify({ error: 'setDefault requires defaultAction' });
                         }
-                        services.approvalManager.setDefaultAction(args.defaultAction);
+                        await services.approvalManager.setDefaultAction(args.defaultAction);
                     }
                     else if (args.action === 'setEnabled') {
                         if (args.enabled === undefined) {
                             return JSON.stringify({ error: 'setEnabled requires enabled' });
                         }
-                        services.approvalManager.setEnabled(args.enabled);
+                        await services.approvalManager.setEnabled(args.enabled);
                     }
                     else if (args.action === 'clearDecisions') {
                         services.approvalManager.clearDecisions();
@@ -292,16 +361,35 @@ async function runEngineerAssignment(input, context) {
         teamId: input.teamId,
         mode: input.mode,
     });
-    const result = await services.orchestrator.dispatchEngineer({
-        teamId: input.teamId,
-        cwd: context.worktree,
-        engineer: input.engineer,
-        mode: input.mode,
-        message: input.message,
-        model: input.model,
-        abortSignal: context.abort,
-        onEvent: (event) => reportClaudeEvent(context, input.engineer, event),
-    });
+    let result;
+    try {
+        result = await services.orchestrator.dispatchEngineer({
+            teamId: input.teamId,
+            cwd: context.worktree,
+            engineer: input.engineer,
+            mode: input.mode,
+            message: input.message,
+            model: input.model,
+            abortSignal: context.abort,
+            onEvent: (event) => reportClaudeEvent(context, input.engineer, event),
+        });
+    }
+    catch (error) {
+        const failure = TeamOrchestrator.classifyError(error);
+        failure.teamId = input.teamId;
+        failure.engineer = input.engineer;
+        failure.mode = input.mode;
+        context.metadata({
+            title: `❌ ${input.engineer} failed (${failure.failureKind})`,
+            metadata: {
+                teamId: failure.teamId,
+                engineer: failure.engineer,
+                failureKind: failure.failureKind,
+                message: failure.message.slice(0, 200),
+            },
+        });
+        throw error;
+    }
     await services.orchestrator.recordWrapperExchange(context.worktree, input.teamId, input.engineer, context.sessionID, input.mode, input.message, result.finalText);
     context.metadata({
         title: `✅ ${input.engineer} finished`,
@@ -335,6 +423,60 @@ function isEngineerAgent(agentId) {
 async function resolveTeamId(worktree, sessionID) {
     return (await getPersistedActiveTeam(worktree)) ?? getActiveTeamSession(worktree) ?? sessionID;
 }
+function formatToolDescription(toolName, toolArgs) {
+    if (!toolArgs || typeof toolArgs !== 'object')
+        return undefined;
+    const args = toolArgs;
+    switch (toolName) {
+        case 'Read':
+        case 'read': {
+            const filePath = args.file_path;
+            return typeof filePath === 'string' ? `Reading: ${filePath}` : undefined;
+        }
+        case 'Grep':
+        case 'grep': {
+            const pattern = args.pattern;
+            return typeof pattern === 'string' ? `Searching: ${pattern}` : undefined;
+        }
+        case 'Write':
+        case 'write': {
+            const filePath = args.file_path;
+            return typeof filePath === 'string' ? `Writing: ${filePath}` : undefined;
+        }
+        case 'Edit':
+        case 'edit': {
+            const filePath = args.file_path;
+            return typeof filePath === 'string' ? `Editing: ${filePath}` : undefined;
+        }
+        case 'Bash':
+        case 'bash':
+        case 'Run':
+        case 'run': {
+            const command = args.command;
+            return typeof command === 'string' ? `Running: ${command.slice(0, 80)}` : undefined;
+        }
+        case 'WebFetch':
+        case 'webfetch': {
+            const url = args.url;
+            return typeof url === 'string' ? `Fetching: ${url}` : undefined;
+        }
+        case 'Glob':
+        case 'glob': {
+            const pattern = args.pattern;
+            return typeof pattern === 'string' ? `Matching: ${pattern}` : undefined;
+        }
+        case 'TodoWrite':
+        case 'todowrite':
+            return args.content ? `Updating todos` : undefined;
+        case 'NotebookEdit':
+        case 'notebook_edit': {
+            const cellPath = args.notebook_cell_path;
+            return typeof cellPath === 'string' ? `Editing notebook: ${cellPath}` : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
 function reportClaudeEvent(context, engineer, event) {
     if (event.type === 'error') {
         context.metadata({
@@ -382,10 +524,13 @@ function reportClaudeEvent(context, engineer, event) {
         catch {
             // event.text is not valid JSON — fall back to generic title
         }
+        const toolDescription = formatToolDescription(toolName ?? '', toolArgs);
         context.metadata({
-            title: toolName
-                ? `⚡ ${engineer} → ${toolName}`
-                : `⚡ ${engineer} is using Claude Code tools`,
+            title: toolDescription
+                ? `⚡ ${engineer} → ${toolDescription}`
+                : toolName
+                    ? `⚡ ${engineer} → ${toolName}`
+                    : `⚡ ${engineer} is using Claude Code tools`,
             metadata: {
                 engineer,
                 sessionId: event.sessionId,
@@ -397,12 +542,15 @@ function reportClaudeEvent(context, engineer, event) {
         return;
     }
     if (event.type === 'assistant' || event.type === 'partial') {
+        const isThinking = event.text.startsWith('<thinking>');
+        const stateLabel = event.type === 'partial' && isThinking ? 'is thinking' : 'is working';
         context.metadata({
-            title: `⚡ ${engineer} is working`,
+            title: `⚡ ${engineer} ${stateLabel}`,
             metadata: {
                 engineer,
                 sessionId: event.sessionId,
                 preview: event.text.slice(0, 160),
+                isThinking,
             },
         });
     }

package/dist/src/plugin/service-factory.d.ts

@@ -1,5 +1,4 @@
 import { ClaudeSessionService } from '../claude/claude-session.service.js';
-import { SessionLiveTailer } from '../claude/session-live-tailer.js';
 import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
 import { TeamStateStore } from '../state/team-state-store.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
@@ -9,7 +8,6 @@ export interface ClaudeManagerPluginServices {
     manager: PersistentManager;
     sessions: ClaudeSessionService;
     approvalManager: ToolApprovalManager;
-    liveTailer: SessionLiveTailer;
     teamStore: TeamStateStore;
     orchestrator: TeamOrchestrator;
 }

package/dist/src/plugin/service-factory.js

@@ -1,13 +1,10 @@
+import path from 'node:path';
 import { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
 import { ClaudeSessionService } from '../claude/claude-session.service.js';
-import { SessionLiveTailer } from '../claude/session-live-tailer.js';
 import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
-import { FileRunStateStore } from '../state/file-run-state-store.js';
 import { TeamStateStore } from '../state/team-state-store.js';
 import { TranscriptStore } from '../state/transcript-store.js';
-import { ContextTracker } from '../manager/context-tracker.js';
 import { GitOperations } from '../manager/git-operations.js';
-import { SessionController } from '../manager/session-controller.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
 import { managerPromptRegistry } from '../prompts/registry.js';
 import { TeamOrchestrator } from '../manager/team-orchestrator.js';
@@ -19,24 +16,19 @@ export function getOrCreatePluginServices(worktree, projectClaudeFiles = []) {
     if (existing) {
         return existing;
     }
-    const approvalManager = new ToolApprovalManager();
+    const approvalPolicyPath = path.join(worktree, '.claude-manager', 'approval-policy.json');
+    const approvalManager = new ToolApprovalManager(undefined, undefined, approvalPolicyPath);
     const sdkAdapter = new ClaudeAgentSdkAdapter(undefined, approvalManager);
     const sessionService = new ClaudeSessionService(sdkAdapter);
-    const contextTracker = new ContextTracker();
-    const sessionController = new SessionController(sdkAdapter, contextTracker, undefined, // session prompt is now constructed dynamically by the wrapper
-    'default', worktree, managerPromptRegistry.modePrefixes);
     const gitOps = new GitOperations(worktree);
-    const stateStore = new FileRunStateStore();
     const teamStore = new TeamStateStore();
     const transcriptStore = new TranscriptStore();
-    const manager = new PersistentManager(sessionController, gitOps, stateStore, contextTracker, transcriptStore);
-    const liveTailer = new SessionLiveTailer();
+    const manager = new PersistentManager(gitOps, transcriptStore);
     const orchestrator = new TeamOrchestrator(sessionService, teamStore, transcriptStore, managerPromptRegistry.engineerSessionPrompt, projectClaudeFiles);
     const services = {
         manager,
         sessions: sessionService,
         approvalManager,
-        liveTailer,
         teamStore,
         orchestrator,
     };

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.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) {

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,