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

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,16 +46,31 @@ 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');
+        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');
+        expect(managerPromptRegistry.engineerAgentPrompt).toContain('surface');
     });
-    it('ctoSystemPrompt delegates single work to named engineers via task() and dual work to team-planner', () => {
+    it('browserQaAgentPrompt instructs browser-qa to report scope mismatches', () => {
+        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('scope mismatch');
+    });
+    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');
@@ -66,4 +87,31 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.browserQaSessionPrompt).not.toContain('implement');
         expect(managerPromptRegistry.browserQaSessionPrompt).not.toContain('write code');
     });
+    it('ctoSystemPrompt encodes task size classification (trivial/simple/large)', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('trivial');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('simple');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('large');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Task size');
+    });
+    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');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('advisory');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('contextExhausted');
+    });
+    it('contextWarnings reflect warn-only policy for critical level', () => {
+        expect(managerPromptRegistry.contextWarnings.critical).toContain('near capacity');
+        expect(managerPromptRegistry.contextWarnings.critical).toContain('Warn only');
+    });
+    it('ctoSystemPrompt uses genuinely vertical slice examples, not horizontal layers', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"types + contracts"');
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"core logic"');
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"plugin tools"');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('end-to-end');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('user-testable');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Horizontal layers');
+    });
 });

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

@@ -44,7 +44,8 @@ describe('TeamOrchestrator', () => {
             outputTokens: 300,
             contextWindowSize: 200_000,
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        const store = new TeamStateStore('.state');
+        const orchestrator = new TeamOrchestrator({ runTask }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         const first = await orchestrator.dispatchEngineer({
             teamId: 'team-1',
             cwd: tempRoot,
@@ -70,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',
@@ -78,6 +81,8 @@ describe('TeamOrchestrator', () => {
         expect(runTask.mock.calls[1]?.[0].systemPrompt).toBeUndefined();
         expect(runTask.mock.calls[1]?.[0].prompt).not.toContain('Assigned engineer: Tom.');
         expect(runTask.mock.calls[1]?.[0].prompt).toContain('Implement the chosen fix');
+        // Hybrid workflow: implement mode must include a pre-implementation plan step
+        expect(runTask.mock.calls[1]?.[0].prompt).toContain('state a brief implementation plan');
         const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
         expect(team.engineers.find((engineer) => engineer.name === 'Tom')).toMatchObject({
             claudeSessionId: 'ses_tom',
@@ -301,7 +306,8 @@ describe('TeamOrchestrator', () => {
                 contextWindowSize: 200_000,
             };
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        const store = new TeamStateStore('.state');
+        const orchestrator = new TeamOrchestrator({ runTask }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         const allEvents = [];
         const result = await orchestrator.dispatchEngineer({
             teamId: 'team-1',
@@ -339,6 +345,174 @@ describe('TeamOrchestrator', () => {
         expect(error.message).toContain('BrowserQA is a browser QA specialist');
         expect(error.message).toContain('does not support implement mode');
     });
+    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 });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        const activePlan = await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Implement billing refactor in three slices',
+            taskSize: 'large',
+            slices: ['types + contracts', 'core logic', 'tests'],
+            preAuthorized: false,
+        });
+        expect(activePlan.id).toMatch(/^plan-/);
+        expect(activePlan.summary).toBe('Implement billing refactor in three slices');
+        expect(activePlan.taskSize).toBe('large');
+        expect(activePlan.preAuthorized).toBe(false);
+        expect(activePlan.slices).toHaveLength(3);
+        expect(activePlan.slices[0]).toMatchObject({
+            index: 0,
+            description: 'types + contracts',
+            status: 'pending',
+        });
+        expect(activePlan.slices[1]).toMatchObject({
+            index: 1,
+            description: 'core logic',
+            status: 'pending',
+        });
+        expect(activePlan.slices[2]).toMatchObject({
+            index: 2,
+            description: 'tests',
+            status: 'pending',
+        });
+        expect(activePlan.currentSliceIndex).toBe(0);
+        expect(activePlan.confirmedAt).not.toBeNull();
+        const retrieved = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(retrieved).toMatchObject({ id: activePlan.id, taskSize: 'large' });
+    });
+    it('clearActivePlan removes activePlan from 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 });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Small task',
+            taskSize: 'simple',
+            slices: [],
+            preAuthorized: false,
+        });
+        const beforeClear = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(beforeClear).not.toBeNull();
+        await orchestrator.clearActivePlan(tempRoot, 'team-1');
+        const afterClear = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(afterClear).toBeNull();
+    });
+    it('updateActivePlanSlice marks a slice done and advances currentSliceIndex', 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 });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Two-slice task',
+            taskSize: 'large',
+            slices: ['slice A', 'slice B'],
+            preAuthorized: true,
+        });
+        await orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done');
+        const plan = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(plan).not.toBeNull();
+        expect(plan.slices[0]).toMatchObject({ index: 0, status: 'done' });
+        expect(plan.slices[0].completedAt).toBeDefined();
+        expect(plan.slices[1]).toMatchObject({ index: 1, status: 'pending' });
+        expect(plan.currentSliceIndex).toBe(1);
+    });
+    it('updateActivePlanSlice sets currentSliceIndex to null when the final slice is completed', 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 });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Single-slice task',
+            taskSize: 'large',
+            slices: ['ship the feature'],
+            preAuthorized: true,
+        });
+        // Complete the only slice (index 0, which is also the last)
+        await orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done');
+        const plan = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(plan).not.toBeNull();
+        expect(plan.slices[0]).toMatchObject({ index: 0, status: 'done' });
+        expect(plan.currentSliceIndex).toBeNull();
+    });
+    it('setActivePlan sets currentSliceIndex to null when no slices are provided', 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 });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        const plan = await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Simple no-slice task',
+            taskSize: 'simple',
+            slices: [],
+            preAuthorized: false,
+        });
+        expect(plan.currentSliceIndex).toBeNull();
+        expect(plan.slices).toHaveLength(0);
+    });
+    it('updateActivePlanSlice throws when team has no active plan', 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 });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await expect(orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done')).rejects.toThrow('has no active plan');
+    });
+    it('updateActivePlanSlice throws when slice index does not exist', 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 });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Two-slice task',
+            taskSize: 'large',
+            slices: ['slice A', 'slice B'],
+            preAuthorized: false,
+        });
+        // Index 5 does not exist (only 0 and 1 exist)
+        await expect(orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 5, 'done')).rejects.toThrow('slice index 5 does not exist');
+    });
+    it('updateActivePlanSlice throws when active plan has no slices', 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 });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'No-slice plan',
+            taskSize: 'simple',
+            slices: [],
+            preAuthorized: false,
+        });
+        await expect(orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done')).rejects.toThrow('plan has no slices');
+    });
+    it('getActivePlan returns null for a new team with no active plan', 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 });
+        const plan = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(plan).toBeNull();
+    });
+    it('normalizeTeamRecord preserves activePlan from persisted records', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const store = new TeamStateStore('.state');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Persist test',
+            taskSize: 'simple',
+            slices: [],
+            preAuthorized: false,
+        });
+        // Re-read via getOrCreateTeam (triggers normalizeTeamRecord)
+        const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        expect(team.activePlan).toBeDefined();
+        expect(team.activePlan.summary).toBe('Persist test');
+    });
     it('selectPlanEngineers excludes BrowserQA from planner selection', async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'planner-exclude-browserqa-'));
         const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, '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;
@@ -116,6 +116,24 @@ export interface SessionContextSnapshot {
     warningLevel: ContextWarningLevel;
     compactionCount: number;
 }
+export type TaskSize = 'trivial' | 'simple' | 'large';
+export interface PlanSlice {
+    index: number;
+    description: string;
+    status: 'pending' | 'in_progress' | 'done' | 'skipped';
+    completedAt?: string;
+}
+export interface ActivePlan {
+    id: string;
+    summary: string;
+    taskSize: TaskSize;
+    createdAt: string;
+    confirmedAt: string | null;
+    preAuthorized: boolean;
+    slices: PlanSlice[];
+    /** Null when the plan has no slices (trivial/simple tasks). */
+    currentSliceIndex: number | null;
+}
 export interface TeamEngineerRecord {
     name: EngineerName;
     wrapperSessionId: string | null;
@@ -128,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;
@@ -142,6 +160,7 @@ export interface TeamRecord {
     createdAt: string;
     updatedAt: string;
     engineers: TeamEngineerRecord[];
+    activePlan?: ActivePlan;
 }
 export interface EngineerTaskResult {
     teamId: string;

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.59",
+  "version": "0.1.61",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",