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

package/dist/src/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/src/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/src/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/team/roster.d.ts

@@ -1,5 +1,4 @@
 import { PLANNER_ELIGIBLE_ENGINEERS, type EngineerName, type TeamEngineerRecord, type TeamRecord } from '../types/contracts.js';
-export declare const TEAM_ENGINEERS: readonly ["Tom", "John", "Maya", "Sara", "Alex", "BrowserQA"];
 export { PLANNER_ELIGIBLE_ENGINEERS };
 export declare function isEngineerName(value: string): value is EngineerName;
 export declare function createEmptyTeamRecord(teamId: string, cwd: string): TeamRecord;

package/dist/src/team/roster.js

@@ -1,5 +1,5 @@
 import { DEFAULT_ENGINEER_NAMES, PLANNER_ELIGIBLE_ENGINEERS, } from '../types/contracts.js';
-export const TEAM_ENGINEERS = DEFAULT_ENGINEER_NAMES;
+const TEAM_ENGINEERS = DEFAULT_ENGINEER_NAMES;
 export { PLANNER_ELIGIBLE_ENGINEERS };
 export function isEngineerName(value) {
     return TEAM_ENGINEERS.includes(value);

package/dist/src/types/contracts.d.ts

@@ -206,6 +206,13 @@ export interface WorkerCapabilities {
     isRuntimeUnavailableResponse?: (finalText: string) => boolean;
     /** Metadata title for the runtime-unavailable event. */
     runtimeUnavailableTitle?: string;
+    /**
+     * Explicit SDK-level pre-approval list for this worker's inner Claude Code session.
+     * Tools in this list bypass interactive confirmation prompts (they are still subject to
+     * the `canUseTool` write-restriction and approval-policy filters).
+     * Absent = falls back to `['Skill']` via the default adapter behaviour.
+     */
+    sessionAllowedTools?: string[];
 }
 export interface GitDiffResult {
     hasDiff: boolean;

package/dist/team/roster.d.ts

@@ -1,5 +1,4 @@
 import { PLANNER_ELIGIBLE_ENGINEERS, type EngineerName, type TeamEngineerRecord, type TeamRecord } from '../types/contracts.js';
-export declare const TEAM_ENGINEERS: readonly ["Tom", "John", "Maya", "Sara", "Alex", "BrowserQA"];
 export { PLANNER_ELIGIBLE_ENGINEERS };
 export declare function isEngineerName(value: string): value is EngineerName;
 export declare function createEmptyTeamRecord(teamId: string, cwd: string): TeamRecord;

package/dist/team/roster.js

@@ -1,5 +1,5 @@
 import { DEFAULT_ENGINEER_NAMES, PLANNER_ELIGIBLE_ENGINEERS, } from '../types/contracts.js';
-export const TEAM_ENGINEERS = DEFAULT_ENGINEER_NAMES;
+const TEAM_ENGINEERS = DEFAULT_ENGINEER_NAMES;
 export { PLANNER_ELIGIBLE_ENGINEERS };
 export function isEngineerName(value) {
     return TEAM_ENGINEERS.includes(value);

package/dist/test/claude-agent-sdk-adapter.test.js

@@ -498,6 +498,45 @@ describe('ClaudeAgentSdkAdapter', () => {
         const gitLogResult = await capturedCanUseTool('Bash', { command: 'git log --oneline -10' }, {});
         expect(gitLogResult.behavior).toBe('allow');
     });
+    it('allows Playwriter-style bash commands when restrictWriteTools is true', async () => {
+        let capturedCanUseTool;
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: (params) => {
+                capturedCanUseTool = params.options?.canUseTool;
+                return createFakeQuery([
+                    {
+                        type: 'result',
+                        subtype: 'success',
+                        session_id: 'ses_playwriter',
+                        is_error: false,
+                        result: 'ok',
+                        num_turns: 1,
+                        total_cost_usd: 0,
+                    },
+                ]);
+            },
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'Run Playwriter tests',
+            restrictWriteTools: true,
+        });
+        expect(capturedCanUseTool).toBeDefined();
+        // Non-destructive Playwriter commands must be allowed
+        const playwriterResult = await capturedCanUseTool('Bash', { command: 'playwriter session new' }, {});
+        expect(playwriterResult.behavior).toBe('allow');
+        const npxResult = await capturedCanUseTool('Bash', { command: 'npx playwriter session new' }, {});
+        expect(npxResult.behavior).toBe('allow');
+        const listResult = await capturedCanUseTool('Bash', { command: 'playwriter session list' }, {});
+        expect(listResult.behavior).toBe('allow');
+        // Destructive commands must still be denied
+        const rmResult = await capturedCanUseTool('Bash', { command: 'rm -rf /tmp/screenshots' }, {});
+        expect(rmResult.behavior).toBe('deny');
+        const redirectResult = await capturedCanUseTool('Bash', { command: 'echo "data" > out.txt' }, {});
+        expect(redirectResult.behavior).toBe('deny');
+    });
     it('allows write tools when restrictWriteTools is false', async () => {
         let capturedCanUseTool;
         const adapter = new ClaudeAgentSdkAdapter({

package/dist/test/team-orchestrator.test.js

@@ -345,6 +345,59 @@ describe('TeamOrchestrator', () => {
         expect(error.message).toContain('BrowserQA is a browser QA specialist');
         expect(error.message).toContain('does not support implement mode');
     });
+    it('forwards sessionAllowedTools to runTask when worker has them configured', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'browserqa-allowed-'));
+        const runTask = vi.fn().mockResolvedValueOnce({
+            sessionId: 'ses_qa',
+            events: [],
+            finalText: 'Done.',
+            turns: 1,
+            totalCostUsd: 0.01,
+            inputTokens: 500,
+            outputTokens: 100,
+            contextWindowSize: 200_000,
+        });
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Engineer prompt', 'Synthesis prompt', {
+            BrowserQA: {
+                ...BROWSER_QA_TEST_CAPS,
+                sessionAllowedTools: ['Skill', 'Bash', 'Read', 'Grep', 'Glob', 'LS', 'ListDirectory'],
+            },
+        });
+        await orchestrator.dispatchEngineer({
+            teamId: 'team-1',
+            cwd: tempRoot,
+            engineer: 'BrowserQA',
+            mode: 'explore',
+            message: 'Run Playwriter tests',
+        });
+        expect(runTask).toHaveBeenCalledOnce();
+        const taskInput = runTask.mock.calls[0]?.[0];
+        expect(taskInput.allowedTools).toEqual(expect.arrayContaining(['Skill', 'Bash', 'Read', 'Grep', 'Glob', 'LS', 'ListDirectory']));
+    });
+    it('passes undefined allowedTools for standard engineers without sessionAllowedTools', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'engineer-no-allowed-'));
+        const runTask = vi.fn().mockResolvedValueOnce({
+            sessionId: 'ses_tom',
+            events: [],
+            finalText: 'Done.',
+            turns: 1,
+            totalCostUsd: 0.01,
+            inputTokens: 500,
+            outputTokens: 100,
+            contextWindowSize: 200_000,
+        });
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        await orchestrator.dispatchEngineer({
+            teamId: 'team-1',
+            cwd: tempRoot,
+            engineer: 'Tom',
+            mode: 'explore',
+            message: 'Investigate something',
+        });
+        expect(runTask).toHaveBeenCalledOnce();
+        const taskInput = runTask.mock.calls[0]?.[0];
+        expect(taskInput.allowedTools).toBeUndefined();
+    });
     it('classifyError returns modeNotSupported for implement-mode rejection', () => {
         const result = TeamOrchestrator.classifyError(new Error('BrowserQA is a browser QA specialist and does not support implement mode. ' +
             'It can only verify and explore.'));

package/dist/test/undo-propagation.test.d.ts

@@ -0,0 +1 @@
+export {};