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

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

@@ -1,45 +1,5 @@
 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 () => ({
@@ -55,28 +15,6 @@ function createMockGitOps() {
             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() {
@@ -86,123 +24,25 @@ function createMockTranscriptStore() {
     };
 }
 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('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 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 sessionCtrl = createMockSessionController();
         const gitOps = createMockGitOps();
-        const store = createMockStateStore();
-        const tracker = new ContextTracker();
-        const manager = new PersistentManager(sessionCtrl, gitOps, store, tracker, createMockTranscriptStore());
+        const manager = new PersistentManager(gitOps, createMockTranscriptStore());
         const result = await manager.gitCommit('feat: add X');
-        expect(gitOps.commit).toHaveBeenCalledWith('feat: add X');
+        expect(gitOps.commit).toHaveBeenCalledWith('feat: add X', undefined);
         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 manager = new PersistentManager(gitOps, 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();
-        expect(cleared).toBe('ses_mock');
-        expect(sessionCtrl.clearSession).toHaveBeenCalled();
-    });
-    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/prompt-registry.test.js

@@ -2,9 +2,9 @@ import { describe, expect, it } from 'vitest';
 import { managerPromptRegistry } from '../src/prompts/registry.js';
 describe('managerPromptRegistry', () => {
     it('gives the CTO explicit orchestration guidance', () => {
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('You are the CTO');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('You are a principal engineer orchestrating a team of AI-powered engineers');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('Task tool');
-        expect(managerPromptRegistry.ctoSystemPrompt).toContain('spawn two engineers in parallel');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('dispatch two engineers with complementary perspectives');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('question');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('Tom, John, Maya, Sara, and Alex');
         expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('clear_session');
@@ -13,21 +13,16 @@ describe('managerPromptRegistry', () => {
     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('remembers your 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('Start with the smallest investigation that resolves the key uncertainty');
         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}');

package/dist/test/report-claude-event.test.d.ts

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

package/dist/test/report-claude-event.test.js

@@ -0,0 +1,246 @@
+/**
+ * Tests for reportClaudeEvent via the real plugin onEvent chain,
+ * plus integration tests for second-invocation continuity across
+ * clearPluginServices() / new plugin instance.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } 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, getOrCreatePluginServices, } from '../src/plugin/service-factory.js';
+import { AGENT_CTO, ENGINEER_AGENT_IDS } from '../src/plugin/agent-hierarchy.js';
+import { TeamStateStore } from '../src/state/team-state-store.js';
+import { TeamOrchestrator } from '../src/manager/team-orchestrator.js';
+function makeContext(worktree, agentId, sessionID) {
+    const metadata = vi.fn();
+    const ctx = {
+        metadata,
+        worktree,
+        sessionID,
+        agent: agentId,
+        abort: new AbortController().signal,
+    };
+    return { metadata, ctx };
+}
+function makeDispatchResult(override = {}) {
+    const context = {
+        sessionId: 'ses-tom-1',
+        totalTurns: 1,
+        totalCostUsd: 0.01,
+        latestInputTokens: 500,
+        latestOutputTokens: 100,
+        contextWindowSize: 200_000,
+        estimatedContextPercent: 0.5,
+        warningLevel: 'ok',
+        compactionCount: 0,
+    };
+    return {
+        teamId: 'team-1',
+        engineer: 'Tom',
+        mode: 'explore',
+        sessionId: 'ses-tom-1',
+        finalText: 'done',
+        turns: 1,
+        totalCostUsd: 0.01,
+        inputTokens: 500,
+        outputTokens: 100,
+        contextWindowSize: 200_000,
+        context,
+        ...override,
+    };
+}
+async function executeClaude(plugin, ctx, args = { mode: 'explore', message: 'do work' }) {
+    const claudeTool = plugin.tool['claude'];
+    return claudeTool.execute(args, ctx);
+}
+// ── reportClaudeEvent via the plugin's onEvent chain ────────────────────────
+describe('reportClaudeEvent — via plugin onEvent chain', () => {
+    let tempRoot;
+    beforeEach(async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'report-event-'));
+        clearPluginServices();
+    });
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot)
+            await rm(tempRoot, { recursive: true, force: true });
+    });
+    /**
+     * Helper: creates a plugin, sets the active CTO team, then stubs
+     * dispatchEngineer so it fires the given events before returning.
+     */
+    async function setupPlugin(events) {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        const services = getOrCreatePluginServices(tempRoot);
+        vi.spyOn(services.orchestrator, 'dispatchEngineer').mockImplementation(async (input) => {
+            for (const event of events) {
+                await input.onEvent?.(event);
+            }
+            return makeDispatchResult();
+        });
+        vi.spyOn(services.orchestrator, 'recordWrapperExchange').mockResolvedValue(undefined);
+        return { plugin, services };
+    }
+    it('surfaces tool name, args, and toolId from a tool_call event', async () => {
+        const event = {
+            type: 'tool_call',
+            sessionId: 'ses-1',
+            text: JSON.stringify({ name: 'read', id: 'call-abc', input: { file_path: '/foo.ts' } }),
+        };
+        const { plugin } = await setupPlugin([event]);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.Tom, 'wrapper-1');
+        await executeClaude(plugin, ctx);
+        const call = metadata.mock.calls.find(([c]) => c?.title?.includes('→'))?.[0];
+        expect(call).toBeDefined();
+        expect(call.title).toBe('⚡ Tom → Reading: /foo.ts');
+        expect(call.metadata.toolName).toBe('read');
+        expect(call.metadata.toolId).toBe('call-abc');
+        expect(call.metadata.toolArgs).toEqual({ file_path: '/foo.ts' });
+        expect(call.metadata.sessionId).toBe('ses-1');
+        expect(call.metadata.engineer).toBe('Tom');
+    });
+    it('double-decodes a JSON-string input (tool input serialised twice)', async () => {
+        // The SDK adapter may serialize `input` as a JSON string inside the outer JSON on
+        // some tool calls. The handler should parse the inner string into an object.
+        const event = {
+            type: 'tool_call',
+            sessionId: 'ses-2',
+            text: JSON.stringify({
+                name: 'bash',
+                id: 'call-def',
+                input: JSON.stringify({ command: 'ls -la' }),
+            }),
+        };
+        const { plugin } = await setupPlugin([event]);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.Tom, 'wrapper-2');
+        await executeClaude(plugin, ctx);
+        const call = metadata.mock.calls.find(([c]) => c?.title?.includes('→'))?.[0];
+        expect(call.title).toBe('⚡ Tom → Running: ls -la');
+        expect(call.metadata.toolArgs).toEqual({ command: 'ls -la' });
+    });
+    it('falls back to generic title and omits tool fields when event.text is not JSON', async () => {
+        const event = {
+            type: 'tool_call',
+            sessionId: 'ses-3',
+            text: 'not-json-at-all',
+        };
+        const { plugin } = await setupPlugin([event]);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.Tom, 'wrapper-3');
+        await executeClaude(plugin, ctx);
+        const call = metadata.mock.calls.find(([c]) => c?.title?.includes('is using Claude Code tools'))?.[0];
+        expect(call).toBeDefined();
+        expect(call.title).toBe('⚡ Tom is using Claude Code tools');
+        expect(call.metadata).not.toHaveProperty('toolName');
+        expect(call.metadata).not.toHaveProperty('toolId');
+        expect(call.metadata).not.toHaveProperty('toolArgs');
+    });
+    it('falls back to generic title when parsed JSON has no name field', async () => {
+        const event = {
+            type: 'tool_call',
+            sessionId: 'ses-4',
+            text: JSON.stringify({ id: 'call-xyz', input: {} }),
+        };
+        const { plugin } = await setupPlugin([event]);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.John, 'wrapper-4');
+        await executeClaude(plugin, ctx);
+        const call = metadata.mock.calls.find(([c]) => c?.title?.includes('is using Claude Code tools'))?.[0];
+        expect(call).toBeDefined();
+        expect(call.metadata).not.toHaveProperty('toolName');
+    });
+    it('includes toolArgs when input is an empty object', async () => {
+        const event = {
+            type: 'tool_call',
+            sessionId: 'ses-5',
+            text: JSON.stringify({ name: 'git_status', id: 'call-ghi', input: {} }),
+        };
+        const { plugin } = await setupPlugin([event]);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.Maya, 'wrapper-5');
+        await executeClaude(plugin, ctx);
+        const call = metadata.mock.calls.find(([c]) => c?.title?.includes('→'))?.[0];
+        expect(call.title).toBe('⚡ Maya → git_status');
+        expect(call.metadata.toolArgs).toEqual({});
+    });
+});
+// ── Second-invocation continuity ─────────────────────────────────────────────
+describe('second invocation continuity', () => {
+    let tempRoot;
+    beforeEach(async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'continuity-'));
+        clearPluginServices();
+    });
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot)
+            await rm(tempRoot, { recursive: true, force: true });
+    });
+    it('wrapper memory is injected after clearPluginServices and a new plugin instance', async () => {
+        // ── Phase 1: first task via orchestrator (no real SDK needed) ──────────
+        const store = new TeamStateStore();
+        await store.setActiveTeam(tempRoot, 'cto-1');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', []);
+        await orchestrator.recordWrapperSession(tempRoot, 'cto-1', 'Tom', 'wrapper-tom-1');
+        await orchestrator.recordWrapperExchange(tempRoot, 'cto-1', 'Tom', 'wrapper-tom-1', 'explore', 'Investigate the auth flow', 'Found two race conditions in the token refresh path.');
+        // ── Phase 2: process restart ───────────────────────────────────────────
+        clearPluginServices();
+        // ── Phase 3: new plugin instance, new CTO session ──────────────────────
+        const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage2 = plugin2['chat.message'];
+        const systemTransform2 = plugin2['experimental.chat.system.transform'];
+        // New CTO session must adopt the persisted team, not create a new one.
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
+        expect(getActiveTeamSession(tempRoot)).toBe('cto-1');
+        // Tom's new wrapper session must be registered under the persisted team.
+        await chatMessage2({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-2' });
+        // Transform fires (after chat.message has registered the session mapping).
+        const output = { system: [] };
+        await systemTransform2({ sessionID: 'wrapper-tom-2', model: 'claude-sonnet-4-6' }, output);
+        expect(output.system).toHaveLength(1);
+        expect(output.system[0]).toContain('Persistent wrapper memory for Tom');
+        expect(output.system[0]).toContain('Investigate the auth flow');
+        expect(output.system[0]).toContain('Found two race conditions');
+    });
+    it('existing engineer Claude session is resumed on second invocation', async () => {
+        // ── Phase 1: pre-seed Tom with a claudeSessionId ───────────────────────
+        const store = new TeamStateStore();
+        await store.setActiveTeam(tempRoot, 'cto-1');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', []);
+        await orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
+        await store.updateTeam(tempRoot, 'cto-1', (team) => ({
+            ...team,
+            engineers: team.engineers.map((e) => e.name === 'Tom' ? { ...e, claudeSessionId: 'ses-tom-persisted' } : e),
+        }));
+        // ── Phase 2: process restart ───────────────────────────────────────────
+        clearPluginServices();
+        // ── Phase 3: new plugin, new CTO, engineer runs second task ───────────
+        const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage2 = plugin2['chat.message'];
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
+        await chatMessage2({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-2' });
+        const services2 = getOrCreatePluginServices(tempRoot);
+        // Mock at the session level so dispatchEngineer runs its real logic
+        // (reads claudeSessionId, passes resumeSessionId to runTask).
+        const runTask = vi.spyOn(services2.sessions, 'runTask').mockResolvedValue({
+            sessionId: 'ses-tom-persisted',
+            events: [],
+            finalText: 'resumed result',
+            turns: 2,
+            totalCostUsd: 0.02,
+            inputTokens: 1000,
+            outputTokens: 200,
+            contextWindowSize: 200_000,
+        });
+        vi.spyOn(services2.orchestrator, 'recordWrapperExchange').mockResolvedValue(undefined);
+        const { ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.Tom, 'wrapper-tom-2');
+        await executeClaude(plugin2, ctx);
+        // dispatchEngineer should have read claudeSessionId='ses-tom-persisted' from
+        // the team store and forwarded it as resumeSessionId.
+        expect(runTask).toHaveBeenCalledOnce();
+        expect(runTask.mock.calls[0]?.[0]).toMatchObject({
+            resumeSessionId: 'ses-tom-persisted',
+            systemPrompt: undefined, // no new system prompt when resuming
+        });
+    });
+});

package/dist/test/team-state-store.test.js

@@ -51,4 +51,22 @@ describe('TeamStateStore', () => {
             { id: 'older' },
         ]);
     });
+    it('returns null for active team when no active-team.json exists', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
+        const store = new TeamStateStore('.state');
+        await expect(store.getActiveTeam(tempRoot)).resolves.toBeNull();
+    });
+    it('persists and reads back the active team ID', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
+        const store = new TeamStateStore('.state');
+        await store.setActiveTeam(tempRoot, 'team-abc');
+        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('team-abc');
+    });
+    it('overwrites the active team ID on subsequent writes', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
+        const store = new TeamStateStore('.state');
+        await store.setActiveTeam(tempRoot, 'team-first');
+        await store.setActiveTeam(tempRoot, 'team-second');
+        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('team-second');
+    });
 });

package/dist/test/tool-approval-manager.test.js

@@ -143,41 +143,41 @@ describe('ToolApprovalManager', () => {
         });
     });
     describe('policy management', () => {
-        it('addRule inserts at specified position', () => {
+        it('addRule inserts at specified position', async () => {
             const manager = new ToolApprovalManager({
                 rules: [],
                 enabled: true,
                 defaultAction: 'allow',
             });
-            manager.addRule({ id: 'a', toolPattern: 'A', action: 'allow' });
-            manager.addRule({ id: 'b', toolPattern: 'B', action: 'allow' });
-            manager.addRule({ id: 'c', toolPattern: 'C', action: 'deny' }, 1);
+            await manager.addRule({ id: 'a', toolPattern: 'A', action: 'allow' });
+            await manager.addRule({ id: 'b', toolPattern: 'B', action: 'allow' });
+            await manager.addRule({ id: 'c', toolPattern: 'C', action: 'deny' }, 1);
             const rules = manager.getPolicy().rules;
             expect(rules.map((r) => r.id)).toEqual(['a', 'c', 'b']);
         });
-        it('addRule appends to end by default', () => {
+        it('addRule appends to end by default', async () => {
             const manager = new ToolApprovalManager({
                 rules: [],
                 enabled: true,
                 defaultAction: 'allow',
             });
-            manager.addRule({ id: 'a', toolPattern: 'A', action: 'allow' });
-            manager.addRule({ id: 'b', toolPattern: 'B', action: 'allow' });
+            await manager.addRule({ id: 'a', toolPattern: 'A', action: 'allow' });
+            await manager.addRule({ id: 'b', toolPattern: 'B', action: 'allow' });
             expect(manager.getPolicy().rules.map((r) => r.id)).toEqual(['a', 'b']);
         });
-        it('removeRule removes by ID and returns true', () => {
+        it('removeRule removes by ID and returns true', async () => {
             const manager = new ToolApprovalManager();
-            const removed = manager.removeRule('allow-read');
+            const removed = await manager.removeRule('allow-read');
             expect(removed).toBe(true);
             expect(manager.getPolicy().rules.find((r) => r.id === 'allow-read')).toBeUndefined();
         });
-        it('removeRule returns false for non-existent ID', () => {
+        it('removeRule returns false for non-existent ID', async () => {
             const manager = new ToolApprovalManager();
-            expect(manager.removeRule('nonexistent')).toBe(false);
+            expect(await manager.removeRule('nonexistent')).toBe(false);
         });
-        it('setPolicy replaces entire policy', () => {
+        it('setPolicy replaces entire policy', async () => {
             const manager = new ToolApprovalManager();
-            manager.setPolicy({
+            await manager.setPolicy({
                 rules: [{ id: 'only', toolPattern: '*', action: 'deny' }],
                 defaultAction: 'deny',
                 enabled: true,
@@ -185,16 +185,16 @@ describe('ToolApprovalManager', () => {
             expect(manager.getPolicy().rules).toHaveLength(1);
             expect(manager.getPolicy().defaultAction).toBe('deny');
         });
-        it('setDefaultAction changes the fallback', () => {
+        it('setDefaultAction changes the fallback', async () => {
             const manager = new ToolApprovalManager({
                 rules: [],
                 enabled: true,
                 defaultAction: 'allow',
             });
-            manager.setDefaultAction('deny');
+            await manager.setDefaultAction('deny');
             expect(manager.evaluate('Unknown', {}).behavior).toBe('deny');
         });
-        it('setEnabled toggles the manager', () => {
+        it('setEnabled toggles the manager', async () => {
             const manager = new ToolApprovalManager({
                 rules: [
                     {
@@ -208,7 +208,7 @@ describe('ToolApprovalManager', () => {
                 defaultAction: 'deny',
             });
             expect(manager.evaluate('Read', {}).behavior).toBe('deny');
-            manager.setEnabled(false);
+            await manager.setEnabled(false);
             expect(manager.evaluate('Read', {}).behavior).toBe('allow');
         });
     });