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

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

@@ -1,14 +1,14 @@
 import { tool } from '@opencode-ai/plugin';
 import { managerPromptRegistry } from '../prompts/registry.js';
 import { isEngineerName } from '../team/roster.js';
-import { discoverProjectClaudeFiles } from '../util/project-context.js';
+import { TeamOrchestrator } from '../manager/team-orchestrator.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';
 const MODEL_ENUM = ['claude-opus-4-6', 'claude-sonnet-4-6'];
 const MODE_ENUM = ['explore', 'implement', 'verify'];
 export const ClaudeManagerPlugin = async ({ worktree }) => {
-    const claudeFiles = await discoverProjectClaudeFiles(worktree);
-    const services = getOrCreatePluginServices(worktree, claudeFiles);
+    const services = getOrCreatePluginServices(worktree);
+    await services.approvalManager.loadPersistedPolicy();
     return {
         config: async (config) => {
             config.agent ??= {};
@@ -103,6 +103,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 +188,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 +316,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 +329,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 +359,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 +421,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 +522,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 +540,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,19 +1,17 @@
 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';
 import { TeamOrchestrator } from '../manager/team-orchestrator.js';
-import type { DiscoveredClaudeFile, EngineerName } from '../types/contracts.js';
-export interface ClaudeManagerPluginServices {
+import { TeamStateStore } from '../state/team-state-store.js';
+import type { EngineerName } from '../types/contracts.js';
+interface ClaudeManagerPluginServices {
     manager: PersistentManager;
     sessions: ClaudeSessionService;
     approvalManager: ToolApprovalManager;
-    liveTailer: SessionLiveTailer;
     teamStore: TeamStateStore;
     orchestrator: TeamOrchestrator;
 }
-export declare function getOrCreatePluginServices(worktree: string, projectClaudeFiles?: DiscoveredClaudeFile[]): ClaudeManagerPluginServices;
+export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
 export declare function clearPluginServices(): void;
 export declare function setActiveTeamSession(worktree: string, teamId: string): void;
 export declare function getActiveTeamSession(worktree: string): string | null;
@@ -27,3 +25,4 @@ export declare function getWrapperSessionMapping(worktree: string, wrapperSessio
     teamId: string;
     engineer: EngineerName;
 } | null;
+export {};

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

@@ -1,42 +1,34 @@
+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';
+import { managerPromptRegistry } from '../prompts/registry.js';
+import { TeamStateStore } from '../state/team-state-store.js';
+import { TranscriptStore } from '../state/transcript-store.js';
 const serviceRegistry = new Map();
 const activeTeamRegistry = new Map();
 const wrapperSessionRegistry = new Map();
-export function getOrCreatePluginServices(worktree, projectClaudeFiles = []) {
+export function getOrCreatePluginServices(worktree) {
     const existing = serviceRegistry.get(worktree);
     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 orchestrator = new TeamOrchestrator(sessionService, teamStore, transcriptStore, managerPromptRegistry.engineerSessionPrompt, projectClaudeFiles);
+    const manager = new PersistentManager(gitOps, transcriptStore);
+    const orchestrator = new TeamOrchestrator(sessionService, teamStore, transcriptStore, managerPromptRegistry.engineerSessionPrompt);
     const services = {
         manager,
         sessions: sessionService,
         approvalManager,
-        liveTailer,
         teamStore,
         orchestrator,
     };

package/dist/src/prompts/registry.js

@@ -1,52 +1,71 @@
 export const managerPromptRegistry = {
     ctoSystemPrompt: [
-        'You are the CTO. Own the outcome, not just the request.',
-        '',
-        '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.',
+        '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.',
+        '',
+        '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.',
+        '- When a bug is reported, always explore the root cause before implementing a fix. No fix without investigation. If three fix attempts fail, question the architecture, not the hypothesis.',
+        '',
+        'Challenge the framing:',
+        '- Before planning, ask what the user is actually trying to achieve, not just what they asked for.',
+        '- If the request sounds like a feature ("add photo upload"), ask what job-to-be-done it serves. The real feature might be larger or different.',
+        '- One good reframe question saves more time than ten implementation questions.',
+        '',
+        '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.',
+        '',
+        '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.',
-        '- Use the built-in `question` tool whenever you need a user decision and provide a recommendation.',
-        '',
-        '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.',
-        '',
-        '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.',
+        '- 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.',
+        '- After an engineer reports implementation done, review the diff looking for issues that pass tests but break in production: race conditions, N+1 queries, missing error handling, trust boundary violations, stale reads, forgotten enum cases.',
+        '- Auto-fix mechanical issues by sending a follow-up to the same engineer. Surface genuinely ambiguous issues to the user.',
+        '- Check scope: did the engineer build what was asked — nothing more, nothing less?',
+        '',
+        'Verify before declaring done:',
+        '- After review passes, dispatch an engineer in verify mode to run the most relevant checks (tests, lint, typecheck, build) for what changed.',
+        '- Do not declare a task complete until verification passes. If it fails, fix and re-verify.',
+        '',
+        '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.',
+        'Review your own diff before reporting done. Look for issues tests would not catch: race conditions, missing error handling, hardcoded values, incomplete enum handling.',
+        '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,

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;
@@ -22,14 +18,14 @@ export interface WrapperHistoryEntry {
     mode?: EngineerWorkMode;
     text: string;
 }
-export interface ClaudeCommandMetadata {
+interface ClaudeCommandMetadata {
     name: string;
     description: string;
     argumentHint?: string;
     source: 'sdk' | 'skill' | 'command';
     path?: string;
 }
-export interface ClaudeAgentMetadata {
+interface ClaudeAgentMetadata {
     name: string;
     description: string;
     model?: string;
@@ -52,6 +48,12 @@ export interface RunClaudeSessionInput {
     effort?: 'low' | 'medium' | 'high' | 'max';
     mode?: SessionMode;
     permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk';
+    /**
+     * When true, the canUseTool callback denies write tools (Edit, Write, MultiEdit,
+     * NotebookEdit) and destructive bash commands. Used instead of SDK plan mode so
+     * the agent can still exit plan mode if needed.
+     */
+    restrictWriteTools?: boolean;
     /** Merged with `Skill` by the SDK adapter unless `Skill` appears in `disallowedTools`. */
     allowedTools?: string[];
     disallowedTools?: string[];
@@ -110,12 +112,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,57 +174,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;
-    /** Trimmed UTF-8 text content. */
-    content: string;
-}
 export interface ToolApprovalRule {
     id: string;
     description?: string;
@@ -240,3 +200,4 @@ export interface ToolApprovalDecision {
     denyMessage?: string;
     agentId?: string;
 }
+export {};

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