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

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

@@ -1,311 +1,110 @@
 import { tool } from '@opencode-ai/plugin';
-import { composeWrapperPrompt, managerPromptRegistry } from '../prompts/registry.js';
+import { managerPromptRegistry } from '../prompts/registry.js';
+import { isEngineerName } from '../team/roster.js';
 import { discoverProjectClaudeFiles } from '../util/project-context.js';
-import { AGENT_CTO, AGENT_ENGINEER_EXPLORE, AGENT_ENGINEER_IMPLEMENT, AGENT_ENGINEER_VERIFY, buildCtoAgentConfig, buildEngineerExploreAgentConfig, buildEngineerImplementAgentConfig, buildEngineerVerifyAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
-import { getOrCreatePluginServices } from './service-factory.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 services = getOrCreatePluginServices(worktree);
-    async function executeDelegate(args, context) {
-        const wrapperServices = getOrCreatePluginServices(context.worktree);
-        if (args.freshSession) {
-            await wrapperServices.manager.clearSession();
-        }
-        const hasActiveSession = wrapperServices.manager.getStatus().sessionId !== null;
-        const promptPreview = args.message.length > 100 ? args.message.slice(0, 100) + '...' : args.message;
-        context.metadata({
-            title: hasActiveSession
-                ? '⚡ Claude Code: Resuming session...'
-                : '⚡ Claude Code: Initializing...',
-            metadata: {
-                status: 'running',
-                sessionId: wrapperServices.manager.getStatus().sessionId,
-                prompt: promptPreview,
-            },
-        });
-        let turnsSoFar;
-        let costSoFar;
-        const result = await wrapperServices.manager.sendMessage(context.worktree, args.message, {
-            model: args.model,
-            effort: args.effort,
-            mode: args.mode,
-            sessionSystemPrompt: args.sessionSystemPrompt,
-            abortSignal: context.abort,
-        }, (event) => {
-            if (event.turns !== undefined) {
-                turnsSoFar = event.turns;
-            }
-            if (event.totalCostUsd !== undefined) {
-                costSoFar = event.totalCostUsd;
-            }
-            const usageSuffix = formatLiveUsage(turnsSoFar, costSoFar);
-            if (event.type === 'tool_call') {
-                let toolName = 'tool';
-                let inputPreview = '';
-                try {
-                    const parsed = JSON.parse(event.text);
-                    toolName = parsed.name ?? 'tool';
-                    if (parsed.input) {
-                        const inputStr = typeof parsed.input === 'string' ? parsed.input : JSON.stringify(parsed.input);
-                        inputPreview = inputStr.length > 150 ? inputStr.slice(0, 150) + '...' : inputStr;
-                    }
-                }
-                catch {
-                    // ignore parse errors
-                }
-                context.metadata({
-                    title: `⚡ Claude Code: Running ${toolName}...${usageSuffix}`,
-                    metadata: {
-                        status: 'running',
-                        sessionId: event.sessionId,
-                        type: event.type,
-                        tool: toolName,
-                        input: inputPreview,
-                    },
-                });
-            }
-            else if (event.type === 'assistant') {
-                const thinkingPreview = event.text.length > 150 ? event.text.slice(0, 150) + '...' : event.text;
-                context.metadata({
-                    title: `⚡ Claude Code: Thinking...${usageSuffix}`,
-                    metadata: {
-                        status: 'running',
-                        sessionId: event.sessionId,
-                        type: event.type,
-                        thinking: thinkingPreview,
-                    },
-                });
-            }
-            else if (event.type === 'init') {
-                context.metadata({
-                    title: `⚡ Claude Code: Session started`,
-                    metadata: {
-                        status: 'running',
-                        sessionId: event.sessionId,
-                        prompt: promptPreview,
-                    },
-                });
-            }
-            else if (event.type === 'user') {
-                const preview = event.text.length > 200 ? event.text.slice(0, 200) + '...' : event.text;
-                const outputPreview = formatToolOutputPreview(event.text);
-                context.metadata({
-                    title: `⚡ Claude Code: ${outputPreview}${usageSuffix}`,
-                    metadata: {
-                        status: 'running',
-                        sessionId: event.sessionId,
-                        type: event.type,
-                        output: preview,
-                    },
-                });
+    const claudeFiles = await discoverProjectClaudeFiles(worktree);
+    const services = getOrCreatePluginServices(worktree, claudeFiles);
+    return {
+        config: async (config) => {
+            config.agent ??= {};
+            config.permission ??= {};
+            denyRestrictedToolsGlobally(config.permission);
+            config.agent[AGENT_CTO] ??= buildCtoAgentConfig(managerPromptRegistry);
+            for (const engineer of ENGINEER_AGENT_NAMES) {
+                config.agent[ENGINEER_AGENT_IDS[engineer]] ??= buildEngineerAgentConfig(managerPromptRegistry, engineer);
             }
-            else if (event.type === 'tool_progress') {
-                let toolName = 'tool';
-                let elapsed = 0;
-                let progressCurrent;
-                let progressTotal;
-                try {
-                    const parsed = JSON.parse(event.text);
-                    toolName = parsed.name ?? 'tool';
-                    elapsed = parsed.elapsed ?? 0;
-                    progressCurrent = parsed.current;
-                    progressTotal = parsed.total;
-                }
-                catch {
-                    // ignore
+        },
+        'chat.message': async (input) => {
+            if (input.agent === AGENT_CTO) {
+                // 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);
                 }
-                const progressInfo = progressCurrent !== undefined && progressTotal !== undefined
-                    ? ` [${progressCurrent}/${progressTotal}]`
-                    : '';
-                context.metadata({
-                    title: `⚡ Claude Code: ${toolName} running ${elapsed > 0 ? `(${elapsed.toFixed(0)}s)` : ''}${progressInfo}...${usageSuffix}`,
-                    metadata: {
-                        status: 'running',
-                        sessionId: event.sessionId,
-                        type: event.type,
-                        tool: toolName,
-                        elapsed,
-                    },
-                });
+                return;
             }
-            else if (event.type === 'tool_summary') {
-                const summary = event.text.length > 200 ? event.text.slice(0, 200) + '...' : event.text;
-                context.metadata({
-                    title: `✅ Claude Code: Tool done${usageSuffix}`,
-                    metadata: {
-                        status: 'success',
-                        sessionId: event.sessionId,
-                        type: event.type,
-                        summary,
-                    },
+            if (input.agent && isEngineerAgent(input.agent)) {
+                const engineer = engineerFromAgent(input.agent);
+                const existing = getWrapperSessionMapping(worktree, input.sessionID);
+                const persisted = existing ??
+                    (await services.orchestrator.findTeamByWrapperSession(worktree, input.sessionID));
+                const teamId = persisted?.teamId ?? (await resolveTeamId(worktree, input.sessionID));
+                setWrapperSessionMapping(worktree, input.sessionID, {
+                    teamId,
+                    engineer,
                 });
+                await services.orchestrator.recordWrapperSession(worktree, teamId, engineer, input.sessionID);
             }
-            else if (event.type === 'partial') {
-                const delta = event.text.length > 200 ? event.text.slice(0, 200) + '...' : event.text;
-                context.metadata({
-                    title: `⚡ Claude Code: Writing...${usageSuffix}`,
-                    metadata: {
-                        status: 'running',
-                        sessionId: event.sessionId,
-                        type: event.type,
-                        delta,
-                    },
-                });
-            }
-            else if (event.type === 'error') {
-                context.metadata({
-                    title: `❌ Claude Code: Error`,
-                    metadata: {
-                        status: 'error',
-                        sessionId: event.sessionId,
-                        error: event.text.slice(0, 200),
-                    },
-                });
-                showToastIfAvailable(context, `Claude Code error: ${event.text.slice(0, 100)}`);
+        },
+        'experimental.chat.system.transform': async (input, output) => {
+            if (!input.sessionID) {
+                return;
             }
-        });
-        const costLabel = `$${(result.totalCostUsd ?? 0).toFixed(4)}`;
-        const turns = result.turns ?? 0;
-        const contextWarning = formatContextWarning(result.context);
-        if (contextWarning) {
-            context.metadata({
-                title: `⚠️ Claude Code: Context at ${result.context.estimatedContextPercent}% (${turns} turns)`,
-                metadata: { status: 'warning', sessionId: result.sessionId, contextWarning },
-            });
-            showToastIfAvailable(context, `⚠️ Context usage at ${result.context.estimatedContextPercent}% — consider compacting`);
-        }
-        else {
-            context.metadata({
-                title: `✅ Claude Code: Complete (${turns} turns, ${costLabel})`,
-                metadata: { status: 'success', sessionId: result.sessionId },
-            });
-            showToastIfAvailable(context, `✅ Session complete (${turns} turns, ${costLabel})`);
-        }
-        let toolOutputs = [];
-        if (result.sessionId) {
-            try {
-                toolOutputs = await wrapperServices.liveTailer.getToolOutputPreview(result.sessionId, context.worktree, 3);
+            const existing = getWrapperSessionMapping(worktree, input.sessionID);
+            const persisted = existing ??
+                (await services.orchestrator.findTeamByWrapperSession(worktree, input.sessionID));
+            if (!persisted) {
+                return;
             }
-            catch {
-                // Non-critical — the JSONL file may not exist yet.
+            const wrapperContext = await services.orchestrator.getWrapperSystemContext(worktree, persisted.teamId, persisted.engineer);
+            if (wrapperContext) {
+                output.system.push(wrapperContext);
             }
-        }
-        return JSON.stringify({
-            sessionId: result.sessionId,
-            finalText: result.finalText,
-            turns: result.turns,
-            totalCostUsd: result.totalCostUsd,
-            inputTokens: result.inputTokens,
-            outputTokens: result.outputTokens,
-            contextWindowSize: result.contextWindowSize,
-            context: result.context,
-            contextWarning,
-            toolOutputs: toolOutputs.length > 0 ? toolOutputs : undefined,
-        }, null, 2);
-    }
-    return {
-        config: async (config) => {
-            config.agent ??= {};
-            config.permission ??= {};
-            denyRestrictedToolsGlobally(config.permission);
-            // Discover project Claude files and build derived wrapper prompts.
-            const claudeFiles = await discoverProjectClaudeFiles(worktree);
-            const derivedPrompts = {
-                ...managerPromptRegistry,
-                engineerExplorePrompt: composeWrapperPrompt(managerPromptRegistry.engineerExplorePrompt, claudeFiles),
-                engineerImplementPrompt: composeWrapperPrompt(managerPromptRegistry.engineerImplementPrompt, claudeFiles),
-                engineerVerifyPrompt: composeWrapperPrompt(managerPromptRegistry.engineerVerifyPrompt, claudeFiles),
-            };
-            config.agent[AGENT_CTO] ??= buildCtoAgentConfig(managerPromptRegistry);
-            config.agent[AGENT_ENGINEER_EXPLORE] ??= buildEngineerExploreAgentConfig(derivedPrompts);
-            config.agent[AGENT_ENGINEER_IMPLEMENT] ??= buildEngineerImplementAgentConfig(derivedPrompts);
-            config.agent[AGENT_ENGINEER_VERIFY] ??= buildEngineerVerifyAgentConfig(derivedPrompts);
         },
         tool: {
-            explore: tool({
-                description: 'Investigate and analyze code without making edits. ' +
-                    'Read-only exploration of the codebase. ' +
-                    'Preferred first step before implementation.',
-                args: {
-                    message: tool.schema.string().min(1),
-                    model: tool.schema
-                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6'])
-                        .optional(),
-                    effort: tool.schema.enum(['medium', 'high', 'max']).default('high'),
-                    freshSession: tool.schema.boolean().default(false),
-                    sessionSystemPrompt: tool.schema.string().optional(),
-                },
-                async execute(args, context) {
-                    return executeDelegate({ ...args, mode: 'plan', wrapperType: 'explore' }, context);
-                },
-            }),
-            verify: tool({
-                description: 'Run verification commands (tests, lint, typecheck, build) and report pass/fail. ' +
-                    'Use after implementation to verify correctness.',
+            claude: tool({
+                description: "Run work through this named engineer's persistent Claude Code session. The session remembers prior turns for this engineer.",
                 args: {
+                    mode: tool.schema.enum(MODE_ENUM),
                     message: tool.schema.string().min(1),
-                    model: tool.schema
-                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6'])
-                        .optional(),
-                    effort: tool.schema.enum(['medium', 'high', 'max']).default('high'),
-                    freshSession: tool.schema.boolean().default(false),
-                    sessionSystemPrompt: tool.schema.string().optional(),
+                    model: tool.schema.enum(MODEL_ENUM).optional(),
                 },
                 async execute(args, context) {
-                    return executeDelegate({ ...args, mode: 'free', wrapperType: 'engineer_verify' }, context);
-                },
-            }),
-            implement: tool({
-                description: 'Implement code changes - can read, edit, and create files. ' +
-                    'Use after exploration to make changes.',
-                args: {
-                    message: tool.schema.string().min(1),
-                    model: tool.schema
-                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6'])
-                        .optional(),
-                    effort: tool.schema.enum(['medium', 'high', 'max']).default('high'),
-                    freshSession: tool.schema.boolean().default(false),
-                    sessionSystemPrompt: tool.schema.string().optional(),
-                },
-                async execute(args, context) {
-                    return executeDelegate({ ...args, mode: 'free', wrapperType: 'implement' }, context);
+                    const engineer = engineerFromAgent(context.agent);
+                    const existing = getWrapperSessionMapping(context.worktree, context.sessionID);
+                    const persisted = existing ??
+                        (await services.orchestrator.findTeamByWrapperSession(context.worktree, context.sessionID));
+                    const teamId = persisted?.teamId ?? (await resolveTeamId(context.worktree, context.sessionID));
+                    setWrapperSessionMapping(context.worktree, context.sessionID, {
+                        teamId,
+                        engineer,
+                    });
+                    await services.orchestrator.recordWrapperSession(context.worktree, teamId, engineer, context.sessionID);
+                    const result = await runEngineerAssignment({
+                        teamId,
+                        engineer,
+                        mode: args.mode,
+                        message: args.message,
+                        model: args.model,
+                    }, context);
+                    return result.finalText;
                 },
             }),
-            compact_context: tool({
-                description: 'Compress session history to reclaim context window space. ' +
-                    'Preserves state while reducing token usage.',
+            team_status: tool({
+                description: 'Show the current CTO team state: named engineers, wrapper session IDs, Claude session IDs, busy flags, wrapper memory, and context snapshots.',
                 args: {
-                    wrapperType: tool.schema.string().optional(),
+                    teamId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    const wrapperServices = getOrCreatePluginServices(context.worktree);
-                    annotateToolRun(context, 'Compacting session', {});
-                    const result = await wrapperServices.manager.compactSession(context.worktree);
-                    const snap = wrapperServices.manager.getStatus();
-                    const contextWarning = formatContextWarning(snap);
-                    context.metadata({
-                        title: contextWarning
-                            ? `⚠️ Claude Code: Compacted — context at ${snap.estimatedContextPercent}%`
-                            : `✅ Claude Code: Compacted (${snap.totalTurns} turns, $${(snap.totalCostUsd ?? 0).toFixed(4)})`,
-                        metadata: {
-                            status: contextWarning ? 'warning' : 'success',
-                            sessionId: result.sessionId,
-                        },
+                    const teamId = args.teamId ?? getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    annotateToolRun(context, 'Reading team status', {
+                        teamId,
                     });
-                    return JSON.stringify({
-                        sessionId: result.sessionId,
-                        finalText: result.finalText,
-                        turns: result.turns,
-                        totalCostUsd: result.totalCostUsd,
-                        context: snap,
-                        contextWarning,
-                    }, null, 2);
+                    const team = await services.orchestrator.getOrCreateTeam(context.worktree, teamId);
+                    return JSON.stringify(team, null, 2);
                 },
             }),
             git_diff: tool({
-                description: 'Show diff of uncommitted changes. ' +
-                    'Use paths to filter to specific files/dirs. ' +
-                    'Use staged=true to see staged changes. ' +
-                    'Use ref to compare against a branch/tag/commit (e.g., ref="main").',
+                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: {
                     paths: tool.schema.string().array().optional(),
                     staged: tool.schema.boolean().optional(),
@@ -317,9 +116,8 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         staged: args.staged,
                         ref: args.ref,
                     });
-                    const paths = args.paths?.filter((p) => p !== undefined);
                     const result = await services.manager.gitDiff({
-                        paths,
+                        paths: args.paths?.filter((path) => path !== undefined),
                         staged: args.staged,
                         ref: args.ref,
                     });
@@ -327,20 +125,18 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             git_commit: tool({
-                description: 'Stage all changes and commit with the given message.',
+                description: 'Stage all changes and create a commit with the given message.',
                 args: {
                     message: tool.schema.string().min(1),
                 },
                 async execute(args, context) {
-                    annotateToolRun(context, 'Committing changes', {
-                        message: args.message,
-                    });
+                    annotateToolRun(context, 'Committing changes', { message: args.message });
                     const result = await services.manager.gitCommit(args.message);
                     return JSON.stringify(result, null, 2);
                 },
             }),
             git_reset: tool({
-                description: 'Discard all uncommitted changes: runs git reset --hard HEAD and git clean -fd.',
+                description: 'Discard all uncommitted changes by running git reset --hard HEAD and git clean -fd.',
                 args: {},
                 async execute(_args, context) {
                     annotateToolRun(context, 'Resetting working directory', {});
@@ -349,8 +145,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             git_status: tool({
-                description: 'Show working tree status — lists changed files in short format. ' +
-                    'Returns isClean=true if nothing changed.',
+                description: 'Show working tree status in short format and whether the tree is clean.',
                 args: {},
                 async execute(_args, context) {
                     annotateToolRun(context, 'Checking git status', {});
@@ -359,93 +154,53 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             git_log: tool({
-                description: 'Show recent commits in short format. ' +
-                    'Default shows last 5 commits. Use count to change.',
+                description: 'Show recent commits in short format. Defaults to 5 commits.',
                 args: {
                     count: tool.schema.number().optional(),
                 },
                 async execute(args, context) {
                     annotateToolRun(context, 'Fetching git log', { count: args.count });
-                    const result = await services.manager.gitLog(args.count ?? 5);
-                    return result;
-                },
-            }),
-            clear_session: tool({
-                description: 'Clear the active session to start fresh. ' +
-                    'Use when context is full or starting a new task.',
-                args: {
-                    wrapperType: tool.schema.string().optional(),
-                    reason: tool.schema.string().optional(),
-                },
-                async execute(args, context) {
-                    const wrapperServices = getOrCreatePluginServices(context.worktree);
-                    annotateToolRun(context, 'Clearing session', {
-                        reason: args.reason,
-                    });
-                    const clearedId = await wrapperServices.manager.clearSession();
-                    return JSON.stringify({ clearedSessionId: clearedId });
-                },
-            }),
-            session_health: tool({
-                description: 'Check session health metrics: context usage %, turn count, cost, and session ID.',
-                args: {
-                    wrapperType: tool.schema.string().optional(),
-                },
-                async execute(args, context) {
-                    const wrapperServices = getOrCreatePluginServices(context.worktree);
-                    annotateToolRun(context, 'Checking session status', {});
-                    const status = wrapperServices.manager.getStatus();
-                    return JSON.stringify({
-                        ...status,
-                        transcriptFile: status.sessionId
-                            ? `.claude-manager/transcripts/${status.sessionId}.json`
-                            : null,
-                        contextWarning: formatContextWarning(status),
-                    }, null, 2);
+                    return services.manager.gitLog(args.count ?? 5);
                 },
             }),
             list_transcripts: tool({
-                description: 'List available session transcripts or inspect a specific transcript by ID.',
+                description: 'List available Claude session transcripts or inspect one transcript by session ID.',
                 args: {
-                    wrapperType: tool.schema.string().optional(),
                     sessionId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    const wrapperServices = getOrCreatePluginServices(context.worktree);
                     annotateToolRun(context, 'Inspecting Claude session history', {});
                     if (args.sessionId) {
                         const [sdkTranscript, localEvents] = await Promise.all([
-                            wrapperServices.sessions.getTranscript(args.sessionId, context.worktree),
-                            wrapperServices.manager.getTranscriptEvents(context.worktree, args.sessionId),
+                            services.sessions.getTranscript(args.sessionId, context.worktree),
+                            services.manager.getTranscriptEvents(context.worktree, args.sessionId),
                         ]);
                         return JSON.stringify({
                             sdkTranscript,
                             localEvents: localEvents.length > 0 ? localEvents : undefined,
                         }, null, 2);
                     }
-                    const sessions = await wrapperServices.sessions.listSessions(context.worktree);
+                    const sessions = await services.sessions.listSessions(context.worktree);
                     return JSON.stringify(sessions, null, 2);
                 },
             }),
             list_history: tool({
-                description: 'List persistent run records from the manager or inspect a specific run.',
+                description: 'List saved CTO teams for this worktree or inspect one team by ID.',
                 args: {
-                    wrapperType: tool.schema.string().optional(),
-                    runId: tool.schema.string().optional(),
+                    teamId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    const wrapperServices = getOrCreatePluginServices(context.worktree);
-                    annotateToolRun(context, 'Reading manager run state', {});
-                    if (args.runId) {
-                        const run = await wrapperServices.manager.getRun(context.worktree, args.runId);
-                        return JSON.stringify(run, null, 2);
+                    annotateToolRun(context, 'Reading saved team history', {});
+                    if (args.teamId) {
+                        const team = await services.teamStore.getTeam(context.worktree, args.teamId);
+                        return JSON.stringify(team, null, 2);
                     }
-                    const runs = await wrapperServices.manager.listRuns(context.worktree);
-                    return JSON.stringify(runs, null, 2);
+                    const teams = await services.orchestrator.listTeams(context.worktree);
+                    return JSON.stringify(teams, null, 2);
                 },
             }),
             approval_policy: tool({
-                description: 'View the current tool approval policy: rules, default action, and enabled status.',
+                description: 'View the current tool approval policy.',
                 args: {},
                 async execute(_args, context) {
                     annotateToolRun(context, 'Reading approval policy', {});
@@ -453,8 +208,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             approval_decisions: tool({
-                description: 'View recent tool approval decisions. Shows what tools were allowed or denied. ' +
-                    'Use deniedOnly to see only denied calls.',
+                description: 'View recent tool approval decisions. Use deniedOnly to show only denied calls.',
                 args: {
                     limit: tool.schema.number().optional(),
                     deniedOnly: tool.schema.boolean().optional(),
@@ -468,8 +222,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             approval_update: tool({
-                description: 'Update the tool approval policy. Add/remove rules, change default action, or enable/disable. ' +
-                    'Rules are evaluated top-to-bottom; first match wins.',
+                description: 'Update the tool approval policy. Add or remove rules, change the default action, enable or disable approvals, or clear decision history.',
                 args: {
                     action: tool.schema.enum([
                         'addRule',
@@ -510,13 +263,11 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                             return JSON.stringify({ error: 'removeRule requires ruleId' });
                         }
                         const removed = services.approvalManager.removeRule(args.ruleId);
-                        return JSON.stringify({ removed });
+                        return JSON.stringify({ removed }, null, 2);
                     }
                     else if (args.action === 'setDefault') {
                         if (!args.defaultAction) {
-                            return JSON.stringify({
-                                error: 'setDefault requires defaultAction',
-                            });
+                            return JSON.stringify({ error: 'setDefault requires defaultAction' });
                         }
                         services.approvalManager.setDefaultAction(args.defaultAction);
                     }
@@ -535,83 +286,144 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         },
     };
 };
-function annotateToolRun(context, title, metadata, status) {
-    const emoji = status ? `${formatStatusEmoji(status)} ` : '';
+async function runEngineerAssignment(input, context) {
+    const services = getOrCreatePluginServices(context.worktree);
+    annotateToolRun(context, `Assigning ${input.engineer}`, {
+        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),
+    });
+    await services.orchestrator.recordWrapperExchange(context.worktree, input.teamId, input.engineer, context.sessionID, input.mode, input.message, result.finalText);
     context.metadata({
-        title: `${emoji}${title}`,
-        metadata: { ...metadata, ...(status ? { status } : {}) },
+        title: `✅ ${input.engineer} finished`,
+        metadata: {
+            teamId: result.teamId,
+            engineer: result.engineer,
+            mode: result.mode,
+            sessionId: result.sessionId,
+            turns: result.turns,
+            contextWarning: formatContextWarning(result.context),
+        },
     });
+    return result;
 }
-function formatLiveUsage(turns, cost) {
-    if (turns === undefined && cost === undefined) {
-        return '';
-    }
-    const parts = [];
-    if (turns !== undefined) {
-        parts.push(`🔄 ${turns} turns`);
-    }
-    if (cost !== undefined) {
-        parts.push(`💰 $${cost.toFixed(4)}`);
+function engineerFromAgent(agentId) {
+    const engineerEntry = Object.entries(ENGINEER_AGENT_IDS).find(([, value]) => value === agentId);
+    const engineer = engineerEntry?.[0];
+    if (!engineer || !isEngineerName(engineer)) {
+        throw new Error(`The claude tool can only be used from a named engineer agent. Received agent ${agentId}.`);
     }
-    return ` (${parts.join(', ')})`;
+    return engineer;
 }
-function formatContextWarning(context) {
-    const { warningLevel, estimatedContextPercent, totalTurns, totalCostUsd } = context;
-    if (warningLevel === 'ok' || estimatedContextPercent === null) {
-        return null;
-    }
-    const templates = managerPromptRegistry.contextWarnings;
-    const template = warningLevel === 'critical'
-        ? templates.critical
-        : warningLevel === 'high'
-            ? templates.high
-            : templates.moderate;
-    return template
-        .replace('{percent}', String(estimatedContextPercent))
-        .replace('{turns}', String(totalTurns))
-        .replace('{cost}', totalCostUsd.toFixed(2));
+function isEngineerAgent(agentId) {
+    return Object.values(ENGINEER_AGENT_IDS).includes(agentId);
 }
-function formatStatusEmoji(status) {
-    switch (status) {
-        case 'running':
-            return '⚡';
-        case 'success':
-            return '✅';
-        case 'error':
-            return '❌';
-        case 'warning':
-            return '⚠️';
-    }
+/**
+ * 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 formatToolOutputPreview(text) {
-    const lower = text.toLowerCase();
-    let prefix;
-    if (lower.includes('"tool":"read"') ||
-        lower.includes('"name":"read"') ||
-        lower.includes('file contents')) {
-        prefix = '↳ Read: ';
+function reportClaudeEvent(context, engineer, event) {
+    if (event.type === 'error') {
+        context.metadata({
+            title: `❌ ${engineer} hit an error`,
+            metadata: {
+                engineer,
+                sessionId: event.sessionId,
+                error: event.text.slice(0, 200),
+            },
+        });
+        return;
     }
-    else if (lower.includes('"tool":"grep"') ||
-        lower.includes('"name":"grep"') ||
-        lower.includes('matches found')) {
-        prefix = '↳ Found: ';
+    if (event.type === 'init') {
+        context.metadata({
+            title: `⚡ ${engineer} session ready`,
+            metadata: {
+                engineer,
+                sessionId: event.sessionId,
+            },
+        });
+        return;
     }
-    else if (lower.includes('"tool":"write"') ||
-        lower.includes('"name":"write"') ||
-        lower.includes('"tool":"edit"') ||
-        lower.includes('"name":"edit"') ||
-        lower.includes('file written') ||
-        lower.includes('file updated')) {
-        prefix = '↳ Wrote: ';
+    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
+        }
+        context.metadata({
+            title: toolName
+                ? `⚡ ${engineer} → ${toolName}`
+                : `⚡ ${engineer} is using Claude Code tools`,
+            metadata: {
+                engineer,
+                sessionId: event.sessionId,
+                ...(toolName !== undefined && { toolName }),
+                ...(toolId !== undefined && { toolId }),
+                ...(toolArgs !== undefined && { toolArgs }),
+            },
+        });
+        return;
     }
-    else {
-        prefix = '↳ Result: ';
+    if (event.type === 'assistant' || event.type === 'partial') {
+        context.metadata({
+            title: `⚡ ${engineer} is working`,
+            metadata: {
+                engineer,
+                sessionId: event.sessionId,
+                preview: event.text.slice(0, 160),
+            },
+        });
     }
-    const snippet = text.replace(/\s+/g, ' ').trim();
-    const truncated = snippet.length > 60 ? snippet.slice(0, 60) + '...' : snippet;
-    return `${prefix}${truncated}`;
 }
-function showToastIfAvailable(context, message) {
-    const ctx = context;
-    ctx.client?.tui?.showToast?.(message);
+function annotateToolRun(context, title, metadata) {
+    context.metadata({
+        title,
+        metadata,
+    });
+}
+function formatContextWarning(context) {
+    if (context.warningLevel === 'ok' || context.estimatedContextPercent === null) {
+        return null;
+    }
+    const template = context.warningLevel === 'critical'
+        ? managerPromptRegistry.contextWarnings.critical
+        : context.warningLevel === 'high'
+            ? managerPromptRegistry.contextWarnings.high
+            : managerPromptRegistry.contextWarnings.moderate;
+    return template
+        .replace('{percent}', String(context.estimatedContextPercent))
+        .replace('{turns}', String(context.totalTurns))
+        .replace('{cost}', context.totalCostUsd.toFixed(2));
 }