@doingdev/opencode-claude-manager-plugin 0.1.35 → 0.1.43

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

@@ -0,0 +1,208 @@
+import { describe, expect, it, vi } from 'vitest';
+import { PersistentManager } from '../src/manager/persistent-manager.js';
+import { ContextTracker } from '../src/manager/context-tracker.js';
+function emptyContext() {
+    return {
+        sessionId: null,
+        totalTurns: 0,
+        totalCostUsd: 0,
+        latestInputTokens: null,
+        latestOutputTokens: null,
+        contextWindowSize: null,
+        estimatedContextPercent: null,
+        warningLevel: 'ok',
+        compactionCount: 0,
+    };
+}
+function createMockSessionController() {
+    return {
+        isActive: false,
+        sessionId: null,
+        sendMessage: vi.fn(async () => ({
+            sessionId: 'ses_mock',
+            events: [],
+            finalText: 'Task completed.',
+            turns: 2,
+            totalCostUsd: 0.03,
+            inputTokens: 20_000,
+            outputTokens: 1_000,
+            contextWindowSize: 200_000,
+        })),
+        compactSession: vi.fn(async () => ({
+            sessionId: 'ses_mock',
+            events: [],
+            finalText: 'Compacted.',
+            turns: 3,
+            totalCostUsd: 0.04,
+        })),
+        clearSession: vi.fn(async () => 'ses_mock'),
+        getContextSnapshot: vi.fn(() => emptyContext()),
+        tryRestore: vi.fn(async () => false),
+    };
+}
+function createMockGitOps() {
+    return {
+        diff: vi.fn(async () => ({
+            hasDiff: true,
+            diffText: 'diff --git a/file.ts\n+new line',
+            stats: { filesChanged: 1, insertions: 1, deletions: 0 },
+        })),
+        commit: vi.fn(async () => ({
+            success: true,
+            output: '[main abc1234] test commit',
+        })),
+        resetHard: vi.fn(async () => ({
+            success: true,
+            output: 'HEAD is now at abc1234',
+        })),
+        diffStat: vi.fn(async () => '1 file changed, 1 insertion(+)'),
+        currentBranch: vi.fn(async () => 'main'),
+        recentCommits: vi.fn(async () => 'abc1234 initial'),
+    };
+}
+function createMockStateStore() {
+    const runs = new Map();
+    return {
+        saveRun: vi.fn(async (run) => {
+            runs.set(run.id, structuredClone(run));
+        }),
+        getRun: vi.fn(async (_cwd, runId) => runs.get(runId) ?? null),
+        listRuns: vi.fn(async () => [...runs.values()]),
+        updateRun: vi.fn(async (_cwd, runId, update) => {
+            const existing = runs.get(runId);
+            if (!existing) {
+                throw new Error(`Run ${runId} not found`);
+            }
+            const updated = update(existing);
+            runs.set(runId, structuredClone(updated));
+            return updated;
+        }),
+    };
+}
+function createMockTranscriptStore() {
+    return {
+        appendEvents: vi.fn(async () => { }),
+        readEvents: vi.fn(async () => []),
+    };
+}
+describe('PersistentManager', () => {
+    it('sends a message through the session controller', async () => {
+        const sessionCtrl = createMockSessionController();
+        const gitOps = createMockGitOps();
+        const store = createMockStateStore();
+        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(result.finalText).toBe('Task completed.');
+        expect(result.inputTokens).toBe(20_000);
+        expect(result.outputTokens).toBe(1_000);
+        expect(result.contextWindowSize).toBe(200_000);
+        expect(result.context).toBeDefined();
+    });
+    it('persists transcript events on sendMessage', async () => {
+        const sessionCtrl = createMockSessionController();
+        sessionCtrl.sendMessage.mockResolvedValueOnce({
+            sessionId: 'ses_tx',
+            events: [
+                { type: 'init', text: 'init' },
+                { type: 'assistant', text: 'Done.' },
+                { type: 'result', text: 'Done.', turns: 1, totalCostUsd: 0.01 },
+            ],
+            finalText: 'Done.',
+            turns: 1,
+            totalCostUsd: 0.01,
+        });
+        const transcriptStore = createMockTranscriptStore();
+        const manager = new PersistentManager(sessionCtrl, createMockGitOps(), createMockStateStore(), new ContextTracker(), transcriptStore);
+        await manager.sendMessage('/tmp', 'do something');
+        expect(transcriptStore.appendEvents).toHaveBeenCalledWith('/tmp', 'ses_tx', [
+            { type: 'init', text: 'init' },
+            { type: 'assistant', text: 'Done.' },
+            { type: 'result', text: 'Done.', turns: 1, totalCostUsd: 0.01 },
+        ]);
+    });
+    it('skips transcript persistence when events are empty', async () => {
+        const transcriptStore = createMockTranscriptStore();
+        const manager = new PersistentManager(createMockSessionController(), createMockGitOps(), createMockStateStore(), new ContextTracker(), transcriptStore);
+        await manager.sendMessage('/tmp', 'hello');
+        expect(transcriptStore.appendEvents).not.toHaveBeenCalled();
+    });
+    it('delegates git diff to GitOperations', async () => {
+        const sessionCtrl = createMockSessionController();
+        const gitOps = createMockGitOps();
+        const store = createMockStateStore();
+        const tracker = new ContextTracker();
+        const manager = new PersistentManager(sessionCtrl, gitOps, store, tracker, createMockTranscriptStore());
+        const diff = await manager.gitDiff();
+        expect(diff.hasDiff).toBe(true);
+        expect(diff.stats.filesChanged).toBe(1);
+    });
+    it('delegates git commit to GitOperations', async () => {
+        const sessionCtrl = createMockSessionController();
+        const gitOps = createMockGitOps();
+        const store = createMockStateStore();
+        const tracker = new ContextTracker();
+        const manager = new PersistentManager(sessionCtrl, gitOps, store, tracker, createMockTranscriptStore());
+        const result = await manager.gitCommit('feat: add X');
+        expect(gitOps.commit).toHaveBeenCalledWith('feat: add X');
+        expect(result.success).toBe(true);
+    });
+    it('delegates git reset to GitOperations', async () => {
+        const sessionCtrl = createMockSessionController();
+        const gitOps = createMockGitOps();
+        const store = createMockStateStore();
+        const tracker = new ContextTracker();
+        const manager = new PersistentManager(sessionCtrl, gitOps, store, tracker, createMockTranscriptStore());
+        const result = await manager.gitReset();
+        expect(gitOps.resetHard).toHaveBeenCalled();
+        expect(result.success).toBe(true);
+    });
+    it('executes a task with run tracking', async () => {
+        const sessionCtrl = createMockSessionController();
+        const gitOps = createMockGitOps();
+        const store = createMockStateStore();
+        const tracker = new ContextTracker();
+        const manager = new PersistentManager(sessionCtrl, gitOps, store, tracker, createMockTranscriptStore());
+        const result = await manager.executeTask('/tmp', 'add tests');
+        expect(result.run.status).toBe('completed');
+        expect(result.run.task).toBe('add tests');
+        expect(result.run.finalSummary).toBe('Task completed.');
+        expect(result.run.messages).toHaveLength(2);
+        expect(result.run.messages[0].direction).toBe('sent');
+        expect(result.run.messages[1].direction).toBe('received');
+        // Verify state was persisted
+        expect(store.saveRun).toHaveBeenCalled();
+        expect(store.updateRun).toHaveBeenCalled();
+    });
+    it('marks run as failed when session throws', async () => {
+        const sessionCtrl = createMockSessionController();
+        sessionCtrl.sendMessage.mockRejectedValueOnce(new Error('SDK connection failed'));
+        const gitOps = createMockGitOps();
+        const store = createMockStateStore();
+        const tracker = new ContextTracker();
+        const manager = new PersistentManager(sessionCtrl, gitOps, store, tracker, createMockTranscriptStore());
+        const result = await manager.executeTask('/tmp', 'failing task');
+        expect(result.run.status).toBe('failed');
+        expect(result.run.finalSummary).toBe('SDK connection failed');
+    });
+    it('clears session via controller', async () => {
+        const sessionCtrl = createMockSessionController();
+        const gitOps = createMockGitOps();
+        const store = createMockStateStore();
+        const tracker = new ContextTracker();
+        const manager = new PersistentManager(sessionCtrl, gitOps, store, tracker, createMockTranscriptStore());
+        const cleared = await manager.clearSession('/tmp');
+        expect(cleared).toBe('ses_mock');
+        expect(sessionCtrl.clearSession).toHaveBeenCalledWith('/tmp');
+    });
+    it('returns status from session controller', () => {
+        const sessionCtrl = createMockSessionController();
+        const gitOps = createMockGitOps();
+        const store = createMockStateStore();
+        const tracker = new ContextTracker();
+        const manager = new PersistentManager(sessionCtrl, gitOps, store, tracker, createMockTranscriptStore());
+        const status = manager.getStatus();
+        expect(status).toEqual(emptyContext());
+    });
+});

package/dist/test/project-context.test.d.ts

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

package/dist/test/project-context.test.js

@@ -0,0 +1,92 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { discoverProjectClaudeFiles } from '../src/util/project-context.js';
+describe('discoverProjectClaudeFiles', () => {
+    const dirs = [];
+    async function makeTmp() {
+        const d = await mkdtemp(join(tmpdir(), 'ctx-test-'));
+        dirs.push(d);
+        return d;
+    }
+    afterEach(async () => {
+        for (const d of dirs) {
+            await rm(d, { recursive: true, force: true });
+        }
+        dirs.length = 0;
+    });
+    it('returns empty array when no Claude files exist', async () => {
+        const cwd = await makeTmp();
+        expect(await discoverProjectClaudeFiles(cwd)).toEqual([]);
+    });
+    it('discovers root CLAUDE.md', async () => {
+        const cwd = await makeTmp();
+        await writeFile(join(cwd, 'CLAUDE.md'), 'project rules\n');
+        const files = await discoverProjectClaudeFiles(cwd);
+        expect(files).toEqual([{ relativePath: 'CLAUDE.md', content: 'project rules' }]);
+    });
+    it('discovers nested CLAUDE.md files recursively', async () => {
+        const cwd = await makeTmp();
+        await writeFile(join(cwd, 'CLAUDE.md'), 'root rules');
+        await mkdir(join(cwd, 'packages/core'), { recursive: true });
+        await writeFile(join(cwd, 'packages/core/CLAUDE.md'), 'core rules');
+        const files = await discoverProjectClaudeFiles(cwd);
+        expect(files).toHaveLength(2);
+        expect(files[0].relativePath).toBe('CLAUDE.md');
+        expect(files[1].relativePath).toBe('packages/core/CLAUDE.md');
+    });
+    it('discovers files under .claude/ recursively', async () => {
+        const cwd = await makeTmp();
+        await mkdir(join(cwd, '.claude/settings'), { recursive: true });
+        await writeFile(join(cwd, '.claude/CLAUDE.md'), 'claude dir md');
+        await writeFile(join(cwd, '.claude/settings/config.txt'), 'some config');
+        const files = await discoverProjectClaudeFiles(cwd);
+        expect(files).toHaveLength(2);
+        expect(files.map((f) => f.relativePath)).toEqual([
+            '.claude/CLAUDE.md',
+            '.claude/settings/config.txt',
+        ]);
+    });
+    it('deduplicates when a file matches both CLAUDE.md walk and .claude/ walk', async () => {
+        const cwd = await makeTmp();
+        await mkdir(join(cwd, '.claude'), { recursive: true });
+        await writeFile(join(cwd, '.claude/CLAUDE.md'), 'shared content');
+        const files = await discoverProjectClaudeFiles(cwd);
+        expect(files).toHaveLength(1);
+        expect(files[0].relativePath).toBe('.claude/CLAUDE.md');
+        expect(files[0].content).toBe('shared content');
+    });
+    it('skips blank/whitespace-only files', async () => {
+        const cwd = await makeTmp();
+        await writeFile(join(cwd, 'CLAUDE.md'), '   \n  \n');
+        expect(await discoverProjectClaudeFiles(cwd)).toEqual([]);
+    });
+    it('trims content whitespace', async () => {
+        const cwd = await makeTmp();
+        await writeFile(join(cwd, 'CLAUDE.md'), '\n  hello world  \n\n');
+        const files = await discoverProjectClaudeFiles(cwd);
+        expect(files[0].content).toBe('hello world');
+    });
+    it('returns deterministic sorted order', async () => {
+        const cwd = await makeTmp();
+        await mkdir(join(cwd, 'b'), { recursive: true });
+        await mkdir(join(cwd, 'a'), { recursive: true });
+        await writeFile(join(cwd, 'b/CLAUDE.md'), 'b rules');
+        await writeFile(join(cwd, 'a/CLAUDE.md'), 'a rules');
+        await writeFile(join(cwd, 'CLAUDE.md'), 'root rules');
+        const files = await discoverProjectClaudeFiles(cwd);
+        expect(files.map((f) => f.relativePath)).toEqual(['CLAUDE.md', 'a/CLAUDE.md', 'b/CLAUDE.md']);
+    });
+    it('skips node_modules and .git directories', async () => {
+        const cwd = await makeTmp();
+        await mkdir(join(cwd, 'node_modules/pkg'), { recursive: true });
+        await writeFile(join(cwd, 'node_modules/pkg/CLAUDE.md'), 'should not appear');
+        await mkdir(join(cwd, '.git/hooks'), { recursive: true });
+        await writeFile(join(cwd, '.git/hooks/CLAUDE.md'), 'should not appear');
+        await writeFile(join(cwd, 'CLAUDE.md'), 'root');
+        const files = await discoverProjectClaudeFiles(cwd);
+        expect(files).toHaveLength(1);
+        expect(files[0].relativePath).toBe('CLAUDE.md');
+    });
+});

package/dist/test/prompt-registry.test.d.ts

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

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

@@ -0,0 +1,256 @@
+import { describe, expect, it } from 'vitest';
+import { composeWrapperPrompt, 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);
+    });
+});

package/dist/test/session-controller.test.d.ts

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