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

package/dist/plugin/claude-manager.plugin.js

@@ -1,9 +1,9 @@
 import { tool } from '@opencode-ai/plugin';
 import { managerPromptRegistry } from '../prompts/registry.js';
+import { isEngineerName } from '../team/roster.js';
 import { discoverProjectClaudeFiles } from '../util/project-context.js';
 import { AGENT_CTO, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, buildCtoAgentConfig, buildEngineerAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
-import { getActiveTeamSession, getOrCreatePluginServices, getWrapperSessionMapping, setActiveTeamSession, setWrapperSessionMapping, } from './service-factory.js';
-import { isEngineerName } from '../team/roster.js';
+import { getActiveTeamSession, getOrCreatePluginServices, getPersistedActiveTeam, getWrapperSessionMapping, setActiveTeamSession, setPersistedActiveTeam, setWrapperSessionMapping, } from './service-factory.js';
 const MODEL_ENUM = ['claude-opus-4-6', 'claude-sonnet-4-6'];
 const MODE_ENUM = ['explore', 'implement', 'verify'];
 export const ClaudeManagerPlugin = async ({ worktree }) => {
@@ -21,7 +21,15 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         },
         'chat.message': async (input) => {
             if (input.agent === AGENT_CTO) {
-                setActiveTeamSession(worktree, input.sessionID);
+                // Adopt the persisted active team if one exists, so a new CTO session
+                // does not orphan previously created engineers and wrapper memory.
+                const persistedTeamId = await getPersistedActiveTeam(worktree);
+                const activeTeamId = persistedTeamId ?? input.sessionID;
+                setActiveTeamSession(worktree, activeTeamId);
+                if (!persistedTeamId) {
+                    // First CTO session for this worktree — persist this session as active team.
+                    await setPersistedActiveTeam(worktree, activeTeamId);
+                }
                 return;
             }
             if (input.agent && isEngineerAgent(input.agent)) {
@@ -29,7 +37,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 const existing = getWrapperSessionMapping(worktree, input.sessionID);
                 const persisted = existing ??
                     (await services.orchestrator.findTeamByWrapperSession(worktree, input.sessionID));
-                const teamId = persisted?.teamId ?? getActiveTeamSession(worktree) ?? input.sessionID;
+                const teamId = persisted?.teamId ?? (await resolveTeamId(worktree, input.sessionID));
                 setWrapperSessionMapping(worktree, input.sessionID, {
                     teamId,
                     engineer,
@@ -65,7 +73,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     const existing = getWrapperSessionMapping(context.worktree, context.sessionID);
                     const persisted = existing ??
                         (await services.orchestrator.findTeamByWrapperSession(context.worktree, context.sessionID));
-                    const teamId = persisted?.teamId ?? getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = persisted?.teamId ?? (await resolveTeamId(context.worktree, context.sessionID));
                     setWrapperSessionMapping(context.worktree, context.sessionID, {
                         teamId,
                         engineer,
@@ -78,7 +86,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         message: args.message,
                         model: args.model,
                     }, context);
-                    return JSON.stringify(result, null, 2);
+                    return result.finalText;
                 },
             }),
             team_status: tool({
@@ -319,6 +327,14 @@ function engineerFromAgent(agentId) {
 function isEngineerAgent(agentId) {
     return Object.values(ENGINEER_AGENT_IDS).includes(agentId);
 }
+/**
+ * Resolves the team ID for an engineer session.
+ * Reads the persisted active team first (survives process restarts), then
+ * falls back to the in-memory registry, then to the raw session ID as a last resort.
+ */
+async function resolveTeamId(worktree, sessionID) {
+    return (await getPersistedActiveTeam(worktree)) ?? getActiveTeamSession(worktree) ?? sessionID;
+}
 function reportClaudeEvent(context, engineer, event) {
     if (event.type === 'error') {
         context.metadata({
@@ -342,11 +358,40 @@ function reportClaudeEvent(context, engineer, event) {
         return;
     }
     if (event.type === 'tool_call') {
+        let toolName;
+        let toolId;
+        let toolArgs;
+        try {
+            const parsed = JSON.parse(event.text);
+            toolName = parsed.name;
+            toolId = parsed.id;
+            // Some SDK versions serialize the input object as a JSON string inside the outer JSON.
+            // Try to double-decode it so callers always receive a plain object.
+            if (typeof parsed.input === 'string') {
+                try {
+                    toolArgs = JSON.parse(parsed.input);
+                }
+                catch {
+                    toolArgs = parsed.input;
+                }
+            }
+            else {
+                toolArgs = parsed.input;
+            }
+        }
+        catch {
+            // event.text is not valid JSON — fall back to generic title
+        }
         context.metadata({
-            title: `⚡ ${engineer} is using Claude Code tools`,
+            title: toolName
+                ? `⚡ ${engineer} → ${toolName}`
+                : `⚡ ${engineer} is using Claude Code tools`,
             metadata: {
                 engineer,
                 sessionId: event.sessionId,
+                ...(toolName !== undefined && { toolName }),
+                ...(toolId !== undefined && { toolId }),
+                ...(toolArgs !== undefined && { toolArgs }),
             },
         });
         return;

package/dist/plugin/service-factory.d.ts

@@ -17,6 +17,8 @@ export declare function getOrCreatePluginServices(worktree: string, projectClaud
 export declare function clearPluginServices(): void;
 export declare function setActiveTeamSession(worktree: string, teamId: string): void;
 export declare function getActiveTeamSession(worktree: string): string | null;
+export declare function getPersistedActiveTeam(worktree: string): Promise<string | null>;
+export declare function setPersistedActiveTeam(worktree: string, teamId: string): Promise<void>;
 export declare function setWrapperSessionMapping(worktree: string, wrapperSessionId: string, mapping: {
     teamId: string;
     engineer: EngineerName;

package/dist/plugin/service-factory.js

@@ -54,6 +54,20 @@ export function setActiveTeamSession(worktree, teamId) {
 export function getActiveTeamSession(worktree) {
     return activeTeamRegistry.get(worktree) ?? null;
 }
+export async function getPersistedActiveTeam(worktree) {
+    const services = serviceRegistry.get(worktree);
+    if (!services) {
+        return null;
+    }
+    return services.teamStore.getActiveTeam(worktree);
+}
+export async function setPersistedActiveTeam(worktree, teamId) {
+    const services = serviceRegistry.get(worktree);
+    if (!services) {
+        return;
+    }
+    await services.teamStore.setActiveTeam(worktree, teamId);
+}
 export function setWrapperSessionMapping(worktree, wrapperSessionId, mapping) {
     wrapperSessionRegistry.set(`${worktree}:${wrapperSessionId}`, mapping);
 }

package/dist/src/plugin/claude-manager.plugin.js

@@ -1,9 +1,9 @@
 import { tool } from '@opencode-ai/plugin';
 import { managerPromptRegistry } from '../prompts/registry.js';
+import { isEngineerName } from '../team/roster.js';
 import { discoverProjectClaudeFiles } from '../util/project-context.js';
 import { AGENT_CTO, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, buildCtoAgentConfig, buildEngineerAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
-import { getActiveTeamSession, getOrCreatePluginServices, getWrapperSessionMapping, setActiveTeamSession, setWrapperSessionMapping, } from './service-factory.js';
-import { isEngineerName } from '../team/roster.js';
+import { getActiveTeamSession, getOrCreatePluginServices, getPersistedActiveTeam, getWrapperSessionMapping, setActiveTeamSession, setPersistedActiveTeam, setWrapperSessionMapping, } from './service-factory.js';
 const MODEL_ENUM = ['claude-opus-4-6', 'claude-sonnet-4-6'];
 const MODE_ENUM = ['explore', 'implement', 'verify'];
 export const ClaudeManagerPlugin = async ({ worktree }) => {
@@ -21,7 +21,15 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         },
         'chat.message': async (input) => {
             if (input.agent === AGENT_CTO) {
-                setActiveTeamSession(worktree, input.sessionID);
+                // Adopt the persisted active team if one exists, so a new CTO session
+                // does not orphan previously created engineers and wrapper memory.
+                const persistedTeamId = await getPersistedActiveTeam(worktree);
+                const activeTeamId = persistedTeamId ?? input.sessionID;
+                setActiveTeamSession(worktree, activeTeamId);
+                if (!persistedTeamId) {
+                    // First CTO session for this worktree — persist this session as active team.
+                    await setPersistedActiveTeam(worktree, activeTeamId);
+                }
                 return;
             }
             if (input.agent && isEngineerAgent(input.agent)) {
@@ -29,7 +37,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 const existing = getWrapperSessionMapping(worktree, input.sessionID);
                 const persisted = existing ??
                     (await services.orchestrator.findTeamByWrapperSession(worktree, input.sessionID));
-                const teamId = persisted?.teamId ?? getActiveTeamSession(worktree) ?? input.sessionID;
+                const teamId = persisted?.teamId ?? (await resolveTeamId(worktree, input.sessionID));
                 setWrapperSessionMapping(worktree, input.sessionID, {
                     teamId,
                     engineer,
@@ -65,7 +73,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     const existing = getWrapperSessionMapping(context.worktree, context.sessionID);
                     const persisted = existing ??
                         (await services.orchestrator.findTeamByWrapperSession(context.worktree, context.sessionID));
-                    const teamId = persisted?.teamId ?? getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = persisted?.teamId ?? (await resolveTeamId(context.worktree, context.sessionID));
                     setWrapperSessionMapping(context.worktree, context.sessionID, {
                         teamId,
                         engineer,
@@ -78,7 +86,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         message: args.message,
                         model: args.model,
                     }, context);
-                    return JSON.stringify(result, null, 2);
+                    return result.finalText;
                 },
             }),
             team_status: tool({
@@ -319,6 +327,14 @@ function engineerFromAgent(agentId) {
 function isEngineerAgent(agentId) {
     return Object.values(ENGINEER_AGENT_IDS).includes(agentId);
 }
+/**
+ * Resolves the team ID for an engineer session.
+ * Reads the persisted active team first (survives process restarts), then
+ * falls back to the in-memory registry, then to the raw session ID as a last resort.
+ */
+async function resolveTeamId(worktree, sessionID) {
+    return (await getPersistedActiveTeam(worktree)) ?? getActiveTeamSession(worktree) ?? sessionID;
+}
 function reportClaudeEvent(context, engineer, event) {
     if (event.type === 'error') {
         context.metadata({
@@ -342,11 +358,40 @@ function reportClaudeEvent(context, engineer, event) {
         return;
     }
     if (event.type === 'tool_call') {
+        let toolName;
+        let toolId;
+        let toolArgs;
+        try {
+            const parsed = JSON.parse(event.text);
+            toolName = parsed.name;
+            toolId = parsed.id;
+            // Some SDK versions serialize the input object as a JSON string inside the outer JSON.
+            // Try to double-decode it so callers always receive a plain object.
+            if (typeof parsed.input === 'string') {
+                try {
+                    toolArgs = JSON.parse(parsed.input);
+                }
+                catch {
+                    toolArgs = parsed.input;
+                }
+            }
+            else {
+                toolArgs = parsed.input;
+            }
+        }
+        catch {
+            // event.text is not valid JSON — fall back to generic title
+        }
         context.metadata({
-            title: `⚡ ${engineer} is using Claude Code tools`,
+            title: toolName
+                ? `⚡ ${engineer} → ${toolName}`
+                : `⚡ ${engineer} is using Claude Code tools`,
             metadata: {
                 engineer,
                 sessionId: event.sessionId,
+                ...(toolName !== undefined && { toolName }),
+                ...(toolId !== undefined && { toolId }),
+                ...(toolArgs !== undefined && { toolArgs }),
             },
         });
         return;

package/dist/src/plugin/service-factory.d.ts

@@ -17,6 +17,8 @@ export declare function getOrCreatePluginServices(worktree: string, projectClaud
 export declare function clearPluginServices(): void;
 export declare function setActiveTeamSession(worktree: string, teamId: string): void;
 export declare function getActiveTeamSession(worktree: string): string | null;
+export declare function getPersistedActiveTeam(worktree: string): Promise<string | null>;
+export declare function setPersistedActiveTeam(worktree: string, teamId: string): Promise<void>;
 export declare function setWrapperSessionMapping(worktree: string, wrapperSessionId: string, mapping: {
     teamId: string;
     engineer: EngineerName;

package/dist/src/plugin/service-factory.js

@@ -54,6 +54,20 @@ export function setActiveTeamSession(worktree, teamId) {
 export function getActiveTeamSession(worktree) {
     return activeTeamRegistry.get(worktree) ?? null;
 }
+export async function getPersistedActiveTeam(worktree) {
+    const services = serviceRegistry.get(worktree);
+    if (!services) {
+        return null;
+    }
+    return services.teamStore.getActiveTeam(worktree);
+}
+export async function setPersistedActiveTeam(worktree, teamId) {
+    const services = serviceRegistry.get(worktree);
+    if (!services) {
+        return;
+    }
+    await services.teamStore.setActiveTeam(worktree, teamId);
+}
 export function setWrapperSessionMapping(worktree, wrapperSessionId, mapping) {
     wrapperSessionRegistry.set(`${worktree}:${wrapperSessionId}`, mapping);
 }

package/dist/src/state/team-state-store.d.ts

@@ -7,7 +7,10 @@ export declare class TeamStateStore {
     getTeam(cwd: string, teamId: string): Promise<TeamRecord | null>;
     listTeams(cwd: string): Promise<TeamRecord[]>;
     updateTeam(cwd: string, teamId: string, update: (team: TeamRecord) => TeamRecord): Promise<TeamRecord>;
+    getActiveTeam(cwd: string): Promise<string | null>;
+    setActiveTeam(cwd: string, teamId: string): Promise<void>;
     private getTeamKey;
+    private getActiveTeamPath;
     private getTeamsDirectory;
     private getTeamPath;
     private enqueueWrite;

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

@@ -59,9 +59,31 @@ export class TeamStateStore {
             return updated;
         });
     }
+    async getActiveTeam(cwd) {
+        const filePath = this.getActiveTeamPath(cwd);
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            const parsed = JSON.parse(content);
+            return parsed.teamId ?? null;
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async setActiveTeam(cwd, teamId) {
+        const filePath = this.getActiveTeamPath(cwd);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await writeJsonAtomically(filePath, { teamId });
+    }
     getTeamKey(cwd, teamId) {
         return `${cwd}:${teamId}`;
     }
+    getActiveTeamPath(cwd) {
+        return path.join(cwd, this.baseDirectoryName, 'active-team.json');
+    }
     getTeamsDirectory(cwd) {
         return path.join(cwd, this.baseDirectoryName, 'teams');
     }

package/dist/state/team-state-store.d.ts

@@ -7,7 +7,10 @@ export declare class TeamStateStore {
     getTeam(cwd: string, teamId: string): Promise<TeamRecord | null>;
     listTeams(cwd: string): Promise<TeamRecord[]>;
     updateTeam(cwd: string, teamId: string, update: (team: TeamRecord) => TeamRecord): Promise<TeamRecord>;
+    getActiveTeam(cwd: string): Promise<string | null>;
+    setActiveTeam(cwd: string, teamId: string): Promise<void>;
     private getTeamKey;
+    private getActiveTeamPath;
     private getTeamsDirectory;
     private getTeamPath;
     private enqueueWrite;

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

@@ -59,9 +59,31 @@ export class TeamStateStore {
             return updated;
         });
     }
+    async getActiveTeam(cwd) {
+        const filePath = this.getActiveTeamPath(cwd);
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            const parsed = JSON.parse(content);
+            return parsed.teamId ?? null;
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async setActiveTeam(cwd, teamId) {
+        const filePath = this.getActiveTeamPath(cwd);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await writeJsonAtomically(filePath, { teamId });
+    }
     getTeamKey(cwd, teamId) {
         return `${cwd}:${teamId}`;
     }
+    getActiveTeamPath(cwd) {
+        return path.join(cwd, this.baseDirectoryName, 'active-team.json');
+    }
     getTeamsDirectory(cwd) {
         return path.join(cwd, this.baseDirectoryName, 'teams');
     }

package/dist/test/cto-active-team.test.d.ts

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

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/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 → read');
+        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 → bash');
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.47",
+  "version": "0.1.49",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",