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

package/dist/src/manager/persistent-manager.js

@@ -1,37 +1,10 @@
-import { randomUUID } from 'node:crypto';
 export class PersistentManager {
-    sessionController;
     gitOps;
-    stateStore;
-    contextTracker;
     transcriptStore;
-    constructor(sessionController, gitOps, stateStore, contextTracker, transcriptStore) {
-        this.sessionController = sessionController;
+    constructor(gitOps, transcriptStore) {
         this.gitOps = gitOps;
-        this.stateStore = stateStore;
-        this.contextTracker = contextTracker;
         this.transcriptStore = transcriptStore;
     }
-    /**
-     * Send a message to the persistent Claude Code session.
-     * Creates a new session if none exists.
-     */
-    async sendMessage(cwd, message, options, onEvent) {
-        const result = await this.sessionController.sendMessage(message, options, onEvent);
-        if (result.sessionId && result.events.length > 0) {
-            await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
-        }
-        return {
-            sessionId: result.sessionId,
-            finalText: result.finalText,
-            turns: result.turns,
-            totalCostUsd: result.totalCostUsd,
-            inputTokens: result.inputTokens,
-            outputTokens: result.outputTokens,
-            contextWindowSize: result.contextWindowSize,
-            context: this.sessionController.getContextSnapshot(),
-        };
-    }
     /**
      * Get the current git diff.
      */
@@ -41,8 +14,8 @@ export class PersistentManager {
     /**
      * Commit all current changes.
      */
-    async gitCommit(message) {
-        return this.gitOps.commit(message);
+    async gitCommit(message, paths) {
+        return this.gitOps.commit(message, paths);
     }
     /**
      * Get git status summary.
@@ -62,115 +35,10 @@ export class PersistentManager {
     async gitReset() {
         return this.gitOps.resetHard();
     }
-    /**
-     * Get current session status and context health.
-     */
-    getStatus() {
-        return this.sessionController.getContextSnapshot();
-    }
-    /**
-     * Clear the active session. Next send creates a fresh one.
-     */
-    async clearSession() {
-        return this.sessionController.clearSession();
-    }
-    /**
-     * Compact the current session to free context.
-     */
-    async compactSession(cwd, onEvent) {
-        const result = await this.sessionController.compactSession(onEvent);
-        if (result.sessionId && result.events.length > 0) {
-            await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
-        }
-        return result;
-    }
     /**
      * Read persisted transcript events for a session.
      */
     getTranscriptEvents(cwd, sessionId) {
         return this.transcriptStore.readEvents(cwd, sessionId);
     }
-    /**
-     * Execute a full task with run tracking.
-     * Creates a run record, sends the message, and persists the result.
-     */
-    async executeTask(cwd, task, options, onProgress) {
-        const runId = randomUUID();
-        const createdAt = new Date().toISOString();
-        const runRecord = {
-            id: runId,
-            cwd,
-            task,
-            status: 'running',
-            createdAt,
-            updatedAt: createdAt,
-            sessionId: this.sessionController.sessionId,
-            sessionHistory: [],
-            messages: [
-                {
-                    timestamp: createdAt,
-                    direction: 'sent',
-                    text: task,
-                },
-            ],
-            actions: [],
-            commits: [],
-            context: this.sessionController.getContextSnapshot(),
-        };
-        await this.stateStore.saveRun(runRecord);
-        await onProgress?.(runRecord);
-        try {
-            const result = await this.sessionController.sendMessage(task, options, async (event) => {
-                // Update run record with progress events
-                const currentRun = await this.stateStore.getRun(cwd, runId);
-                if (currentRun) {
-                    const updated = {
-                        ...currentRun,
-                        updatedAt: new Date().toISOString(),
-                        sessionId: event.sessionId ?? currentRun.sessionId,
-                        context: this.sessionController.getContextSnapshot(),
-                    };
-                    await this.stateStore.saveRun(updated);
-                    await onProgress?.(updated);
-                }
-            });
-            const completedRun = await this.stateStore.updateRun(cwd, runId, (run) => ({
-                ...run,
-                status: 'completed',
-                updatedAt: new Date().toISOString(),
-                sessionId: result.sessionId ?? run.sessionId,
-                messages: [
-                    ...run.messages,
-                    {
-                        timestamp: new Date().toISOString(),
-                        direction: 'received',
-                        text: result.finalText,
-                        turns: result.turns,
-                        totalCostUsd: result.totalCostUsd,
-                        inputTokens: result.inputTokens,
-                        outputTokens: result.outputTokens,
-                    },
-                ],
-                context: this.sessionController.getContextSnapshot(),
-                finalSummary: result.finalText,
-            }));
-            return { run: completedRun };
-        }
-        catch (error) {
-            const failedRun = await this.stateStore.updateRun(cwd, runId, (run) => ({
-                ...run,
-                status: 'failed',
-                updatedAt: new Date().toISOString(),
-                context: this.sessionController.getContextSnapshot(),
-                finalSummary: error instanceof Error ? error.message : String(error),
-            }));
-            return { run: failedRun };
-        }
-    }
-    listRuns(cwd) {
-        return this.stateStore.listRuns(cwd);
-    }
-    getRun(cwd, runId) {
-        return this.stateStore.getRun(cwd, runId);
-    }
 }

package/dist/src/manager/team-orchestrator.d.ts

@@ -2,7 +2,7 @@ import type { ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapt
 import type { ClaudeSessionService } from '../claude/claude-session.service.js';
 import type { TeamStateStore } from '../state/team-state-store.js';
 import type { TranscriptStore } from '../state/transcript-store.js';
-import type { DiscoveredClaudeFile, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TeamRecord } from '../types/contracts.js';
+import type { EngineerFailureResult, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TeamRecord } from '../types/contracts.js';
 interface DispatchEngineerInput {
     teamId: string;
     cwd: string;
@@ -18,8 +18,7 @@ export declare class TeamOrchestrator {
     private readonly teamStore;
     private readonly transcriptStore;
     private readonly engineerSessionPrompt;
-    private readonly projectClaudeFiles;
-    constructor(sessions: ClaudeSessionService, teamStore: TeamStateStore, transcriptStore: TranscriptStore, engineerSessionPrompt: string, projectClaudeFiles: DiscoveredClaudeFile[]);
+    constructor(sessions: ClaudeSessionService, teamStore: TeamStateStore, transcriptStore: TranscriptStore, engineerSessionPrompt: string);
     getOrCreateTeam(cwd: string, teamId: string): Promise<TeamRecord>;
     listTeams(cwd: string): Promise<TeamRecord[]>;
     recordWrapperSession(cwd: string, teamId: string, engineer: EngineerName, wrapperSessionId: string): Promise<void>;
@@ -29,7 +28,14 @@ export declare class TeamOrchestrator {
         teamId: string;
         engineer: EngineerName;
     } | null>;
+    resetEngineer(cwd: string, teamId: string, engineer: EngineerName, options?: {
+        clearSession?: boolean;
+        clearHistory?: boolean;
+    }): Promise<void>;
     dispatchEngineer(input: DispatchEngineerInput): Promise<EngineerTaskResult>;
+    static classifyError(error: unknown): EngineerFailureResult & {
+        cause: unknown;
+    };
     planWithTeam(input: {
         teamId: string;
         cwd: string;
@@ -45,6 +51,5 @@ export declare class TeamOrchestrator {
     private normalizeTeamRecord;
     private buildSessionSystemPrompt;
     private buildEngineerPrompt;
-    private mapWorkModeToSessionMode;
 }
 export {};

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

@@ -1,17 +1,16 @@
 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;
     transcriptStore;
     engineerSessionPrompt;
-    projectClaudeFiles;
-    constructor(sessions, teamStore, transcriptStore, engineerSessionPrompt, projectClaudeFiles) {
+    constructor(sessions, teamStore, transcriptStore, engineerSessionPrompt) {
         this.sessions = sessions;
         this.teamStore = teamStore;
         this.transcriptStore = transcriptStore;
         this.engineerSessionPrompt = engineerSessionPrompt;
-        this.projectClaudeFiles = projectClaudeFiles;
     }
     async getOrCreateTeam(cwd, teamId) {
         const existing = await this.teamStore.getTeam(cwd, teamId);
@@ -77,6 +76,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);
@@ -102,10 +111,11 @@ export class TeamOrchestrator {
                 resumeSessionId: engineerState.claudeSessionId ?? undefined,
                 persistSession: true,
                 includePartialMessages: true,
-                permissionMode: this.mapWorkModeToSessionMode(input.mode) === 'plan' ? 'plan' : 'acceptEdits',
+                permissionMode: 'acceptEdits',
+                restrictWriteTools: input.mode === 'explore',
                 model: input.model,
                 effort: input.mode === 'implement' ? 'high' : 'medium',
-                settingSources: ['user'],
+                settingSources: ['user', 'project', 'local'],
                 abortSignal: input.abortSignal,
             }, input.onEvent);
             tracker.recordResult({
@@ -124,6 +134,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 +158,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.');
@@ -185,10 +224,11 @@ export class TeamOrchestrator {
             systemPrompt: buildSynthesisSystemPrompt(),
             persistSession: false,
             includePartialMessages: false,
-            permissionMode: 'plan',
+            permissionMode: 'acceptEdits',
+            restrictWriteTools: true,
             model: input.model,
             effort: 'high',
-            settingSources: ['user'],
+            settingSources: ['user', 'project', 'local'],
             abortSignal: input.abortSignal,
         });
         const parsedSynthesis = parseSynthesisResult(synthesisResult.finalText);
@@ -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),
             };
@@ -247,17 +293,11 @@ export class TeamOrchestrator {
         };
     }
     buildSessionSystemPrompt(engineer, mode) {
-        const claudeFileSection = this.projectClaudeFiles.length
-            ? `\n\nProject Claude Files:\n${this.projectClaudeFiles
-                .map((file) => `## ${file.relativePath}\n${file.content}`)
-                .join('\n\n')}`
-            : '';
         return [
             this.engineerSessionPrompt,
             '',
             `Assigned engineer: ${engineer}.`,
             `Current work mode: ${mode}.`,
-            claudeFileSection,
         ]
             .join('\n')
             .trim();
@@ -265,18 +305,30 @@ export class TeamOrchestrator {
     buildEngineerPrompt(mode, message) {
         return `${buildModeInstruction(mode)}\n\n${message}`;
     }
-    mapWorkModeToSessionMode(mode) {
-        return mode === 'explore' ? 'plan' : 'free';
-    }
 }
 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.',
+                'Before reporting done, review your own diff for issues that pass tests but break in production.',
+            ].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: tests, lint, typecheck, build.',
+                'Check that changed code paths have test coverage.',
+                'Report pass/fail with evidence.',
+                'Escalate failures with exact output.',
+            ].join(' ');
     }
 }
 function summarizeMessage(message) {
@@ -292,28 +344,29 @@ 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. Think about failure modes and edge cases — what can break at each boundary?'
+        : 'You are the challenger. Stress-test assumptions, surface missing decisions, and propose a stronger alternative when the lead plan is weak. Think about failure modes and edge cases — what can break at each boundary?';
     return [
         posture,
         '',
         'Return exactly these sections:',
         '1. Objective',
-        '2. Proposed approach',
+        '2. Proposed approach (include system boundaries and data flow)',
         '3. Files or systems likely involved',
-        '4. Risks and open questions',
-        '5. Verification',
-        '6. Step-by-step plan',
+        '4. Failure modes and edge cases (what happens when things go wrong?)',
+        '5. Risks and open questions',
+        '6. Verification (how to prove it works, including what tests to add)',
+        '7. Step-by-step plan',
         '',
         `User request: ${request}`,
     ].join('\n');
 }
 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,6 @@ 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"];
 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',
@@ -22,7 +24,7 @@ const CTO_ONLY_TOOL_IDS = [
     'approval_update',
 ];
 const ENGINEER_TOOL_IDS = ['claude'];
-export const ALL_RESTRICTED_TOOL_IDS = [...CTO_ONLY_TOOL_IDS, ...ENGINEER_TOOL_IDS];
+const ALL_RESTRICTED_TOOL_IDS = [...CTO_ONLY_TOOL_IDS, ...ENGINEER_TOOL_IDS];
 const CTO_READONLY_TOOLS = {
     read: 'allow',
     grep: 'allow',
@@ -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(),