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

package/dist/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/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/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/plugin/claude-manager.plugin.js

@@ -1,14 +1,16 @@
 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, getWrapperSessionMapping, setActiveTeamSession, setWrapperSessionMapping, } from './service-factory.js';
-import { isEngineerName } from '../team/roster.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);
+    await services.approvalManager.loadPersistedPolicy();
     return {
         config: async (config) => {
             config.agent ??= {};
@@ -21,7 +23,15 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         },
         'chat.message': async (input) => {
             if (input.agent === AGENT_CTO) {
-                setActiveTeamSession(worktree, input.sessionID);
+                // Adopt the persisted active team if one exists, so a new CTO session
+                // does not orphan previously created engineers and wrapper memory.
+                const persistedTeamId = await getPersistedActiveTeam(worktree);
+                const activeTeamId = persistedTeamId ?? input.sessionID;
+                setActiveTeamSession(worktree, activeTeamId);
+                if (!persistedTeamId) {
+                    // First CTO session for this worktree — persist this session as active team.
+                    await setPersistedActiveTeam(worktree, activeTeamId);
+                }
                 return;
             }
             if (input.agent && isEngineerAgent(input.agent)) {
@@ -29,7 +39,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 const existing = getWrapperSessionMapping(worktree, input.sessionID);
                 const persisted = existing ??
                     (await services.orchestrator.findTeamByWrapperSession(worktree, input.sessionID));
-                const teamId = persisted?.teamId ?? getActiveTeamSession(worktree) ?? input.sessionID;
+                const teamId = persisted?.teamId ?? (await resolveTeamId(worktree, input.sessionID));
                 setWrapperSessionMapping(worktree, input.sessionID, {
                     teamId,
                     engineer,
@@ -65,7 +75,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     const existing = getWrapperSessionMapping(context.worktree, context.sessionID);
                     const persisted = existing ??
                         (await services.orchestrator.findTeamByWrapperSession(context.worktree, context.sessionID));
-                    const teamId = persisted?.teamId ?? getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = persisted?.teamId ?? (await resolveTeamId(context.worktree, context.sessionID));
                     setWrapperSessionMapping(context.worktree, context.sessionID, {
                         teamId,
                         engineer,
@@ -78,7 +88,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         message: args.message,
                         model: args.model,
                     }, context);
-                    return JSON.stringify(result, null, 2);
+                    return result.finalText;
                 },
             }),
             team_status: tool({
@@ -95,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: {
@@ -117,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);
                 },
             }),
@@ -241,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,
@@ -254,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();
@@ -284,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`,
@@ -319,6 +415,68 @@ function engineerFromAgent(agentId) {
 function isEngineerAgent(agentId) {
     return Object.values(ENGINEER_AGENT_IDS).includes(agentId);
 }
+/**
+ * Resolves the team ID for an engineer session.
+ * Reads the persisted active team first (survives process restarts), then
+ * falls back to the in-memory registry, then to the raw session ID as a last resort.
+ */
+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({
@@ -342,22 +500,57 @@ function reportClaudeEvent(context, engineer, event) {
         return;
     }
     if (event.type === 'tool_call') {
+        let toolName;
+        let toolId;
+        let toolArgs;
+        try {
+            const parsed = JSON.parse(event.text);
+            toolName = parsed.name;
+            toolId = parsed.id;
+            // Some SDK versions serialize the input object as a JSON string inside the outer JSON.
+            // Try to double-decode it so callers always receive a plain object.
+            if (typeof parsed.input === 'string') {
+                try {
+                    toolArgs = JSON.parse(parsed.input);
+                }
+                catch {
+                    toolArgs = parsed.input;
+                }
+            }
+            else {
+                toolArgs = parsed.input;
+            }
+        }
+        catch {
+            // event.text is not valid JSON — fall back to generic title
+        }
+        const toolDescription = formatToolDescription(toolName ?? '', toolArgs);
         context.metadata({
-            title: `⚡ ${engineer} is using Claude Code tools`,
+            title: toolDescription
+                ? `⚡ ${engineer} → ${toolDescription}`
+                : toolName
+                    ? `⚡ ${engineer} → ${toolName}`
+                    : `⚡ ${engineer} is using Claude Code tools`,
             metadata: {
                 engineer,
                 sessionId: event.sessionId,
+                ...(toolName !== undefined && { toolName }),
+                ...(toolId !== undefined && { toolId }),
+                ...(toolArgs !== undefined && { toolArgs }),
             },
         });
         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,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;
 }
@@ -17,6 +15,8 @@ export declare function getOrCreatePluginServices(worktree: string, projectClaud
 export declare function clearPluginServices(): void;
 export declare function setActiveTeamSession(worktree: string, teamId: string): void;
 export declare function getActiveTeamSession(worktree: string): string | null;
+export declare function getPersistedActiveTeam(worktree: string): Promise<string | null>;
+export declare function setPersistedActiveTeam(worktree: string, teamId: string): Promise<void>;
 export declare function setWrapperSessionMapping(worktree: string, wrapperSessionId: string, mapping: {
     teamId: string;
     engineer: EngineerName;

package/dist/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,
     };
@@ -54,6 +46,20 @@ export function setActiveTeamSession(worktree, teamId) {
 export function getActiveTeamSession(worktree) {
     return activeTeamRegistry.get(worktree) ?? null;
 }
+export async function getPersistedActiveTeam(worktree) {
+    const services = serviceRegistry.get(worktree);
+    if (!services) {
+        return null;
+    }
+    return services.teamStore.getActiveTeam(worktree);
+}
+export async function setPersistedActiveTeam(worktree, teamId) {
+    const services = serviceRegistry.get(worktree);
+    if (!services) {
+        return;
+    }
+    await services.teamStore.setActiveTeam(worktree, teamId);
+}
 export function setWrapperSessionMapping(worktree, wrapperSessionId, mapping) {
     wrapperSessionRegistry.set(`${worktree}:${wrapperSessionId}`, mapping);
 }