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

package/dist/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/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/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(),

package/dist/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/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/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,
     };