@doingdev/opencode-claude-manager-plugin 0.1.46 → 0.1.49

package/dist/test/cto-active-team.test.js

@@ -0,0 +1,52 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { mkdtemp, 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 { clearPluginServices, getActiveTeamSession } from '../src/plugin/service-factory.js';
+import { AGENT_CTO } from '../src/plugin/agent-hierarchy.js';
+import { TeamStateStore } from '../src/state/team-state-store.js';
+describe('CTO chat.message — persisted active team', () => {
+    let tempRoot;
+    beforeEach(async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'cto-team-'));
+        clearPluginServices();
+    });
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot) {
+            await rm(tempRoot, { recursive: true, force: true });
+        }
+    });
+    it('persists the active team on the first CTO message', async () => {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'session-cto-1' });
+        const store = new TeamStateStore('.claude-manager');
+        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('session-cto-1');
+        expect(getActiveTeamSession(tempRoot)).toBe('session-cto-1');
+    });
+    it('a new CTO session adopts the already-persisted active team instead of overwriting it', async () => {
+        const store = new TeamStateStore('.claude-manager');
+        // Simulate a pre-existing persisted active team (e.g., from a previous process run).
+        await store.setActiveTeam(tempRoot, 'old-team-id');
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        // New CTO session with a different session ID.
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'brand-new-cto-session' });
+        // The persisted active team must NOT be overwritten.
+        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('old-team-id');
+        // The in-memory registry must point to the persisted team, NOT the new session.
+        expect(getActiveTeamSession(tempRoot)).toBe('old-team-id');
+    });
+    it('does not overwrite the persisted team across two CTO messages in the same session', async () => {
+        const store = new TeamStateStore('.claude-manager');
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'session-cto-1' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'session-cto-1' });
+        // Still the original session — persisted.
+        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('session-cto-1');
+        expect(getActiveTeamSession(tempRoot)).toBe('session-cto-1');
+    });
+});

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/report-claude-event.test.d.ts

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