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

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

@@ -30,6 +30,11 @@ export declare class TeamOrchestrator {
         teamId: string;
         engineer: EngineerName;
     } | null>;
+    /**
+     * Remove wrapper history entries whose timestamp is strictly after cutoffIso.
+     * Used during CTO undo propagation to prune stale wrapper memory.
+     */
+    pruneWrapperHistoryAfter(cwd: string, teamId: string, engineer: EngineerName, cutoffIso: string): Promise<void>;
     resetEngineer(cwd: string, teamId: string, engineer: EngineerName, options?: {
         clearSession?: boolean;
         clearHistory?: boolean;

package/dist/manager/team-orchestrator.js

@@ -80,6 +80,16 @@ export class TeamOrchestrator {
         }
         return null;
     }
+    /**
+     * Remove wrapper history entries whose timestamp is strictly after cutoffIso.
+     * Used during CTO undo propagation to prune stale wrapper memory.
+     */
+    async pruneWrapperHistoryAfter(cwd, teamId, engineer, cutoffIso) {
+        await this.updateEngineer(cwd, teamId, engineer, (entry) => ({
+            ...entry,
+            wrapperHistory: entry.wrapperHistory.filter((h) => h.timestamp <= cutoffIso),
+        }));
+    }
     async resetEngineer(cwd, teamId, engineer, options) {
         await this.updateEngineer(cwd, teamId, engineer, (entry) => ({
             ...entry,
@@ -122,6 +132,7 @@ export class TeamOrchestrator {
                 persistSession: true,
                 includePartialMessages: true,
                 permissionMode: 'acceptEdits',
+                allowedTools: workerCaps?.sessionAllowedTools,
                 restrictWriteTools: input.mode === 'explore' || (workerCaps?.restrictWriteTools ?? false),
                 model: input.model,
                 effort: (workerCaps?.restrictWriteTools ?? false)

package/dist/plugin/agents/browser-qa.js

@@ -12,6 +12,10 @@ export function buildWorkerCapabilities(prompts) {
             plannerEligible: false,
             isRuntimeUnavailableResponse: (text) => text.trimStart().startsWith('PLAYWRIGHT_UNAVAILABLE:'),
             runtimeUnavailableTitle: '❌ Playwright unavailable',
+            // Pre-approve the Playwriter toolchain at the SDK level so headless sessions
+            // never stall waiting for interactive confirmation. Write tools remain blocked
+            // by restrictWriteTools and the canUseTool write-filter.
+            sessionAllowedTools: ['Skill', 'Bash', 'Read', 'Grep', 'Glob', 'LS', 'ListDirectory'],
         },
     };
 }

package/dist/plugin/agents/common.d.ts

@@ -12,7 +12,6 @@ export declare const ENGINEER_AGENT_IDS: {
 /** General named engineers only (Tom/John/Maya/Sara/Alex). BrowserQA is a specialist registered separately. */
 export declare const ENGINEER_AGENT_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
 export declare const CTO_ONLY_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
-export declare const ENGINEER_TOOL_IDS: readonly ["claude"];
 export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "claude"];
 export type ToolPermission = 'allow' | 'ask' | 'deny';
 export type AgentPermission = {

package/dist/plugin/agents/common.js

@@ -26,7 +26,7 @@ export const CTO_ONLY_TOOL_IDS = [
     'approval_decisions',
     'approval_update',
 ];
-export const ENGINEER_TOOL_IDS = ['claude'];
+const ENGINEER_TOOL_IDS = ['claude'];
 export const ALL_RESTRICTED_TOOL_IDS = [...CTO_ONLY_TOOL_IDS, ...ENGINEER_TOOL_IDS];
 export const CTO_READONLY_TOOLS = {
     read: 'allow',

package/dist/plugin/agents/index.d.ts

@@ -1,6 +1,5 @@
-export { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, ALL_RESTRICTED_TOOL_IDS, buildEngineerPermissions, CTO_ONLY_TOOL_IDS, CTO_READONLY_TOOLS, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, ENGINEER_TOOL_IDS, } from './common.js';
-export type { AgentPermission, ToolPermission } from './common.js';
+export { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from './common.js';
 export { buildCtoAgentConfig } from './cto.js';
 export { buildTeamPlannerAgentConfig } from './team-planner.js';
 export { buildEngineerAgentConfig } from './engineers.js';
-export { buildBrowserQaAgentConfig, buildWorkerCapabilities } from './browser-qa.js';
+export { buildBrowserQaAgentConfig } from './browser-qa.js';

package/dist/plugin/agents/index.js

@@ -1,5 +1,5 @@
-export { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, ALL_RESTRICTED_TOOL_IDS, buildEngineerPermissions, CTO_ONLY_TOOL_IDS, CTO_READONLY_TOOLS, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, ENGINEER_TOOL_IDS, } from './common.js';
+export { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from './common.js';
 export { buildCtoAgentConfig } from './cto.js';
 export { buildTeamPlannerAgentConfig } from './team-planner.js';
 export { buildEngineerAgentConfig } from './engineers.js';
-export { buildBrowserQaAgentConfig, buildWorkerCapabilities } from './browser-qa.js';
+export { buildBrowserQaAgentConfig } from './browser-qa.js';

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

@@ -4,7 +4,7 @@ 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 { getOrCreatePluginServices, getParentSessionId, getSessionTeam, getWrapperSessionMapping, registerParentSession, registerSessionTeam, setWrapperSessionMapping, } from './service-factory.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 }) => {
@@ -44,6 +44,169 @@ export const ClaudeManagerPlugin = async ({ worktree, client }) => {
         }
         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 ??= {};
@@ -82,6 +245,49 @@ export const ClaudeManagerPlugin = async ({ worktree, client }) => {
                 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) => {

package/dist/plugin/service-factory.d.ts

@@ -15,6 +15,14 @@ interface ClaudeManagerPluginServices {
 }
 export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
 export declare function clearPluginServices(): void;
+export declare function isRevertAlreadyProcessed(ctoSessionId: string, revertMessageId: string): boolean;
+export declare function markRevertProcessed(ctoSessionId: string, revertMessageId: string): void;
+export declare function clearRevertProcessed(ctoSessionId: string, revertMessageId: string): void;
+/**
+ * Clear the latest dedup entry for a CTO session — called when the revert marker disappears
+ * so that a subsequent undo of the same message can be processed again.
+ */
+export declare function clearLatestRevertProcessed(ctoSessionId: string): void;
 export declare function registerParentSession(childId: string, parentId: string): void;
 export declare function getParentSessionId(childId: string): string | undefined;
 export declare function registerSessionTeam(sessionId: string, teamId: string): void;

package/dist/plugin/service-factory.js

@@ -15,6 +15,15 @@ const wrapperSessionRegistry = new Map();
 const parentSessionRegistry = new Map();
 /** ctoSessionId → teamId — populated when a CTO chat.message fires */
 const sessionTeamRegistry = new Map();
+/**
+ * Dedupe set for processed CTO undo events.
+ * Key format: "${ctoSessionId}:${revertMessageId}".
+ * Cleared when the session no longer shows a revert marker (via a subsequent session.updated
+ * with no revert field) or on a full service reset.
+ */
+const processedRevertRegistry = new Set();
+/** ctoSessionId → latest processed revertMessageId — used to clear stale dedup entries when the revert marker disappears */
+const latestRevertRegistry = new Map();
 export function getOrCreatePluginServices(worktree) {
     const existing = serviceRegistry.get(worktree);
     if (existing) {
@@ -48,6 +57,29 @@ export function clearPluginServices() {
     wrapperSessionRegistry.clear();
     parentSessionRegistry.clear();
     sessionTeamRegistry.clear();
+    processedRevertRegistry.clear();
+    latestRevertRegistry.clear();
+}
+export function isRevertAlreadyProcessed(ctoSessionId, revertMessageId) {
+    return processedRevertRegistry.has(`${ctoSessionId}:${revertMessageId}`);
+}
+export function markRevertProcessed(ctoSessionId, revertMessageId) {
+    processedRevertRegistry.add(`${ctoSessionId}:${revertMessageId}`);
+    latestRevertRegistry.set(ctoSessionId, revertMessageId);
+}
+export function clearRevertProcessed(ctoSessionId, revertMessageId) {
+    processedRevertRegistry.delete(`${ctoSessionId}:${revertMessageId}`);
+}
+/**
+ * Clear the latest dedup entry for a CTO session — called when the revert marker disappears
+ * so that a subsequent undo of the same message can be processed again.
+ */
+export function clearLatestRevertProcessed(ctoSessionId) {
+    const revertMessageId = latestRevertRegistry.get(ctoSessionId);
+    if (revertMessageId !== undefined) {
+        processedRevertRegistry.delete(`${ctoSessionId}:${revertMessageId}`);
+        latestRevertRegistry.delete(ctoSessionId);
+    }
 }
 export function registerParentSession(childId, parentId) {
     parentSessionRegistry.set(childId, parentId);

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

@@ -30,6 +30,11 @@ export declare class TeamOrchestrator {
         teamId: string;
         engineer: EngineerName;
     } | null>;
+    /**
+     * Remove wrapper history entries whose timestamp is strictly after cutoffIso.
+     * Used during CTO undo propagation to prune stale wrapper memory.
+     */
+    pruneWrapperHistoryAfter(cwd: string, teamId: string, engineer: EngineerName, cutoffIso: string): Promise<void>;
     resetEngineer(cwd: string, teamId: string, engineer: EngineerName, options?: {
         clearSession?: boolean;
         clearHistory?: boolean;

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

@@ -80,6 +80,16 @@ export class TeamOrchestrator {
         }
         return null;
     }
+    /**
+     * Remove wrapper history entries whose timestamp is strictly after cutoffIso.
+     * Used during CTO undo propagation to prune stale wrapper memory.
+     */
+    async pruneWrapperHistoryAfter(cwd, teamId, engineer, cutoffIso) {
+        await this.updateEngineer(cwd, teamId, engineer, (entry) => ({
+            ...entry,
+            wrapperHistory: entry.wrapperHistory.filter((h) => h.timestamp <= cutoffIso),
+        }));
+    }
     async resetEngineer(cwd, teamId, engineer, options) {
         await this.updateEngineer(cwd, teamId, engineer, (entry) => ({
             ...entry,
@@ -122,6 +132,7 @@ export class TeamOrchestrator {
                 persistSession: true,
                 includePartialMessages: true,
                 permissionMode: 'acceptEdits',
+                allowedTools: workerCaps?.sessionAllowedTools,
                 restrictWriteTools: input.mode === 'explore' || (workerCaps?.restrictWriteTools ?? false),
                 model: input.model,
                 effort: (workerCaps?.restrictWriteTools ?? false)

package/dist/src/plugin/agents/browser-qa.js

@@ -12,6 +12,10 @@ export function buildWorkerCapabilities(prompts) {
             plannerEligible: false,
             isRuntimeUnavailableResponse: (text) => text.trimStart().startsWith('PLAYWRIGHT_UNAVAILABLE:'),
             runtimeUnavailableTitle: '❌ Playwright unavailable',
+            // Pre-approve the Playwriter toolchain at the SDK level so headless sessions
+            // never stall waiting for interactive confirmation. Write tools remain blocked
+            // by restrictWriteTools and the canUseTool write-filter.
+            sessionAllowedTools: ['Skill', 'Bash', 'Read', 'Grep', 'Glob', 'LS', 'ListDirectory'],
         },
     };
 }

package/dist/src/plugin/agents/common.d.ts

@@ -12,7 +12,6 @@ export declare const ENGINEER_AGENT_IDS: {
 /** General named engineers only (Tom/John/Maya/Sara/Alex). BrowserQA is a specialist registered separately. */
 export declare const ENGINEER_AGENT_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
 export declare const CTO_ONLY_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
-export declare const ENGINEER_TOOL_IDS: readonly ["claude"];
 export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "claude"];
 export type ToolPermission = 'allow' | 'ask' | 'deny';
 export type AgentPermission = {

package/dist/src/plugin/agents/common.js

@@ -26,7 +26,7 @@ export const CTO_ONLY_TOOL_IDS = [
     'approval_decisions',
     'approval_update',
 ];
-export const ENGINEER_TOOL_IDS = ['claude'];
+const ENGINEER_TOOL_IDS = ['claude'];
 export const ALL_RESTRICTED_TOOL_IDS = [...CTO_ONLY_TOOL_IDS, ...ENGINEER_TOOL_IDS];
 export const CTO_READONLY_TOOLS = {
     read: 'allow',

package/dist/src/plugin/agents/index.d.ts

@@ -1,6 +1,5 @@
-export { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, ALL_RESTRICTED_TOOL_IDS, buildEngineerPermissions, CTO_ONLY_TOOL_IDS, CTO_READONLY_TOOLS, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, ENGINEER_TOOL_IDS, } from './common.js';
-export type { AgentPermission, ToolPermission } from './common.js';
+export { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from './common.js';
 export { buildCtoAgentConfig } from './cto.js';
 export { buildTeamPlannerAgentConfig } from './team-planner.js';
 export { buildEngineerAgentConfig } from './engineers.js';
-export { buildBrowserQaAgentConfig, buildWorkerCapabilities } from './browser-qa.js';
+export { buildBrowserQaAgentConfig } from './browser-qa.js';

package/dist/src/plugin/agents/index.js

@@ -1,5 +1,5 @@
-export { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, ALL_RESTRICTED_TOOL_IDS, buildEngineerPermissions, CTO_ONLY_TOOL_IDS, CTO_READONLY_TOOLS, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, ENGINEER_TOOL_IDS, } from './common.js';
+export { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from './common.js';
 export { buildCtoAgentConfig } from './cto.js';
 export { buildTeamPlannerAgentConfig } from './team-planner.js';
 export { buildEngineerAgentConfig } from './engineers.js';
-export { buildBrowserQaAgentConfig, buildWorkerCapabilities } from './browser-qa.js';
+export { buildBrowserQaAgentConfig } from './browser-qa.js';