@doingdev/opencode-claude-manager-plugin 0.1.60 → 0.1.62

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

@@ -1,9 +1,9 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { mkdtemp, rm } from 'node:fs/promises';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { ClaudeManagerPlugin } from '../src/plugin/claude-manager.plugin.js';
-import { AGENT_CTO, AGENT_TEAM_PLANNER, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from '../src/plugin/agent-hierarchy.js';
+import { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from '../src/plugin/agent-hierarchy.js';
 import { clearPluginServices } from '../src/plugin/service-factory.js';
 describe('ClaudeManagerPlugin', () => {
     it('configures CTO with orchestration tools and question access', async () => {
@@ -31,8 +31,6 @@ describe('ClaudeManagerPlugin', () => {
             question: 'allow',
             team_status: 'allow',
             reset_engineer: 'allow',
-            confirm_plan: 'allow',
-            advance_slice: 'allow',
             git_diff: 'allow',
             git_commit: 'allow',
             git_reset: 'allow',
@@ -99,7 +97,7 @@ describe('ClaudeManagerPlugin', () => {
             expect(agent.permission).not.toHaveProperty('grep');
         }
     });
-    it('configures team-planner as a planning-bridge subagent', async () => {
+    it('configures team-planner as a thin planning wrapper subagent', async () => {
         const plugin = await ClaudeManagerPlugin({
             worktree: '/tmp/project',
         });
@@ -118,6 +116,7 @@ describe('ClaudeManagerPlugin', () => {
         });
         expect(teamPlanner.permission).not.toHaveProperty('read');
         expect(teamPlanner.permission).not.toHaveProperty('grep');
+        expect(teamPlanner.permission).not.toHaveProperty('glob');
     });
     it('registers the named engineer bridge and team status tools', async () => {
         const plugin = await ClaudeManagerPlugin({
@@ -127,8 +126,6 @@ describe('ClaudeManagerPlugin', () => {
         expect(tools['claude']).toBeDefined();
         expect(tools['team_status']).toBeDefined();
         expect(tools['plan_with_team']).toBeDefined();
-        expect(tools['confirm_plan']).toBeDefined();
-        expect(tools['advance_slice']).toBeDefined();
         expect(tools['reset_engineer']).toBeDefined();
         expect(tools['assign_engineer']).toBeUndefined();
     });
@@ -152,62 +149,13 @@ describe('ClaudeManagerPlugin', () => {
         expect(modelSchema.safeParse(undefined).success).toBe(true);
         expect(modelSchema.safeParse('claude-haiku-4-5').success).toBe(false);
     });
-    it('confirm_plan tool validates taskSize enum and requires summary', async () => {
+    it('does not expose explicit plan tracking tools', async () => {
         const plugin = await ClaudeManagerPlugin({
             worktree: '/tmp/project',
         });
         const tools = plugin.tool;
-        const confirmPlan = tools['confirm_plan'];
-        expect(confirmPlan).toBeDefined();
-        const summarySchema = confirmPlan.args.summary;
-        const taskSizeSchema = confirmPlan.args.taskSize;
-        const slicesSchema = confirmPlan.args.slices;
-        const preAuthorizedSchema = confirmPlan.args.preAuthorized;
-        expect(summarySchema.safeParse('Billing refactor').success).toBe(true);
-        expect(summarySchema.safeParse('').success).toBe(false);
-        expect(taskSizeSchema.safeParse('trivial').success).toBe(true);
-        expect(taskSizeSchema.safeParse('simple').success).toBe(true);
-        expect(taskSizeSchema.safeParse('large').success).toBe(true);
-        expect(taskSizeSchema.safeParse('medium').success).toBe(false);
-        expect(taskSizeSchema.safeParse('huge').success).toBe(false);
-        // slices is optional — absent and array both valid
-        expect(slicesSchema.safeParse(undefined).success).toBe(true);
-        expect(slicesSchema.safeParse(['slice A', 'slice B']).success).toBe(true);
-        // preAuthorized is optional boolean
-        expect(preAuthorizedSchema.safeParse(true).success).toBe(true);
-        expect(preAuthorizedSchema.safeParse(false).success).toBe(true);
-        expect(preAuthorizedSchema.safeParse(undefined).success).toBe(true);
-    });
-    it('advance_slice tool validates sliceIndex and optional status enum', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const tools = plugin.tool;
-        const advanceSlice = tools['advance_slice'];
-        expect(advanceSlice).toBeDefined();
-        const sliceIndexSchema = advanceSlice.args.sliceIndex;
-        const statusSchema = advanceSlice.args.status;
-        expect(sliceIndexSchema.safeParse(0).success).toBe(true);
-        expect(sliceIndexSchema.safeParse(2).success).toBe(true);
-        expect(sliceIndexSchema.safeParse('0').success).toBe(false);
-        expect(statusSchema.safeParse('done').success).toBe(true);
-        expect(statusSchema.safeParse('skipped').success).toBe(true);
-        expect(statusSchema.safeParse(undefined).success).toBe(true);
-        expect(statusSchema.safeParse('in_progress').success).toBe(false);
-    });
-    it('confirm_plan and advance_slice are denied for engineers', async () => {
-        const plugin = await ClaudeManagerPlugin({
-            worktree: '/tmp/project',
-        });
-        const config = {};
-        await plugin.config?.(config);
-        const agents = (config.agent ?? {});
-        for (const engineer of ENGINEER_AGENT_NAMES) {
-            const agentId = ENGINEER_AGENT_IDS[engineer];
-            const agent = agents[agentId];
-            expect(agent.permission['confirm_plan']).toBe('deny');
-            expect(agent.permission['advance_slice']).toBe('deny');
-        }
+        expect(tools['confirm_plan']).toBeUndefined();
+        expect(tools['advance_slice']).toBeUndefined();
     });
     it('exposes hooks for CTO team tracking and wrapper memory injection', async () => {
         const plugin = await ClaudeManagerPlugin({
@@ -335,7 +283,7 @@ describe('Agent ID normalization and lookup helpers', () => {
         expect(agents['browser-qa']).toBeDefined();
     });
 });
-describe('confirm_plan and advance_slice tool execution', () => {
+describe('claude tool — engineer failure debug log', () => {
     let tempRoot;
     afterEach(async () => {
         clearPluginServices();
@@ -343,101 +291,26 @@ describe('confirm_plan and advance_slice tool execution', () => {
             await rm(tempRoot, { recursive: true, force: true });
         }
     });
-    it('confirm_plan persists an active plan and returns it as JSON', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
-        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
-        const tools = plugin.tool;
-        const context = {
-            sessionID: 'cto-sess-confirm',
-            worktree: tempRoot,
-            agent: AGENT_CTO,
-            metadata: vi.fn(),
-        };
-        const result = await tools['confirm_plan'].execute({
-            summary: 'Add billing history',
-            taskSize: 'large',
-            slices: ['user can view invoices', 'user can update payment method'],
-            preAuthorized: false,
-        }, context);
-        const activePlan = JSON.parse(result);
-        expect(activePlan['summary']).toBe('Add billing history');
-        expect(activePlan['taskSize']).toBe('large');
-        expect(activePlan['currentSliceIndex']).toBe(0);
-        expect(activePlan['preAuthorized']).toBe(false);
-        expect(activePlan['slices'].length).toBe(2);
-    });
-    it('advance_slice marks a slice done and returns updated plan state', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
-        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
-        const tools = plugin.tool;
-        const context = {
-            sessionID: 'cto-sess-advance',
-            worktree: tempRoot,
-            agent: AGENT_CTO,
-            metadata: vi.fn(),
-        };
-        // Set up plan with two slices
-        await tools['confirm_plan'].execute({
-            summary: 'Two-slice task',
-            taskSize: 'large',
-            slices: ['user can log in', 'user can log out'],
-            preAuthorized: false,
-        }, context);
-        // Advance non-final slice 0
-        const result = await tools['advance_slice'].execute({ sliceIndex: 0, status: 'done' }, context);
-        const payload = JSON.parse(result);
-        const slices = payload.activePlan['slices'];
-        expect(slices[0]['status']).toBe('done');
-        expect(payload.activePlan['currentSliceIndex']).toBe(1);
-    });
-    it('advance_slice sets currentSliceIndex to null when completing the final slice', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
-        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
-        const tools = plugin.tool;
-        const context = {
-            sessionID: 'cto-sess-final',
-            worktree: tempRoot,
-            agent: AGENT_CTO,
-            metadata: vi.fn(),
-        };
-        await tools['confirm_plan'].execute({
-            summary: 'Single-slice task',
-            taskSize: 'large',
-            slices: ['ship the feature'],
-            preAuthorized: true,
-        }, context);
-        const result = await tools['advance_slice'].execute({ sliceIndex: 0, status: 'done' }, context);
-        const payload = JSON.parse(result);
-        expect(payload.activePlan['currentSliceIndex']).toBeNull();
-    });
-    it('advance_slice throws when there is no active plan', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
-        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
-        const tools = plugin.tool;
-        const context = {
-            sessionID: 'cto-sess-no-plan',
-            worktree: tempRoot,
-            agent: AGENT_CTO,
-            metadata: vi.fn(),
-        };
-        await expect(tools['advance_slice'].execute({ sliceIndex: 0 }, context)).rejects.toThrow('has no active plan');
-    });
-    it('advance_slice throws when the slice index is invalid', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
+    it('appends an engineer_failure entry to debug.log when dispatchEngineer throws', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-failure-log-'));
         const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
         const tools = plugin.tool;
         const context = {
-            sessionID: 'cto-sess-bad-idx',
+            sessionID: 'wrapper-browserqa-fail',
             worktree: tempRoot,
-            agent: AGENT_CTO,
+            agent: AGENT_BROWSER_QA,
             metadata: vi.fn(),
         };
-        await tools['confirm_plan'].execute({
-            summary: 'Two-slice task',
-            taskSize: 'large',
-            slices: ['slice A', 'slice B'],
-            preAuthorized: false,
-        }, context);
-        await expect(tools['advance_slice'].execute({ sliceIndex: 99 }, context)).rejects.toThrow('slice index 99 does not exist');
+        // BrowserQA in implement mode throws synchronously before running a session
+        await expect(tools['claude'].execute({ mode: 'implement', message: 'Write a feature' }, context)).rejects.toThrow('modeNotSupported');
+        const logPath = join(tempRoot, '.claude-manager', 'debug.log');
+        const content = await readFile(logPath, 'utf8');
+        const entry = JSON.parse(content.trim().split('\n')[0]);
+        expect(entry.type).toBe('engineer_failure');
+        expect(entry.engineer).toBe('BrowserQA');
+        expect(entry.mode).toBe('implement');
+        expect(entry.failureKind).toBe('modeNotSupported');
+        expect(typeof entry.message).toBe('string');
+        expect(typeof entry.ts).toBe('string');
     });
 });

package/dist/test/fs-helpers.test.d.ts

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

package/dist/test/fs-helpers.test.js

@@ -0,0 +1,56 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { appendDebugLog } from '../src/util/fs-helpers.js';
+describe('appendDebugLog', () => {
+    let tmpDir;
+    afterEach(async () => {
+        if (tmpDir) {
+            await rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('creates the log file and parent directories if they do not exist', async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'fs-helpers-'));
+        const logPath = join(tmpDir, 'nested', 'dir', 'debug.log');
+        await appendDebugLog(logPath, { type: 'test', value: 42 });
+        const content = await readFile(logPath, 'utf8');
+        expect(content).toBeTruthy();
+    });
+    it('writes a valid JSON object with a ts field on each line', async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'fs-helpers-'));
+        const logPath = join(tmpDir, 'debug.log');
+        await appendDebugLog(logPath, { type: 'tool_denied', toolName: 'Edit' });
+        const content = await readFile(logPath, 'utf8');
+        const line = content.trim();
+        const entry = JSON.parse(line);
+        expect(entry.type).toBe('tool_denied');
+        expect(entry.toolName).toBe('Edit');
+        expect(typeof entry.ts).toBe('string');
+        // ts should be a valid ISO date string
+        expect(() => new Date(entry.ts).toISOString()).not.toThrow();
+    });
+    it('appends multiple entries as separate NDJSON lines', async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'fs-helpers-'));
+        const logPath = join(tmpDir, 'debug.log');
+        await appendDebugLog(logPath, { type: 'a' });
+        await appendDebugLog(logPath, { type: 'b' });
+        await appendDebugLog(logPath, { type: 'c' });
+        const content = await readFile(logPath, 'utf8');
+        const lines = content.trim().split('\n');
+        expect(lines).toHaveLength(3);
+        const types = lines.map((l) => JSON.parse(l).type);
+        expect(types).toEqual(['a', 'b', 'c']);
+    });
+    it('injected ts field overrides a ts in the entry', async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'fs-helpers-'));
+        const logPath = join(tmpDir, 'debug.log');
+        // The spread order means our ts wins over any ts in entry
+        await appendDebugLog(logPath, { ts: 'caller-value', type: 'x' });
+        const content = await readFile(logPath, 'utf8');
+        const entry = JSON.parse(content.trim());
+        // ts should be a real ISO date, not 'caller-value'
+        expect(entry.ts).not.toBe('caller-value');
+        expect(() => new Date(entry.ts).toISOString()).not.toThrow();
+    });
+});

package/dist/test/prompt-registry.test.js

@@ -1,15 +1,19 @@
 import { describe, expect, it } from 'vitest';
 import { managerPromptRegistry } from '../src/prompts/registry.js';
 describe('managerPromptRegistry', () => {
-    it('gives the CTO explicit orchestration guidance', () => {
+    it('gives the CTO investigation-first orchestration guidance', () => {
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('You are a principal engineer orchestrating a team of AI-powered engineers');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('Operating Loop');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('named engineer');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Orient → Investigate → Decide → Delegate');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('single-engineer');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('team-planner');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('question');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('Review: Inspect diffs for production safety');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('race condition');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('contextExhausted');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('adaptive, not rigid');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('revisit earlier steps');
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('Orient → Classify → Plan → Confirm → Delegate');
         expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('clear_session');
         expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('freshSession');
     });
@@ -18,11 +22,13 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.engineerAgentPrompt).toContain('claude');
         expect(managerPromptRegistry.engineerAgentPrompt).toContain('remembers your prior turns');
         expect(managerPromptRegistry.engineerAgentPrompt).toContain('wrapper context');
+        expect(managerPromptRegistry.engineerAgentPrompt).toContain('caller-directed');
         expect(managerPromptRegistry.engineerAgentPrompt).not.toContain('read/grep/glob');
     });
     it('keeps the engineer session prompt direct and repo-aware', () => {
         expect(managerPromptRegistry.engineerSessionPrompt).toContain('expert software engineer');
         expect(managerPromptRegistry.engineerSessionPrompt).toContain('Start with the smallest investigation that resolves the key uncertainty');
+        expect(managerPromptRegistry.engineerSessionPrompt).toContain('Do not default to a plan unless the caller explicitly asks for one');
         expect(managerPromptRegistry.engineerSessionPrompt).toContain('Verify your work before reporting done');
         expect(managerPromptRegistry.engineerSessionPrompt).toContain('Do not run git commit');
         expect(managerPromptRegistry.engineerSessionPrompt).toContain('rollout');
@@ -40,20 +46,18 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.planSynthesisPrompt).toContain('## Recommended Question');
         expect(managerPromptRegistry.planSynthesisPrompt).toContain('## Recommended Answer');
     });
-    it('teamPlannerPrompt directs the agent to call plan_with_team with autonomous engineer selection', () => {
+    it('teamPlannerPrompt keeps the wrapper thin and calls plan_with_team', () => {
         expect(managerPromptRegistry.teamPlannerPrompt).toContain('plan_with_team');
+        expect(managerPromptRegistry.teamPlannerPrompt).toContain('live activity in the UI');
+        expect(managerPromptRegistry.teamPlannerPrompt).toContain('Keep the wrapper thin');
         expect(managerPromptRegistry.teamPlannerPrompt).toContain('auto-select');
-        expect(managerPromptRegistry.teamPlannerPrompt).toContain('engineer');
-    });
-    it('ctoSystemPrompt includes Confirm step in operating loop before Delegate', () => {
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Orient → Classify → Plan → Confirm → Delegate');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Confirm: Get user buy-in before implementing');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('recommendedQuestion');
-        // Confirm section must appear before Delegate section in the text
-        const confirmIdx = managerPromptRegistry.ctoSystemPrompt.indexOf('## Confirm:');
-        const delegateIdx = managerPromptRegistry.ctoSystemPrompt.indexOf('## Delegate:');
-        expect(confirmIdx).toBeGreaterThan(-1);
-        expect(confirmIdx).toBeLessThan(delegateIdx);
+        expect(managerPromptRegistry.teamPlannerPrompt).toContain('pass the full result back to the CTO unchanged');
+    });
+    it('ctoSystemPrompt delegates directly when scope is clear and asks for explicit explore outputs', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('For trivial or simple work with clear scope: delegate directly to one engineer');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('expected output shape');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('root cause');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('implementation plan');
     });
     it('engineerAgentPrompt instructs engineers to surface plan deviations', () => {
         expect(managerPromptRegistry.engineerAgentPrompt).toContain('deviation');
@@ -62,14 +66,11 @@ describe('managerPromptRegistry', () => {
     it('browserQaAgentPrompt instructs browser-qa to report scope mismatches', () => {
         expect(managerPromptRegistry.browserQaAgentPrompt).toContain('scope mismatch');
     });
-    it('teamPlannerPrompt instructs planner to pass synthesis back unchanged', () => {
-        expect(managerPromptRegistry.teamPlannerPrompt).toContain('unchanged');
-    });
-    it('ctoSystemPrompt delegates single work to named engineers via task() and dual work to team-planner', () => {
+    it('ctoSystemPrompt delegates single work to named engineers and complex planning to team-planner', () => {
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('task(subagent_type:');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('single-engineer');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('team-planner');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('automatically selects');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('live UI activity');
     });
     it('ctoSystemPrompt mentions browser-qa for delegation', () => {
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('browser-qa');
@@ -92,11 +93,9 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('large');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('Task size');
     });
-    it('ctoSystemPrompt mentions confirm_plan and advance_slice for large task lifecycle', () => {
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('confirm_plan');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('advance_slice');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('preAuthorized');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('vertical slice');
+    it('ctoSystemPrompt no longer mentions explicit plan-tracking tools', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('confirm_plan');
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('advance_slice');
     });
     it('ctoSystemPrompt encodes warn-only context policy', () => {
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('Context warnings');
@@ -108,14 +107,11 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.contextWarnings.critical).toContain('Warn only');
     });
     it('ctoSystemPrompt uses genuinely vertical slice examples, not horizontal layers', () => {
-        // Horizontal layer examples (internal plumbing only) must not appear
         expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"types + contracts"');
         expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"core logic"');
         expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"plugin tools"');
-        // Prompt must describe the end-to-end / user-testable property of a slice
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('end-to-end');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('user-testable');
-        // Horizontal layers must be explicitly called out as wrong
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Horizontal layer');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Horizontal layers');
     });
 });

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

@@ -71,6 +71,8 @@ describe('TeamOrchestrator', () => {
         expect(runTask.mock.calls[0]?.[0].prompt).toContain('Base engineer prompt');
         expect(runTask.mock.calls[0]?.[0].prompt).toContain('Assigned engineer: Tom.');
         expect(runTask.mock.calls[0]?.[0].prompt).toContain('Investigate the auth flow');
+        expect(runTask.mock.calls[0]?.[0].prompt).toContain('The caller should specify the desired output');
+        expect(runTask.mock.calls[0]?.[0].prompt).not.toContain('Produce a concrete plan');
         expect(runTask.mock.calls[1]?.[0]).toMatchObject({
             resumeSessionId: 'ses_tom',
             permissionMode: 'acceptEdits',
@@ -343,6 +345,75 @@ 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.'));
+        expect(result.failureKind).toBe('modeNotSupported');
+    });
+    it('classifyError still returns sdkError for generic errors', () => {
+        const result = TeamOrchestrator.classifyError(new Error('Something unexpected happened'));
+        expect(result.failureKind).toBe('sdkError');
+    });
+    it('getFailureGuidanceText returns actionable guidance for modeNotSupported', async () => {
+        const { getFailureGuidanceText } = await import('../src/manager/team-orchestrator.js');
+        const guidance = getFailureGuidanceText('modeNotSupported');
+        expect(guidance).toContain('explore');
+        expect(guidance).toContain('verify');
+        expect(guidance).toContain('implement');
+    });
     it('setActivePlan persists plan with slices on TeamRecord', async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
         const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });

package/dist/types/contracts.d.ts

@@ -4,9 +4,9 @@ export interface ManagerPromptRegistry {
     engineerSessionPrompt: string;
     /** Prompt prepended to the user prompt of the synthesis runTask call inside plan_with_team. */
     planSynthesisPrompt: string;
-    /** Visible subagent prompt for teamPlanner — thin bridge that calls plan_with_team. */
+    /** Visible subagent prompt for teamPlanner — thin wrapper that calls plan_with_team. */
     teamPlannerPrompt: string;
-    /** Visible subagent prompt for browserQa — thin bridge that calls claude tool for browser verification. */
+    /** Visible subagent prompt for browserQa — thin wrapper that calls claude tool for browser verification. */
     browserQaAgentPrompt: string;
     /** Prompt prepended to browser verification task prompts in Claude Code sessions. */
     browserQaSessionPrompt: string;
@@ -146,7 +146,7 @@ export interface TeamEngineerRecord {
     wrapperHistory: WrapperHistoryEntry[];
     context: SessionContextSnapshot;
 }
-export type EngineerFailureKind = 'sdkError' | 'contextExhausted' | 'toolDenied' | 'aborted' | 'engineerBusy' | 'unknown';
+export type EngineerFailureKind = 'sdkError' | 'contextExhausted' | 'toolDenied' | 'modeNotSupported' | 'aborted' | 'engineerBusy' | 'unknown';
 export interface EngineerFailureResult {
     teamId: string;
     engineer: EngineerName;
@@ -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/util/fs-helpers.d.ts

@@ -1,2 +1,8 @@
 export declare function writeJsonAtomically(filePath: string, data: unknown): Promise<void>;
 export declare function isFileNotFoundError(error: unknown): error is NodeJS.ErrnoException;
+/**
+ * Appends a single NDJSON line to a debug log file.
+ * Creates the parent directory if it does not exist.
+ * A `ts` (ISO timestamp) field is injected automatically.
+ */
+export declare function appendDebugLog(logPath: string, entry: Record<string, unknown>): Promise<void>;

package/dist/util/fs-helpers.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { promises as fs } from 'node:fs';
+import path from 'node:path';
 export async function writeJsonAtomically(filePath, data) {
     const tempPath = `${filePath}.${randomUUID()}.tmp`;
     await fs.writeFile(tempPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
@@ -8,3 +9,13 @@ export async function writeJsonAtomically(filePath, data) {
 export function isFileNotFoundError(error) {
     return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
 }
+/**
+ * Appends a single NDJSON line to a debug log file.
+ * Creates the parent directory if it does not exist.
+ * A `ts` (ISO timestamp) field is injected automatically.
+ */
+export async function appendDebugLog(logPath, entry) {
+    const line = JSON.stringify({ ...entry, ts: new Date().toISOString() }) + '\n';
+    await fs.mkdir(path.dirname(logPath), { recursive: true });
+    await fs.appendFile(logPath, line, 'utf8');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.60",
+  "version": "0.1.62",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",