@doingdev/opencode-claude-manager-plugin 0.1.65 → 0.1.66

package/dist/test/file-run-state-store.test.js

@@ -1,82 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { FileRunStateStore } from '../src/state/file-run-state-store.js';
-const tempDirectories = [];
-function createRun(cwd, id) {
-    return {
-        id,
-        cwd,
-        task: 'Implement feature',
-        status: 'completed',
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        sessionId: null,
-        sessionHistory: [],
-        messages: [],
-        actions: [],
-        commits: [],
-        context: {
-            sessionId: null,
-            totalTurns: 0,
-            totalCostUsd: 0,
-            latestInputTokens: null,
-            latestOutputTokens: null,
-            contextWindowSize: null,
-            estimatedContextPercent: null,
-            warningLevel: 'ok',
-            compactionCount: 0,
-        },
-        finalSummary: 'Done.',
-    };
-}
-describe('FileRunStateStore', () => {
-    afterEach(async () => {
-        await Promise.all(tempDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
-    });
-    it('persists and reloads run records', async () => {
-        const cwd = await mkdtemp(path.join(os.tmpdir(), 'file-run-state-store-'));
-        tempDirectories.push(cwd);
-        const store = new FileRunStateStore();
-        const run = createRun(cwd, 'run_1');
-        await store.saveRun(run);
-        const loadedRun = await store.getRun(cwd, 'run_1');
-        expect(loadedRun).toMatchObject({ id: 'run_1', finalSummary: 'Done.' });
-        expect(await store.listRuns(cwd)).toHaveLength(1);
-    });
-    it('serializes concurrent updates for the same run', async () => {
-        const cwd = await mkdtemp(path.join(os.tmpdir(), 'file-run-state-store-'));
-        tempDirectories.push(cwd);
-        const store = new FileRunStateStore();
-        const run = createRun(cwd, 'run_2');
-        run.status = 'running';
-        await store.saveRun(run);
-        await Promise.all([
-            store.updateRun(cwd, 'run_2', (currentRun) => ({
-                ...currentRun,
-                messages: [
-                    ...currentRun.messages,
-                    {
-                        timestamp: new Date().toISOString(),
-                        direction: 'sent',
-                        text: 'Task A',
-                    },
-                ],
-            })),
-            store.updateRun(cwd, 'run_2', (currentRun) => ({
-                ...currentRun,
-                messages: [
-                    ...currentRun.messages,
-                    {
-                        timestamp: new Date().toISOString(),
-                        direction: 'sent',
-                        text: 'Task B',
-                    },
-                ],
-            })),
-        ]);
-        const updatedRun = await store.getRun(cwd, 'run_2');
-        expect(updatedRun?.messages.map((m) => m.text).sort()).toEqual(['Task A', 'Task B']);
-    });
-});

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

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

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

@@ -1,56 +0,0 @@
-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/git-operations.test.d.ts

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

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

@@ -1,133 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-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';
-const execFileAsync = promisify(execFile);
-async function createTestRepo() {
-    const dir = await mkdtemp(join(tmpdir(), 'git-ops-test-'));
-    await execFileAsync('git', ['init'], { cwd: dir });
-    await execFileAsync('git', ['config', 'user.email', 'test@test.com'], {
-        cwd: dir,
-    });
-    await execFileAsync('git', ['config', 'user.name', 'Test'], { cwd: dir });
-    // Create initial commit
-    await writeFile(join(dir, 'README.md'), '# Test\n');
-    await execFileAsync('git', ['add', '-A'], { cwd: dir });
-    await execFileAsync('git', ['commit', '-m', 'initial'], { cwd: dir });
-    return dir;
-}
-describe('GitOperations', () => {
-    it('reports no diff on clean repo', async () => {
-        const dir = await createTestRepo();
-        const git = new GitOperations(dir);
-        const result = await git.diff();
-        expect(result.hasDiff).toBe(false);
-        expect(result.diffText.trim()).toBe('');
-        expect(result.stats.filesChanged).toBe(0);
-    });
-    it('reports diff when files are modified', async () => {
-        const dir = await createTestRepo();
-        await writeFile(join(dir, 'README.md'), '# Changed\n');
-        const git = new GitOperations(dir);
-        const result = await git.diff();
-        expect(result.hasDiff).toBe(true);
-        expect(result.diffText).toContain('Changed');
-        expect(result.stats.filesChanged).toBe(1);
-        expect(result.stats.insertions).toBeGreaterThan(0);
-    });
-    it('commits all changes', async () => {
-        const dir = await createTestRepo();
-        await writeFile(join(dir, 'new-file.ts'), 'export const x = 1;\n');
-        const git = new GitOperations(dir);
-        const result = await git.commit('add new file');
-        expect(result.success).toBe(true);
-        expect(result.output).toContain('add new file');
-        // Verify clean after commit
-        const diff = await git.diff();
-        expect(diff.hasDiff).toBe(false);
-    });
-    it('resets hard to discard changes', async () => {
-        const dir = await createTestRepo();
-        await writeFile(join(dir, 'README.md'), '# Changed\n');
-        await writeFile(join(dir, 'untracked.ts'), 'junk');
-        const git = new GitOperations(dir);
-        const result = await git.resetHard();
-        expect(result.success).toBe(true);
-        const diff = await git.diff();
-        expect(diff.hasDiff).toBe(false);
-    });
-    it('handles commit failure on clean repo', async () => {
-        const dir = await createTestRepo();
-        const git = new GitOperations(dir);
-        const result = await git.commit('nothing to commit');
-        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.d.ts

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

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

@@ -1,48 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { PersistentManager } from '../src/manager/persistent-manager.js';
-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',
-        })),
-    };
-}
-function createMockTranscriptStore() {
-    return {
-        appendEvents: vi.fn(async () => { }),
-        readEvents: vi.fn(async () => []),
-    };
-}
-describe('PersistentManager', () => {
-    it('delegates git diff to GitOperations', async () => {
-        const gitOps = createMockGitOps();
-        const manager = new PersistentManager(gitOps, 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 gitOps = createMockGitOps();
-        const manager = new PersistentManager(gitOps, createMockTranscriptStore());
-        const result = await manager.gitCommit('feat: add X');
-        expect(gitOps.commit).toHaveBeenCalledWith('feat: add X', undefined);
-        expect(result.success).toBe(true);
-    });
-    it('delegates git reset to GitOperations', async () => {
-        const gitOps = createMockGitOps();
-        const manager = new PersistentManager(gitOps, createMockTranscriptStore());
-        const result = await manager.gitReset();
-        expect(gitOps.resetHard).toHaveBeenCalled();
-        expect(result.success).toBe(true);
-    });
-});

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

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

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

@@ -1,92 +0,0 @@
-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

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

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

@@ -1,117 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { managerPromptRegistry } from '../src/prompts/registry.js';
-describe('managerPromptRegistry', () => {
-    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('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');
-    });
-    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 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');
-        expect(managerPromptRegistry.engineerSessionPrompt).toContain('backwards compatibility');
-    });
-    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');
-    });
-    it('planSynthesisPrompt contains synthesis guidance and complete output format', () => {
-        expect(managerPromptRegistry.planSynthesisPrompt).toContain('synthesiz');
-        expect(managerPromptRegistry.planSynthesisPrompt).toContain('two independent');
-        expect(managerPromptRegistry.planSynthesisPrompt).toContain('## Synthesis');
-        expect(managerPromptRegistry.planSynthesisPrompt).toContain('## Recommended Question');
-        expect(managerPromptRegistry.planSynthesisPrompt).toContain('## Recommended Answer');
-    });
-    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('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('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('live UI activity');
-    });
-    it('ctoSystemPrompt mentions browser-qa for delegation', () => {
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('browser-qa');
-    });
-    it('browserQaAgentPrompt mentions Playwright and PLAYWRIGHT_UNAVAILABLE sentinel', () => {
-        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('Playwright');
-        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('PLAYWRIGHT_UNAVAILABLE');
-        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('browser QA');
-    });
-    it('browserQaSessionPrompt mentions Playwright and restricts write tools', () => {
-        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('Playwright');
-        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('Allowed tools');
-        expect(managerPromptRegistry.browserQaSessionPrompt).toContain('browser QA');
-        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/report-claude-event.test.d.ts

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