@doingdev/opencode-claude-manager-plugin 0.1.64 → 0.1.66

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

@@ -1,950 +0,0 @@
-import { tool } from '@opencode-ai/plugin';
-import { managerPromptRegistry } from '../prompts/registry.js';
-import { appendDebugLog } from '../util/fs-helpers.js';
-import { isEngineerName } from '../team/roster.js';
-import { TeamOrchestrator, createActionableError, getFailureGuidanceText, } from '../manager/team-orchestrator.js';
-import { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, buildBrowserQaAgentConfig, buildCtoAgentConfig, buildEngineerAgentConfig, buildTeamPlannerAgentConfig, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from './agents/index.js';
-import { clearLatestRevertProcessed, clearRevertProcessed, getOrCreatePluginServices, getParentSessionId, getSessionTeam, getWrapperSessionMapping, isRevertAlreadyProcessed, markRevertProcessed, registerParentSession, registerSessionTeam, 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, client }) => {
-    const services = getOrCreatePluginServices(worktree);
-    await services.approvalManager.loadPersistedPolicy();
-    /**
-     * Resolves the team ID for a brand-new engineer wrapper session.
-     *
-     * 1. Walk the cached parentID chain (populated by session.created events).
-     * 2. On a cache miss, attempt a live client.session.get() lookup and cache
-     *    whatever parentID the SDK returns.
-     * 3. Fall back to the orphan sentinel (sessionID itself) only when both
-     *    cache and live lookup come up empty.
-     */
-    async function resolveTeamId(sessionID) {
-        let current = sessionID;
-        const seen = new Set();
-        while (current && !seen.has(current)) {
-            seen.add(current);
-            const team = getSessionTeam(current);
-            if (team !== undefined)
-                return team;
-            // Cache miss on this node's parent: try the live SDK.
-            if (client && !getParentSessionId(current)) {
-                try {
-                    const result = await client.session.get({ path: { id: current } });
-                    const parentID = result.data?.parentID;
-                    if (parentID) {
-                        registerParentSession(current, parentID);
-                    }
-                }
-                catch {
-                    // Network / auth failure — let the walk continue to orphan.
-                }
-            }
-            current = getParentSessionId(current);
-        }
-        return sessionID;
-    }
-    /**
-     * Propagate a CTO-level undo to all engineer wrapper sessions and their inner
-     * Claude Code sessions that ran work after the reverted CTO message.
-     *
-     * Steps per affected engineer:
-     *   1. Determine how many wrapper exchanges happened after the cutoff.
-     *   2. Revert the engineer's OpenCode wrapper session to the first message after the cutoff.
-     *   3. Send `/undo` to the inner Claude Code session once per affected exchange.
-     *   4. Prune the in-disk wrapper history to remove the stale entries.
-     *
-     * Best-effort: one engineer's failure does not prevent others from being processed.
-     */
-    async function handleCtoUndoPropagation(ctoSessionId, teamId, revertMessageId) {
-        if (!client) {
-            // Throw so the caller's catch clears the dedup marker; transient — should be retried.
-            throw new Error('no OpenCode client — cannot resolve revert cutoff');
-        }
-        // Fetch the CTO message to get a reliable cutoff timestamp.
-        // Let errors propagate so the caller's catch clears the dedup marker on failure.
-        const msgResult = await client.session.message({
-            path: { id: ctoSessionId, messageID: revertMessageId },
-        });
-        const created = msgResult.data?.info.time.created;
-        if (created === undefined) {
-            throw new Error('reverted CTO message has no creation timestamp');
-        }
-        const cutoffMs = created;
-        const cutoffIso = new Date(cutoffMs).toISOString();
-        const team = await services.orchestrator.getOrCreateTeam(worktree, teamId);
-        for (const engineerRecord of team.engineers) {
-            try {
-                await undoEngineerTurns(teamId, engineerRecord, cutoffMs, cutoffIso);
-            }
-            catch (err) {
-                // One engineer's failure must not prevent others from being processed.
-                try {
-                    await appendDebugLog(services.debugLogPath, {
-                        type: 'undo_engineer_error',
-                        ctoSessionId,
-                        teamId,
-                        engineer: engineerRecord.name,
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-                catch {
-                    // Ignore log write failures.
-                }
-            }
-        }
-    }
-    /**
-     * Undo all work an engineer did after the cutoff in both their OpenCode wrapper
-     * session and their inner Claude Code session, then prune the wrapper history.
-     */
-    async function undoEngineerTurns(teamId, engineerRecord, cutoffMs, cutoffIso) {
-        // Count how many full exchanges (assignment+result pairs) happened after the cutoff.
-        const undoCount = engineerRecord.wrapperHistory.filter((h) => h.type === 'assignment' && h.timestamp > cutoffIso).length;
-        if (undoCount === 0) {
-            return;
-        }
-        // 1. Revert the engineer's OpenCode wrapper session.
-        if (client && engineerRecord.wrapperSessionId) {
-            try {
-                await revertWrapperSession(engineerRecord.wrapperSessionId, cutoffMs);
-            }
-            catch (err) {
-                try {
-                    await appendDebugLog(services.debugLogPath, {
-                        type: 'undo_wrapper_revert_error',
-                        teamId,
-                        engineer: engineerRecord.name,
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-                catch {
-                    // Ignore log write failures.
-                }
-            }
-        }
-        // 2. Undo the corresponding inner Claude Code session turns.
-        let innerUndoFailed = false;
-        if (engineerRecord.claudeSessionId) {
-            for (let i = 0; i < undoCount; i++) {
-                try {
-                    await services.sessions.runTask({
-                        cwd: worktree,
-                        prompt: '/undo',
-                        resumeSessionId: engineerRecord.claudeSessionId,
-                        persistSession: true,
-                        permissionMode: 'acceptEdits',
-                        maxTurns: 1,
-                        settingSources: ['user', 'project', 'local'],
-                    }, undefined);
-                }
-                catch {
-                    // Best-effort: stop further /undo attempts for this engineer on failure.
-                    innerUndoFailed = true;
-                    break;
-                }
-            }
-        }
-        // If inner undo failed, the Claude session may be in an inconsistent state.
-        // Reset the session reference and context snapshot so the next assignment starts fresh.
-        if (innerUndoFailed) {
-            try {
-                await services.orchestrator.resetEngineer(worktree, teamId, engineerRecord.name, {
-                    clearSession: true,
-                    clearHistory: false,
-                });
-            }
-            catch (err) {
-                try {
-                    await appendDebugLog(services.debugLogPath, {
-                        type: 'undo_clear_session_error',
-                        teamId,
-                        engineer: engineerRecord.name,
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-                catch {
-                    // Ignore log write failures.
-                }
-            }
-        }
-        // 3. Prune the persisted wrapper history.
-        try {
-            await services.orchestrator.pruneWrapperHistoryAfter(worktree, teamId, engineerRecord.name, cutoffIso);
-        }
-        catch (err) {
-            try {
-                await appendDebugLog(services.debugLogPath, {
-                    type: 'undo_prune_error',
-                    teamId,
-                    engineer: engineerRecord.name,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-            catch {
-                // Ignore log write failures.
-            }
-        }
-    }
-    /**
-     * Revert an engineer's OpenCode wrapper session to just before the first user
-     * message that was created after cutoffMs.
-     */
-    async function revertWrapperSession(wrapperSessionId, cutoffMs) {
-        if (!client) {
-            return;
-        }
-        const messagesResult = await client.session.messages({
-            path: { id: wrapperSessionId },
-        });
-        const messages = messagesResult.data ?? [];
-        const firstAffected = messages.find((m) => m.info.role === 'user' && m.info.time.created > cutoffMs);
-        if (!firstAffected) {
-            return;
-        }
-        await client.session.revert({
-            path: { id: wrapperSessionId },
-            body: { messageID: firstAffected.info.id },
-        });
-    }
-    return {
-        config: async (config) => {
-            config.agent ??= {};
-            config.permission ??= {};
-            denyRestrictedToolsGlobally(config.permission);
-            config.agent[AGENT_CTO] ??= buildCtoAgentConfig(managerPromptRegistry);
-            config.agent[AGENT_TEAM_PLANNER] ??= buildTeamPlannerAgentConfig(managerPromptRegistry);
-            config.agent[AGENT_BROWSER_QA] ??= buildBrowserQaAgentConfig(managerPromptRegistry);
-            for (const engineer of ENGINEER_AGENT_NAMES) {
-                config.agent[ENGINEER_AGENT_IDS[engineer]] ??= buildEngineerAgentConfig(managerPromptRegistry, engineer);
-            }
-        },
-        'chat.message': async (input) => {
-            if (input.agent === AGENT_CTO) {
-                // Each CTO session ID is its own team. The session ID is the durable
-                // identity: no worktree-global active-team state.
-                registerSessionTeam(input.sessionID, input.sessionID);
-                return;
-            }
-            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(input.sessionID));
-                setWrapperSessionMapping(worktree, input.sessionID, {
-                    teamId,
-                    workerName: engineer,
-                });
-                await services.orchestrator.recordWrapperSession(worktree, teamId, engineer, input.sessionID);
-            }
-        },
-        event: async ({ event: sdkEvent }) => {
-            if (sdkEvent.type === 'session.created') {
-                const session = sdkEvent.properties.info;
-                if (session.parentID) {
-                    registerParentSession(session.id, session.parentID);
-                }
-                return;
-            }
-            if (sdkEvent.type === 'session.updated') {
-                const session = sdkEvent.properties.info;
-                if (!session.revert) {
-                    // Revert marker cleared — remove the stale dedup entry so a future undo
-                    // of the same message (redo → undo) is processed again.
-                    clearLatestRevertProcessed(session.id);
-                    return;
-                }
-                // Only propagate undo for CTO sessions (teamId === sessionId).
-                if (getSessionTeam(session.id) !== session.id) {
-                    // In-memory miss — check persisted state to survive process restart / cache loss.
-                    const persistedTeam = await services.teamStore.getTeam(worktree, session.id);
-                    if (!persistedTeam) {
-                        return;
-                    }
-                    // Valid CTO team found on disk — register it so future events skip the I/O.
-                    registerSessionTeam(session.id, session.id);
-                }
-                const teamId = session.id;
-                const revertMessageId = session.revert.messageID;
-                // Deduplicate: multiple session.updated events can fire for the same revert marker.
-                if (isRevertAlreadyProcessed(session.id, revertMessageId)) {
-                    return;
-                }
-                markRevertProcessed(session.id, revertMessageId);
-                // Best-effort: do not throw from the event hook.
-                await handleCtoUndoPropagation(session.id, teamId, revertMessageId).catch(async (err) => {
-                    // On total failure, remove the dedup marker so a retry is possible.
-                    clearRevertProcessed(session.id, revertMessageId);
-                    try {
-                        await appendDebugLog(services.debugLogPath, {
-                            type: 'undo_propagation_error',
-                            ctoSessionId: session.id,
-                            revertMessageId,
-                            error: err instanceof Error ? err.message : String(err),
-                        });
-                    }
-                    catch {
-                        // Log write failures must not mask the original error path.
-                    }
-                });
-            }
-        },
-        'experimental.chat.system.transform': async (input, output) => {
-            if (!input.sessionID) {
-                return;
-            }
-            // Try in-memory mapping first
-            let mapping = getWrapperSessionMapping(worktree, input.sessionID);
-            // Fall back to persisted lookup if in-memory mapping is absent
-            if (!mapping) {
-                // Check if this is an engineer wrapper session
-                const engineerMatch = await services.orchestrator.findTeamByWrapperSession(worktree, input.sessionID);
-                if (engineerMatch) {
-                    mapping = {
-                        teamId: engineerMatch.teamId,
-                        workerName: engineerMatch.engineer,
-                    };
-                }
-            }
-            if (!mapping) {
-                return;
-            }
-            const wrapperContext = await services.orchestrator.getWrapperSystemContext(worktree, mapping.teamId, mapping.workerName);
-            if (wrapperContext) {
-                output.system.push(wrapperContext);
-            }
-        },
-        tool: {
-            claude: tool({
-                description: "Run work through a named engineer's persistent Claude Code session. Engineers include general developers (Tom, John, Maya, Sara, Alex) and specialists like browser-qa. The session remembers prior turns.",
-                args: {
-                    mode: tool.schema.enum(MODE_ENUM),
-                    message: tool.schema.string().min(1),
-                    model: tool.schema.enum(MODEL_ENUM).optional(),
-                },
-                async execute(args, context) {
-                    // Handle engineer agents (includes BrowserQA)
-                    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.sessionID));
-                    setWrapperSessionMapping(context.worktree, context.sessionID, {
-                        teamId,
-                        workerName: 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);
-                    const capabilities = services.workerCapabilities[engineer];
-                    if (capabilities?.isRuntimeUnavailableResponse?.(result.finalText)) {
-                        const lines = result.finalText.split('\n');
-                        const unavailableLine = lines[0] ?? 'Playwright unavailable (reason unknown)';
-                        context.metadata({
-                            title: capabilities.runtimeUnavailableTitle ?? '❌ Playwright unavailable',
-                            metadata: { unavailable: unavailableLine },
-                        });
-                    }
-                    return result.finalText;
-                },
-            }),
-            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: {
-                    teamId: tool.schema.string().optional(),
-                },
-                async execute(args, context) {
-                    const teamId = args.teamId ?? context.sessionID;
-                    annotateToolRun(context, 'Reading team status', {
-                        teamId,
-                    });
-                    const team = await services.orchestrator.getOrCreateTeam(context.worktree, teamId);
-                    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. Automatically selects distinct available engineers if names are not provided.',
-                args: {
-                    request: tool.schema.string().min(1),
-                    leadEngineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex']).optional(),
-                    challengerEngineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex']).optional(),
-                    model: tool.schema.enum(MODEL_ENUM).optional(),
-                },
-                async execute(args, context) {
-                    const teamId = context.sessionID;
-                    // Pre-determine engineers for event labeling (using orchestrator selection logic)
-                    const { lead, challenger } = await services.orchestrator.selectPlanEngineers(context.worktree, teamId, args.leadEngineer, args.challengerEngineer);
-                    annotateToolRun(context, 'Running dual-engineer plan synthesis', {
-                        teamId,
-                        lead,
-                        challenger,
-                    });
-                    const result = await services.orchestrator.planWithTeam({
-                        teamId,
-                        cwd: context.worktree,
-                        request: args.request,
-                        leadEngineer: lead,
-                        challengerEngineer: challenger,
-                        model: args.model,
-                        abortSignal: context.abort,
-                        onLeadEvent: (event) => reportClaudeEvent(context, lead, event),
-                        onChallengerEvent: (event) => reportClaudeEvent(context, challenger, event),
-                        onSynthesisEvent: (event) => reportPlanSynthesisEvent(context, event),
-                    });
-                    context.metadata({
-                        title: '✅ Plan synthesis finished',
-                        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', 'BrowserQA']),
-                    clearSession: tool.schema.boolean().optional(),
-                    clearHistory: tool.schema.boolean().optional(),
-                },
-                async execute(args, context) {
-                    const teamId = 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: {
-                    paths: tool.schema.string().array().optional(),
-                    staged: tool.schema.boolean().optional(),
-                    ref: tool.schema.string().optional(),
-                },
-                async execute(args, context) {
-                    annotateToolRun(context, 'Running git diff', {
-                        paths: args.paths,
-                        staged: args.staged,
-                        ref: args.ref,
-                    });
-                    const result = await services.manager.gitDiff({
-                        paths: args.paths?.filter((path) => path !== undefined),
-                        staged: args.staged,
-                        ref: args.ref,
-                    });
-                    return JSON.stringify(result, null, 2);
-                },
-            }),
-            git_commit: tool({
-                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,
-                        paths: args.paths,
-                    });
-                    const result = await services.manager.gitCommit(args.message, args.paths);
-                    return JSON.stringify(result, null, 2);
-                },
-            }),
-            git_reset: tool({
-                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', {});
-                    const result = await services.manager.gitReset();
-                    return JSON.stringify(result, null, 2);
-                },
-            }),
-            git_status: tool({
-                description: 'Show working tree status in short format and whether the tree is clean.',
-                args: {},
-                async execute(_args, context) {
-                    annotateToolRun(context, 'Checking git status', {});
-                    const result = await services.manager.gitStatus();
-                    return JSON.stringify(result, null, 2);
-                },
-            }),
-            git_log: tool({
-                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 });
-                    return services.manager.gitLog(args.count ?? 5);
-                },
-            }),
-            list_transcripts: tool({
-                description: 'List available Claude session transcripts or inspect one transcript by session ID.',
-                args: {
-                    sessionId: tool.schema.string().optional(),
-                },
-                async execute(args, context) {
-                    annotateToolRun(context, 'Inspecting Claude session history', {});
-                    if (args.sessionId) {
-                        const [sdkTranscript, localEvents] = await Promise.all([
-                            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 services.sessions.listSessions(context.worktree);
-                    return JSON.stringify(sessions, null, 2);
-                },
-            }),
-            list_history: tool({
-                description: 'List saved CTO teams for this worktree or inspect one team by ID.',
-                args: {
-                    teamId: tool.schema.string().optional(),
-                },
-                async execute(args, context) {
-                    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 teams = await services.orchestrator.listTeams(context.worktree);
-                    return JSON.stringify(teams, null, 2);
-                },
-            }),
-            approval_policy: tool({
-                description: 'View the current tool approval policy.',
-                args: {},
-                async execute(_args, context) {
-                    annotateToolRun(context, 'Reading approval policy', {});
-                    return JSON.stringify(services.approvalManager.getPolicy(), null, 2);
-                },
-            }),
-            approval_decisions: tool({
-                description: 'View recent tool approval decisions. Use deniedOnly to show only denied calls.',
-                args: {
-                    limit: tool.schema.number().optional(),
-                    deniedOnly: tool.schema.boolean().optional(),
-                },
-                async execute(args, context) {
-                    annotateToolRun(context, 'Reading approval decisions', {});
-                    const decisions = args.deniedOnly
-                        ? services.approvalManager.getDeniedDecisions(args.limit)
-                        : services.approvalManager.getDecisions(args.limit);
-                    return JSON.stringify({ total: decisions.length, decisions }, null, 2);
-                },
-            }),
-            approval_update: tool({
-                description: 'Update the tool approval policy. Add or remove rules, enable or disable approvals, or clear decision history. Unmatched tools are always allowed; block only with explicit deny rules (defaultAction cannot be set to deny).',
-                args: {
-                    action: tool.schema.enum([
-                        'addRule',
-                        'removeRule',
-                        'setDefault',
-                        'setEnabled',
-                        'clearDecisions',
-                    ]),
-                    ruleId: tool.schema.string().optional(),
-                    toolPattern: tool.schema.string().optional(),
-                    inputPattern: tool.schema.string().optional(),
-                    ruleAction: tool.schema.enum(['allow', 'deny']).optional(),
-                    denyMessage: tool.schema.string().optional(),
-                    description: tool.schema.string().optional(),
-                    position: tool.schema.number().optional(),
-                    defaultAction: tool.schema.enum(['allow', 'deny']).optional(),
-                    enabled: tool.schema.boolean().optional(),
-                },
-                async execute(args, context) {
-                    annotateToolRun(context, `Updating approval: ${args.action}`, {});
-                    if (args.action === 'addRule') {
-                        if (!args.ruleId || !args.toolPattern || !args.ruleAction) {
-                            return JSON.stringify({
-                                error: 'addRule requires ruleId, toolPattern, and ruleAction',
-                            });
-                        }
-                        await services.approvalManager.addRule({
-                            id: args.ruleId,
-                            toolPattern: args.toolPattern,
-                            inputPattern: args.inputPattern,
-                            action: args.ruleAction,
-                            denyMessage: args.denyMessage,
-                            description: args.description,
-                        }, args.position);
-                    }
-                    else if (args.action === 'removeRule') {
-                        if (!args.ruleId) {
-                            return JSON.stringify({ error: 'removeRule requires 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' });
-                        }
-                        if (args.defaultAction === 'deny') {
-                            return JSON.stringify({
-                                error: 'defaultAction cannot be deny; unmatched tools are always allowed. Add explicit deny rules instead.',
-                            });
-                        }
-                        await services.approvalManager.setDefaultAction(args.defaultAction);
-                    }
-                    else if (args.action === 'setEnabled') {
-                        if (args.enabled === undefined) {
-                            return JSON.stringify({ error: 'setEnabled requires enabled' });
-                        }
-                        await services.approvalManager.setEnabled(args.enabled);
-                    }
-                    else if (args.action === 'clearDecisions') {
-                        services.approvalManager.clearDecisions();
-                    }
-                    return JSON.stringify(services.approvalManager.getPolicy(), null, 2);
-                },
-            }),
-        },
-    };
-};
-async function runEngineerAssignment(input, context) {
-    const services = getOrCreatePluginServices(context.worktree);
-    annotateToolRun(context, `Assigning ${input.engineer}`, {
-        teamId: input.teamId,
-        mode: input.mode,
-    });
-    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;
-        const guidance = getFailureGuidanceText(failure.failureKind);
-        context.metadata({
-            title: `❌ ${input.engineer} failed (${failure.failureKind})`,
-            metadata: {
-                teamId: failure.teamId,
-                engineer: failure.engineer,
-                failureKind: failure.failureKind,
-                message: failure.message.slice(0, 200),
-                guidance,
-            },
-        });
-        try {
-            await appendDebugLog(services.debugLogPath, {
-                type: 'engineer_failure',
-                engineer: failure.engineer,
-                teamId: failure.teamId,
-                mode: failure.mode,
-                failureKind: failure.failureKind,
-                message: failure.message.slice(0, 300),
-            });
-        }
-        catch {
-            // Log write failures must not mask the original error.
-        }
-        throw createActionableError(failure, 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`,
-        metadata: {
-            teamId: result.teamId,
-            engineer: result.engineer,
-            mode: result.mode,
-            sessionId: result.sessionId,
-            turns: result.turns,
-            contextWarning: formatContextWarning(result.context),
-        },
-    });
-    return result;
-}
-/**
- * Normalize an agent ID to its lowercase canonical form.
- * Handles both uppercase (e.g., 'Tom') and lowercase (e.g., 'tom') inputs.
- */
-export function normalizeAgentId(agentId) {
-    return agentId.toLowerCase();
-}
-export function engineerFromAgent(agentId) {
-    const normalized = normalizeAgentId(agentId);
-    const engineerEntry = Object.entries(ENGINEER_AGENT_IDS).find(([, value]) => value === normalized);
-    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 engineer;
-}
-export function isEngineerAgent(agentId) {
-    const normalized = normalizeAgentId(agentId);
-    return Object.values(ENGINEER_AGENT_IDS).some((id) => id === normalized);
-}
-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, workerName, event) {
-    const baseMetadata = { workerName, engineer: workerName };
-    if (event.type === 'error') {
-        context.metadata({
-            title: `❌ ${workerName} hit an error`,
-            metadata: {
-                ...baseMetadata,
-                sessionId: event.sessionId,
-                error: event.text.slice(0, 200),
-            },
-        });
-        return;
-    }
-    if (event.type === 'status') {
-        context.metadata({
-            title: `ℹ️ ${workerName}: ${event.text}`,
-            metadata: {
-                ...baseMetadata,
-                status: event.text,
-            },
-        });
-        return;
-    }
-    if (event.type === 'init') {
-        context.metadata({
-            title: `⚡ ${workerName} session ready`,
-            metadata: {
-                ...baseMetadata,
-                sessionId: event.sessionId,
-            },
-        });
-        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: toolDescription
-                ? `⚡ ${workerName} → ${toolDescription}`
-                : toolName
-                    ? `⚡ ${workerName} → ${toolName}`
-                    : `⚡ ${workerName} is using Claude Code tools`,
-            metadata: {
-                ...baseMetadata,
-                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: `⚡ ${workerName} ${stateLabel}`,
-            metadata: {
-                ...baseMetadata,
-                sessionId: event.sessionId,
-                preview: event.text.slice(0, 160),
-                isThinking,
-            },
-        });
-    }
-}
-function reportPlanSynthesisEvent(context, event) {
-    if (event.type === 'error') {
-        context.metadata({
-            title: `❌ Plan synthesis hit an error`,
-            metadata: {
-                sessionId: event.sessionId,
-                error: event.text.slice(0, 200),
-            },
-        });
-        return;
-    }
-    if (event.type === 'init') {
-        context.metadata({
-            title: `⚡ Plan synthesis ready`,
-            metadata: {
-                sessionId: event.sessionId,
-            },
-        });
-        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;
-            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: toolDescription
-                ? `⚡ Plan synthesis → ${toolDescription}`
-                : toolName
-                    ? `⚡ Plan synthesis → ${toolName}`
-                    : `⚡ Plan synthesis is running`,
-            metadata: {
-                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: `⚡ Plan synthesis ${stateLabel}`,
-            metadata: {
-                sessionId: event.sessionId,
-                preview: event.text.slice(0, 160),
-                isThinking,
-            },
-        });
-    }
-}
-function annotateToolRun(context, title, metadata) {
-    const agentLabel = context.agent === AGENT_CTO ? 'CTO' : undefined;
-    context.metadata({
-        title: agentLabel ? `${agentLabel} → ${title}` : 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));
-}