@doingdev/opencode-claude-manager-plugin 0.1.44 → 0.1.47

package/dist/test/git-operations.test.js

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { mkdtemp, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { GitOperations } from '../src/manager/git-operations.js';
@@ -87,4 +87,68 @@ describe('GitOperations', () => {
         expect(result.success).toBe(false);
         expect(result.error).toBeDefined();
     });
+    it('filters diff by paths', async () => {
+        const dir = await createTestRepo();
+        await mkdir(join(dir, 'src'), { recursive: true });
+        await writeFile(join(dir, 'src/index.ts'), 'export const x = 1;\n');
+        await writeFile(join(dir, 'README.md'), '# Changed\n');
+        const git = new GitOperations(dir);
+        // Stage the new file so git diff can see it
+        await execFileAsync('git', ['add', 'src/index.ts'], { cwd: dir });
+        const result = await git.diff({ paths: ['src'] });
+        expect(result.hasDiff).toBe(true);
+        expect(result.diffText).toContain('src/index.ts');
+        expect(result.diffText).not.toContain('README.md');
+    });
+    it('shows staged diff when staged=true', async () => {
+        const dir = await createTestRepo();
+        await writeFile(join(dir, 'README.md'), '# Changed\n');
+        const git = new GitOperations(dir);
+        // First commit the current state
+        await execFileAsync('git', ['add', 'README.md'], { cwd: dir });
+        // Now make another change
+        await writeFile(join(dir, 'README.md'), '# Changed more\n');
+        await execFileAsync('git', ['add', 'README.md'], { cwd: dir });
+        const result = await git.diff({ staged: true });
+        expect(result.hasDiff).toBe(true);
+        expect(result.diffText).toContain('Changed more');
+    });
+    it('compares against arbitrary ref', async () => {
+        const dir = await createTestRepo();
+        await writeFile(join(dir, 'README.md'), '# Changed\n');
+        const git = new GitOperations(dir);
+        const result = await git.diff({ ref: 'HEAD' });
+        expect(result.hasDiff).toBe(true);
+        expect(result.diffText).toContain('Changed');
+    });
+    it('returns status with isClean false when changes exist', async () => {
+        const dir = await createTestRepo();
+        await writeFile(join(dir, 'README.md'), '# Changed\n');
+        const git = new GitOperations(dir);
+        const result = await git.status();
+        expect(result.isClean).toBe(false);
+        expect(result.output).toContain('README.md');
+    });
+    it('returns status with isClean true on clean repo', async () => {
+        const dir = await createTestRepo();
+        const git = new GitOperations(dir);
+        const result = await git.status();
+        expect(result.isClean).toBe(true);
+        expect(result.output).toBe('');
+    });
+    it('returns log with custom count', async () => {
+        const dir = await createTestRepo();
+        const git = new GitOperations(dir);
+        // Add more commits
+        await writeFile(join(dir, 'file1.txt'), '1');
+        await execFileAsync('git', ['add', '-A'], { cwd: dir });
+        await execFileAsync('git', ['commit', '-m', 'commit 1'], { cwd: dir });
+        await writeFile(join(dir, 'file2.txt'), '2');
+        await execFileAsync('git', ['add', '-A'], { cwd: dir });
+        await execFileAsync('git', ['commit', '-m', 'commit 2'], { cwd: dir });
+        const result = await git.log(3);
+        expect(result).toContain('commit 2');
+        expect(result).toContain('commit 1');
+        expect(result).toContain('initial');
+    });
 });

package/dist/test/persistent-manager.test.js

@@ -93,7 +93,7 @@ describe('PersistentManager', () => {
         const tracker = new ContextTracker();
         const manager = new PersistentManager(sessionCtrl, gitOps, store, tracker, createMockTranscriptStore());
         const result = await manager.sendMessage('/tmp', 'implement feature X');
-        expect(sessionCtrl.sendMessage).toHaveBeenCalledWith('/tmp', 'implement feature X', undefined, undefined);
+        expect(sessionCtrl.sendMessage).toHaveBeenCalledWith('implement feature X', undefined, undefined);
         expect(result.finalText).toBe('Task completed.');
         expect(result.inputTokens).toBe(20_000);
         expect(result.outputTokens).toBe(1_000);
@@ -192,9 +192,9 @@ describe('PersistentManager', () => {
         const store = createMockStateStore();
         const tracker = new ContextTracker();
         const manager = new PersistentManager(sessionCtrl, gitOps, store, tracker, createMockTranscriptStore());
-        const cleared = await manager.clearSession('/tmp');
+        const cleared = await manager.clearSession();
         expect(cleared).toBe('ses_mock');
-        expect(sessionCtrl.clearSession).toHaveBeenCalledWith('/tmp');
+        expect(sessionCtrl.clearSession).toHaveBeenCalled();
     });
     it('returns status from session controller', () => {
         const sessionCtrl = createMockSessionController();

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

@@ -1,256 +1,36 @@
 import { describe, expect, it } from 'vitest';
-import { composeWrapperPrompt, managerPromptRegistry } from '../src/prompts/registry.js';
+import { managerPromptRegistry } from '../src/prompts/registry.js';
 describe('managerPromptRegistry', () => {
-    describe('ctoSystemPrompt', () => {
-        it('establishes technical owner identity', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('technical owner');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('not a ticket-taker');
-        });
-        it('instructs to discover the right problem before solving', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('discover the right problem before solving it');
-        });
-        it('checks for hidden assumptions and root causes', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Hidden assumptions');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('root causes');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('abstraction leaks');
-        });
-        it('includes missed-opportunity check', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Missed-opportunity check');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('cleaner alternative');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('requester likely missed');
-        });
-        it('puts verification-first as core principle', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('verification-first');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Every delegation MUST include how to verify success');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('single highest-leverage');
-        });
-        it('right-sizes approach by complexity', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Simple tasks');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Medium+ tasks');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Complex tasks');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Right-size your approach');
-        });
-        it('requires self-contained delegation with context', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('does not have your context');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('self-contained');
-        });
-        it('requires review after every delegation', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Review every change');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('read the FULL diff');
-        });
-        it('forbids delegating without verification criteria', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Do NOT delegate without verification criteria');
-        });
-        it('establishes delegation-first as core principle', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('delegation-first');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('default action is to delegate');
-        });
-        it('limits direct lookups before delegating', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('more than 2 direct read/grep/glob lookups');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('stop and delegate');
-        });
-        it('prefers engineer_plan for repo exploration', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Prefer spawning `engineer_plan` for repo exploration');
-        });
-        it('instructs using the Task tool to invoke engineers', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Task tool');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('engineer_plan');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('engineer_build');
-        });
-        it('forbids direct engineer_* tool calls', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Do NOT call any engineer_* tools directly');
-        });
-        it('includes context efficiency guidance', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Context efficiency');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('freshSession');
-        });
-        it('references CTO-owned tools', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('git_diff');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('git_commit');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('git_reset');
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('todowrite');
-        });
-        it('does not reference Claude Code session internals', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('compact_context');
-            expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('session_health');
-            expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('clear_session');
-        });
-        it('includes autonomy blockers', () => {
-            expect(managerPromptRegistry.ctoSystemPrompt).toContain('Autonomy blockers');
-        });
-    });
-    describe('engineerPlanPrompt', () => {
-        it('establishes staff engineer identity, not a relay', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('staff engineer');
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('not a forwarding layer');
-        });
-        it('includes repo-context investigation guidance', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('Repo-context investigation');
-        });
-        it('uses read/grep/glob sparingly', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('read/grep/glob sparingly');
-        });
-        it('delegates after more than 2 lookups', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('more than 2 lookups are needed, send the investigation to the engineer');
-        });
-        it('includes architecture framing guidance', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('real problem');
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('cleanest architecture');
-        });
-        it('allows one high-leverage clarification', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('ONE clarification first if it materially improves architecture');
-        });
-        it('forbids implementation by the wrapper itself', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('Do NOT implement changes yourself');
-        });
-        it('does not prohibit self-investigation', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).not.toContain('Do NOT investigate on your own');
-        });
-        it('instructs using the plan-mode send tool', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('explore');
-        });
-        it('includes context management', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('session_health');
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('compact_context');
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('clear_session');
-        });
-        it('includes freshSession guidance', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('freshSession:true');
-        });
-        it('requires verbatim response', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('verbatim');
-        });
-        it('includes Project Claude Files guidance', () => {
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('Using appended Project Claude Files');
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('Extract only the rules relevant to the current task');
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('specific/nested paths over root-level guidance');
-            expect(managerPromptRegistry.engineerPlanPrompt).toContain('Direct user instructions override Claude-file guidance');
-        });
-    });
-    describe('engineerBuildPrompt', () => {
-        it('establishes staff engineer identity, not a relay', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('staff engineer');
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('not a forwarding layer');
-        });
-        it('includes repo-context investigation guidance', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('Repo-context investigation');
-        });
-        it('uses read/grep/glob sparingly', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('read/grep/glob sparingly');
-        });
-        it('delegates after more than 2 lookups', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('more than 2 lookups are needed, send the investigation to the engineer');
-        });
-        it('includes architecture framing guidance', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('real problem');
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('cleanest architecture');
-        });
-        it('allows one high-leverage clarification', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('ONE clarification first if it materially improves architecture');
-        });
-        it('forbids implementation by the wrapper itself', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('Do NOT implement changes yourself');
-        });
-        it('does not prohibit self-investigation', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).not.toContain('Do NOT investigate on your own');
-        });
-        it('instructs using the build-mode send tool', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('implement');
-        });
-        it('includes context management', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('session_health');
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('compact_context');
-        });
-        it('includes freshSession guidance', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('freshSession:true');
-        });
-        it('includes effort max for hard problems', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('effort "max"');
-        });
-        it('requires verbatim response', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('verbatim');
-        });
-        it('includes Project Claude Files guidance', () => {
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('Using appended Project Claude Files');
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('Extract only the rules relevant to the current task');
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('specific/nested paths over root-level guidance');
-            expect(managerPromptRegistry.engineerBuildPrompt).toContain('Direct user instructions override Claude-file guidance');
-        });
-    });
-    describe('engineerSessionPrompt', () => {
-        it('establishes expert engineer identity', () => {
-            expect(managerPromptRegistry.engineerSessionPrompt).toContain('expert engineer');
-        });
-        it('requires self-verification', () => {
-            expect(managerPromptRegistry.engineerSessionPrompt).toContain('verify your own work before reporting done');
-        });
-        it('runs tests even if not explicitly asked', () => {
-            expect(managerPromptRegistry.engineerSessionPrompt).toContain('still run relevant tests if they exist');
-        });
-        it('forbids git operations', () => {
-            expect(managerPromptRegistry.engineerSessionPrompt).toContain('git commit');
-            expect(managerPromptRegistry.engineerSessionPrompt).toContain('do NOT run');
-        });
-        it('requires structured reporting', () => {
-            expect(managerPromptRegistry.engineerSessionPrompt).toContain('what was done, what was verified, what passed/failed');
-        });
-    });
-    describe('modePrefixes', () => {
-        it('has both plan and free keys', () => {
-            expect(managerPromptRegistry.modePrefixes).toHaveProperty('plan');
-            expect(managerPromptRegistry.modePrefixes).toHaveProperty('free');
-        });
-        it('plan prefix enforces read-only', () => {
-            expect(managerPromptRegistry.modePrefixes.plan).toContain('PLAN MODE');
-            expect(managerPromptRegistry.modePrefixes.plan).toContain('Do NOT create or edit');
-        });
-        it('free prefix is empty', () => {
-            expect(managerPromptRegistry.modePrefixes.free).toBe('');
-        });
-    });
-    describe('contextWarnings', () => {
-        it('ships templates with placeholders', () => {
-            expect(managerPromptRegistry.contextWarnings.moderate).toContain('{percent}');
-            expect(managerPromptRegistry.contextWarnings.high).toContain('{turns}');
-            expect(managerPromptRegistry.contextWarnings.critical).toContain('Clear the session');
-        });
-    });
-});
-describe('composeWrapperPrompt', () => {
-    const base = 'You manage a Claude Code engineer.';
-    it('returns base prompt unchanged when no Claude files provided', () => {
-        expect(composeWrapperPrompt(base, [])).toBe(base);
-    });
-    it('appends a single file with path-labeled section', () => {
-        const files = [
-            { relativePath: 'CLAUDE.md', content: 'Use pnpm. No default exports.' },
-        ];
-        const result = composeWrapperPrompt(base, files);
-        expect(result).toContain('## Project Claude Files');
-        expect(result).toContain('### CLAUDE.md');
-        expect(result).toContain('Use pnpm. No default exports.');
-    });
-    it('appends multiple files with distinct path headers', () => {
-        const files = [
-            { relativePath: 'CLAUDE.md', content: 'root rules' },
-            { relativePath: '.claude/settings.md', content: 'settings content' },
-            { relativePath: 'packages/core/CLAUDE.md', content: 'core rules' },
-        ];
-        const result = composeWrapperPrompt(base, files);
-        expect(result).toContain('### CLAUDE.md\nroot rules');
-        expect(result).toContain('### .claude/settings.md\nsettings content');
-        expect(result).toContain('### packages/core/CLAUDE.md\ncore rules');
-    });
-    it('preserves multi-line file content', () => {
-        const files = [
-            { relativePath: 'CLAUDE.md', content: 'Line one\nLine two\nLine three' },
-        ];
-        const result = composeWrapperPrompt(base, files);
-        expect(result).toContain('Line one\nLine two\nLine three');
-    });
-    it('starts with the base prompt', () => {
-        const files = [{ relativePath: 'CLAUDE.md', content: 'rules' }];
-        const result = composeWrapperPrompt(base, files);
-        expect(result.startsWith(base)).toBe(true);
+    it('gives the CTO explicit orchestration guidance', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('You are the CTO');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Task tool');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('spawn two engineers in parallel');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('question');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Tom, John, Maya, Sara, and Alex');
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('clear_session');
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('freshSession');
+    });
+    it('keeps the engineer wrapper prompt short and tool-focused', () => {
+        expect(managerPromptRegistry.engineerAgentPrompt).toContain('named engineer');
+        expect(managerPromptRegistry.engineerAgentPrompt).toContain('claude');
+        expect(managerPromptRegistry.engineerAgentPrompt).toContain('remembers prior turns');
+        expect(managerPromptRegistry.engineerAgentPrompt).toContain('wrapper context');
+        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('Execute directly');
+        expect(managerPromptRegistry.engineerSessionPrompt).toContain('Verify your own work');
+        expect(managerPromptRegistry.engineerSessionPrompt).toContain('Do not run git commit');
+    });
+    it('still exposes plan and free mode prefixes', () => {
+        expect(managerPromptRegistry.modePrefixes.plan).toContain('PLAN MODE');
+        expect(managerPromptRegistry.modePrefixes.plan).toContain('Read-only');
+        expect(managerPromptRegistry.modePrefixes.free).toBe('');
+    });
+    it('keeps context warnings available for engineer sessions', () => {
+        expect(managerPromptRegistry.contextWarnings.moderate).toContain('{percent}');
+        expect(managerPromptRegistry.contextWarnings.high).toContain('{turns}');
+        expect(managerPromptRegistry.contextWarnings.critical).toContain('near capacity');
     });
 });

package/dist/test/session-controller.test.js

@@ -25,9 +25,9 @@ describe('SessionController', () => {
     it('creates a new session on first sendMessage', async () => {
         const adapter = createMockAdapter();
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test prompt');
+        const controller = new SessionController(adapter, tracker, 'test prompt', 'test', '/tmp');
         expect(controller.isActive).toBe(false);
-        const result = await controller.sendMessage('/tmp', 'hello');
+        const result = await controller.sendMessage('hello');
         expect(controller.isActive).toBe(true);
         expect(controller.sessionId).toBe('ses_test');
         expect(result.finalText).toBe('Done.');
@@ -39,17 +39,17 @@ describe('SessionController', () => {
     it('sends settingSources as user-only', async () => {
         const adapter = createMockAdapter();
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await controller.sendMessage('/tmp', 'hello');
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await controller.sendMessage('hello');
         const call = adapter.runSession.mock.calls[0][0];
         expect(call.settingSources).toEqual(['user']);
     });
     it('resumes session on subsequent sends', async () => {
         const adapter = createMockAdapter([{}, {}]);
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test prompt');
-        await controller.sendMessage('/tmp', 'first');
-        await controller.sendMessage('/tmp', 'second');
+        const controller = new SessionController(adapter, tracker, 'test prompt', 'test', '/tmp');
+        await controller.sendMessage('first');
+        await controller.sendMessage('second');
         const secondCall = adapter.runSession.mock.calls[1][0];
         expect(secondCall.resumeSessionId).toBe('ses_test');
         expect(secondCall.systemPrompt).toBeUndefined();
@@ -57,8 +57,8 @@ describe('SessionController', () => {
     it('updates context tracker on each message', async () => {
         const adapter = createMockAdapter([{ turns: 3, totalCostUsd: 0.05, inputTokens: 50_000 }]);
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await controller.sendMessage('/tmp', 'task');
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await controller.sendMessage('task');
         const snap = controller.getContextSnapshot();
         expect(snap.totalTurns).toBe(3);
         expect(snap.totalCostUsd).toBe(0.05);
@@ -68,10 +68,10 @@ describe('SessionController', () => {
     it('clears session and resets context', async () => {
         const adapter = createMockAdapter();
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await controller.sendMessage('/tmp', 'task');
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await controller.sendMessage('task');
         expect(controller.isActive).toBe(true);
-        const clearedId = await controller.clearSession('/tmp');
+        const clearedId = await controller.clearSession();
         expect(clearedId).toBe('ses_test');
         expect(controller.isActive).toBe(false);
         expect(controller.sessionId).toBeNull();
@@ -82,9 +82,9 @@ describe('SessionController', () => {
     it('sends /compact to current session', async () => {
         const adapter = createMockAdapter([{}, {}]);
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await controller.sendMessage('/tmp', 'task');
-        await controller.compactSession('/tmp');
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await controller.sendMessage('task');
+        await controller.compactSession();
         const compactCall = adapter.runSession.mock.calls[1][0];
         expect(compactCall.prompt).toBe('/compact');
         expect(compactCall.resumeSessionId).toBe('ses_test');
@@ -92,14 +92,14 @@ describe('SessionController', () => {
     it('throws when compacting without active session', async () => {
         const adapter = createMockAdapter();
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await expect(controller.compactSession('/tmp')).rejects.toThrow('No active session to compact');
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await expect(controller.compactSession()).rejects.toThrow('No active session to compact');
     });
     it('threads effort through to the SDK input', async () => {
         const adapter = createMockAdapter();
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await controller.sendMessage('/tmp', 'hard task', { effort: 'max' });
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await controller.sendMessage('hard task', { effort: 'max' });
         const call = adapter.runSession.mock.calls[0][0];
         expect(call.effort).toBe('max');
     });
@@ -111,8 +111,8 @@ describe('SessionController', () => {
         it('defaults to free mode with acceptEdits permissionMode', async () => {
             const adapter = createMockAdapter();
             const tracker = new ContextTracker();
-            const controller = new SessionController(adapter, tracker, 'test', modePrefixes);
-            await controller.sendMessage('/tmp', 'do something');
+            const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp', modePrefixes);
+            await controller.sendMessage('do something');
             const call = adapter.runSession.mock.calls[0][0];
             expect(call.permissionMode).toBe('acceptEdits');
             expect(call.prompt).toBe('do something');
@@ -120,8 +120,8 @@ describe('SessionController', () => {
         it('sets permissionMode to plan and prepends prefix in plan mode', async () => {
             const adapter = createMockAdapter();
             const tracker = new ContextTracker();
-            const controller = new SessionController(adapter, tracker, 'test', modePrefixes);
-            await controller.sendMessage('/tmp', 'analyze this', { mode: 'plan' });
+            const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp', modePrefixes);
+            await controller.sendMessage('analyze this', { mode: 'plan' });
             const call = adapter.runSession.mock.calls[0][0];
             expect(call.permissionMode).toBe('plan');
             expect(call.prompt).toBe('[PLAN MODE] Read-only planning.\n\nanalyze this');
@@ -129,8 +129,8 @@ describe('SessionController', () => {
         it('explicit free mode uses acceptEdits and no prefix', async () => {
             const adapter = createMockAdapter();
             const tracker = new ContextTracker();
-            const controller = new SessionController(adapter, tracker, 'test', modePrefixes);
-            await controller.sendMessage('/tmp', 'build it', { mode: 'free' });
+            const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp', modePrefixes);
+            await controller.sendMessage('build it', { mode: 'free' });
             const call = adapter.runSession.mock.calls[0][0];
             expect(call.permissionMode).toBe('acceptEdits');
             expect(call.prompt).toBe('build it');
@@ -138,8 +138,8 @@ describe('SessionController', () => {
         it('works without modePrefixes constructor arg (backward compat)', async () => {
             const adapter = createMockAdapter();
             const tracker = new ContextTracker();
-            const controller = new SessionController(adapter, tracker, 'test');
-            await controller.sendMessage('/tmp', 'hello', { mode: 'plan' });
+            const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+            await controller.sendMessage('hello', { mode: 'plan' });
             const call = adapter.runSession.mock.calls[0][0];
             expect(call.permissionMode).toBe('plan');
             // Empty prefix defaults — prompt should be unchanged

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

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