@doingdev/opencode-claude-manager-plugin 0.1.58 → 0.1.59

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

@@ -3,12 +3,46 @@ import { managerPromptRegistry } from '../prompts/registry.js';
 import { isEngineerName } from '../team/roster.js';
 import { TeamOrchestrator, createActionableError, getFailureGuidanceText, } from '../manager/team-orchestrator.js';
 import { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, buildBrowserQaAgentConfig, buildCtoAgentConfig, buildEngineerAgentConfig, buildTeamPlannerAgentConfig, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from './agents/index.js';
-import { getActiveTeamSession, getOrCreatePluginServices, getPersistedActiveTeam, getWrapperSessionMapping, setActiveTeamSession, setPersistedActiveTeam, setWrapperSessionMapping, } from './service-factory.js';
+import { getOrCreatePluginServices, getParentSessionId, getSessionTeam, getWrapperSessionMapping, registerParentSession, registerSessionTeam, 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 }) => {
+export const ClaudeManagerPlugin = async ({ worktree, client }) => {
     const services = getOrCreatePluginServices(worktree);
     await services.approvalManager.loadPersistedPolicy();
+    /**
+     * Resolves the team ID for a brand-new engineer wrapper session.
+     *
+     * 1. Walk the cached parentID chain (populated by session.created events).
+     * 2. On a cache miss, attempt a live client.session.get() lookup and cache
+     *    whatever parentID the SDK returns.
+     * 3. Fall back to the orphan sentinel (sessionID itself) only when both
+     *    cache and live lookup come up empty.
+     */
+    async function resolveTeamId(sessionID) {
+        let current = sessionID;
+        const seen = new Set();
+        while (current && !seen.has(current)) {
+            seen.add(current);
+            const team = getSessionTeam(current);
+            if (team !== undefined)
+                return team;
+            // Cache miss on this node's parent: try the live SDK.
+            if (client && !getParentSessionId(current)) {
+                try {
+                    const result = await client.session.get({ path: { id: current } });
+                    const parentID = result.data?.parentID;
+                    if (parentID) {
+                        registerParentSession(current, parentID);
+                    }
+                }
+                catch {
+                    // Network / auth failure — let the walk continue to orphan.
+                }
+            }
+            current = getParentSessionId(current);
+        }
+        return sessionID;
+    }
     return {
         config: async (config) => {
             config.agent ??= {};
@@ -23,15 +57,9 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         },
         'chat.message': async (input) => {
             if (input.agent === AGENT_CTO) {
-                // 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);
-                }
+                // Each CTO session ID is its own team. The session ID is the durable
+                // identity: no worktree-global active-team state.
+                registerSessionTeam(input.sessionID, input.sessionID);
                 return;
             }
             if (input.agent && isEngineerAgent(input.agent)) {
@@ -39,7 +67,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 ?? (await resolveTeamId(worktree, input.sessionID));
+                const teamId = persisted?.teamId ?? (await resolveTeamId(input.sessionID));
                 setWrapperSessionMapping(worktree, input.sessionID, {
                     teamId,
                     workerName: engineer,
@@ -47,6 +75,14 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 await services.orchestrator.recordWrapperSession(worktree, teamId, engineer, input.sessionID);
             }
         },
+        event: async ({ event: sdkEvent }) => {
+            if (sdkEvent.type === 'session.created') {
+                const session = sdkEvent.properties.info;
+                if (session.parentID) {
+                    registerParentSession(session.id, session.parentID);
+                }
+            }
+        },
         'experimental.chat.system.transform': async (input, output) => {
             if (!input.sessionID) {
                 return;
@@ -86,7 +122,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 ?? (await resolveTeamId(context.worktree, context.sessionID));
+                    const teamId = persisted?.teamId ?? (await resolveTeamId(context.sessionID));
                     setWrapperSessionMapping(context.worktree, context.sessionID, {
                         teamId,
                         workerName: engineer,
@@ -117,7 +153,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     teamId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    const teamId = args.teamId ?? getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = args.teamId ?? context.sessionID;
                     annotateToolRun(context, 'Reading team status', {
                         teamId,
                     });
@@ -134,7 +170,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     model: tool.schema.enum(MODEL_ENUM).optional(),
                 },
                 async execute(args, context) {
-                    const teamId = getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = context.sessionID;
                     // Pre-determine engineers for event labeling (using orchestrator selection logic)
                     const { lead, challenger } = await services.orchestrator.selectPlanEngineers(context.worktree, teamId, args.leadEngineer, args.challengerEngineer);
                     annotateToolRun(context, 'Running dual-engineer plan synthesis', {
@@ -178,7 +214,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     clearHistory: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
-                    const teamId = getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = context.sessionID;
                     annotateToolRun(context, `Resetting ${args.engineer}`, {
                         teamId,
                         clearSession: args.clearSession,
@@ -456,14 +492,6 @@ export function isEngineerAgent(agentId) {
     const normalized = normalizeAgentId(agentId);
     return Object.values(ENGINEER_AGENT_IDS).some((id) => id === normalized);
 }
-/**
- * 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 formatToolDescription(toolName, toolArgs) {
     if (!toolArgs || typeof toolArgs !== 'object')
         return undefined;

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

@@ -14,10 +14,10 @@ interface ClaudeManagerPluginServices {
 }
 export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
 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 registerParentSession(childId: string, parentId: string): void;
+export declare function getParentSessionId(childId: string): string | undefined;
+export declare function registerSessionTeam(sessionId: string, teamId: string): void;
+export declare function getSessionTeam(sessionId: string): string | undefined;
 export declare function setWrapperSessionMapping(worktree: string, wrapperSessionId: string, mapping: {
     teamId: string;
     workerName: EngineerName;

package/dist/plugin/service-factory.js

@@ -10,8 +10,11 @@ import { TeamStateStore } from '../state/team-state-store.js';
 import { TranscriptStore } from '../state/transcript-store.js';
 import { buildWorkerCapabilities } from './agents/browser-qa.js';
 const serviceRegistry = new Map();
-const activeTeamRegistry = new Map();
 const wrapperSessionRegistry = new Map();
+/** childSessionId → parentSessionId — populated from session.created events */
+const parentSessionRegistry = new Map();
+/** ctoSessionId → teamId — populated when a CTO chat.message fires */
+const sessionTeamRegistry = new Map();
 export function getOrCreatePluginServices(worktree) {
     const existing = serviceRegistry.get(worktree);
     if (existing) {
@@ -40,28 +43,21 @@ export function getOrCreatePluginServices(worktree) {
 }
 export function clearPluginServices() {
     serviceRegistry.clear();
-    activeTeamRegistry.clear();
     wrapperSessionRegistry.clear();
+    parentSessionRegistry.clear();
+    sessionTeamRegistry.clear();
 }
-export function setActiveTeamSession(worktree, teamId) {
-    activeTeamRegistry.set(worktree, teamId);
+export function registerParentSession(childId, parentId) {
+    parentSessionRegistry.set(childId, parentId);
 }
-export function getActiveTeamSession(worktree) {
-    return activeTeamRegistry.get(worktree) ?? null;
+export function getParentSessionId(childId) {
+    return parentSessionRegistry.get(childId);
 }
-export async function getPersistedActiveTeam(worktree) {
-    const services = serviceRegistry.get(worktree);
-    if (!services) {
-        return null;
-    }
-    return services.teamStore.getActiveTeam(worktree);
+export function registerSessionTeam(sessionId, teamId) {
+    sessionTeamRegistry.set(sessionId, teamId);
 }
-export async function setPersistedActiveTeam(worktree, teamId) {
-    const services = serviceRegistry.get(worktree);
-    if (!services) {
-        return;
-    }
-    await services.teamStore.setActiveTeam(worktree, teamId);
+export function getSessionTeam(sessionId) {
+    return sessionTeamRegistry.get(sessionId);
 }
 export function setWrapperSessionMapping(worktree, wrapperSessionId, mapping) {
     wrapperSessionRegistry.set(`${worktree}:${wrapperSessionId}`, mapping);

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

@@ -3,12 +3,46 @@ import { managerPromptRegistry } from '../prompts/registry.js';
 import { isEngineerName } from '../team/roster.js';
 import { TeamOrchestrator, createActionableError, getFailureGuidanceText, } from '../manager/team-orchestrator.js';
 import { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, buildBrowserQaAgentConfig, buildCtoAgentConfig, buildEngineerAgentConfig, buildTeamPlannerAgentConfig, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from './agents/index.js';
-import { getActiveTeamSession, getOrCreatePluginServices, getPersistedActiveTeam, getWrapperSessionMapping, setActiveTeamSession, setPersistedActiveTeam, setWrapperSessionMapping, } from './service-factory.js';
+import { getOrCreatePluginServices, getParentSessionId, getSessionTeam, getWrapperSessionMapping, registerParentSession, registerSessionTeam, 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 }) => {
+export const ClaudeManagerPlugin = async ({ worktree, client }) => {
     const services = getOrCreatePluginServices(worktree);
     await services.approvalManager.loadPersistedPolicy();
+    /**
+     * Resolves the team ID for a brand-new engineer wrapper session.
+     *
+     * 1. Walk the cached parentID chain (populated by session.created events).
+     * 2. On a cache miss, attempt a live client.session.get() lookup and cache
+     *    whatever parentID the SDK returns.
+     * 3. Fall back to the orphan sentinel (sessionID itself) only when both
+     *    cache and live lookup come up empty.
+     */
+    async function resolveTeamId(sessionID) {
+        let current = sessionID;
+        const seen = new Set();
+        while (current && !seen.has(current)) {
+            seen.add(current);
+            const team = getSessionTeam(current);
+            if (team !== undefined)
+                return team;
+            // Cache miss on this node's parent: try the live SDK.
+            if (client && !getParentSessionId(current)) {
+                try {
+                    const result = await client.session.get({ path: { id: current } });
+                    const parentID = result.data?.parentID;
+                    if (parentID) {
+                        registerParentSession(current, parentID);
+                    }
+                }
+                catch {
+                    // Network / auth failure — let the walk continue to orphan.
+                }
+            }
+            current = getParentSessionId(current);
+        }
+        return sessionID;
+    }
     return {
         config: async (config) => {
             config.agent ??= {};
@@ -23,15 +57,9 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         },
         'chat.message': async (input) => {
             if (input.agent === AGENT_CTO) {
-                // 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);
-                }
+                // Each CTO session ID is its own team. The session ID is the durable
+                // identity: no worktree-global active-team state.
+                registerSessionTeam(input.sessionID, input.sessionID);
                 return;
             }
             if (input.agent && isEngineerAgent(input.agent)) {
@@ -39,7 +67,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 ?? (await resolveTeamId(worktree, input.sessionID));
+                const teamId = persisted?.teamId ?? (await resolveTeamId(input.sessionID));
                 setWrapperSessionMapping(worktree, input.sessionID, {
                     teamId,
                     workerName: engineer,
@@ -47,6 +75,14 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 await services.orchestrator.recordWrapperSession(worktree, teamId, engineer, input.sessionID);
             }
         },
+        event: async ({ event: sdkEvent }) => {
+            if (sdkEvent.type === 'session.created') {
+                const session = sdkEvent.properties.info;
+                if (session.parentID) {
+                    registerParentSession(session.id, session.parentID);
+                }
+            }
+        },
         'experimental.chat.system.transform': async (input, output) => {
             if (!input.sessionID) {
                 return;
@@ -86,7 +122,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 ?? (await resolveTeamId(context.worktree, context.sessionID));
+                    const teamId = persisted?.teamId ?? (await resolveTeamId(context.sessionID));
                     setWrapperSessionMapping(context.worktree, context.sessionID, {
                         teamId,
                         workerName: engineer,
@@ -117,7 +153,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     teamId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    const teamId = args.teamId ?? getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = args.teamId ?? context.sessionID;
                     annotateToolRun(context, 'Reading team status', {
                         teamId,
                     });
@@ -134,7 +170,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     model: tool.schema.enum(MODEL_ENUM).optional(),
                 },
                 async execute(args, context) {
-                    const teamId = getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = context.sessionID;
                     // Pre-determine engineers for event labeling (using orchestrator selection logic)
                     const { lead, challenger } = await services.orchestrator.selectPlanEngineers(context.worktree, teamId, args.leadEngineer, args.challengerEngineer);
                     annotateToolRun(context, 'Running dual-engineer plan synthesis', {
@@ -178,7 +214,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     clearHistory: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
-                    const teamId = getActiveTeamSession(context.worktree) ?? context.sessionID;
+                    const teamId = context.sessionID;
                     annotateToolRun(context, `Resetting ${args.engineer}`, {
                         teamId,
                         clearSession: args.clearSession,
@@ -456,14 +492,6 @@ export function isEngineerAgent(agentId) {
     const normalized = normalizeAgentId(agentId);
     return Object.values(ENGINEER_AGENT_IDS).some((id) => id === normalized);
 }
-/**
- * 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 formatToolDescription(toolName, toolArgs) {
     if (!toolArgs || typeof toolArgs !== 'object')
         return undefined;

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

@@ -14,10 +14,10 @@ interface ClaudeManagerPluginServices {
 }
 export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
 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 registerParentSession(childId: string, parentId: string): void;
+export declare function getParentSessionId(childId: string): string | undefined;
+export declare function registerSessionTeam(sessionId: string, teamId: string): void;
+export declare function getSessionTeam(sessionId: string): string | undefined;
 export declare function setWrapperSessionMapping(worktree: string, wrapperSessionId: string, mapping: {
     teamId: string;
     workerName: EngineerName;

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

@@ -10,8 +10,11 @@ import { TeamStateStore } from '../state/team-state-store.js';
 import { TranscriptStore } from '../state/transcript-store.js';
 import { buildWorkerCapabilities } from './agents/browser-qa.js';
 const serviceRegistry = new Map();
-const activeTeamRegistry = new Map();
 const wrapperSessionRegistry = new Map();
+/** childSessionId → parentSessionId — populated from session.created events */
+const parentSessionRegistry = new Map();
+/** ctoSessionId → teamId — populated when a CTO chat.message fires */
+const sessionTeamRegistry = new Map();
 export function getOrCreatePluginServices(worktree) {
     const existing = serviceRegistry.get(worktree);
     if (existing) {
@@ -40,28 +43,21 @@ export function getOrCreatePluginServices(worktree) {
 }
 export function clearPluginServices() {
     serviceRegistry.clear();
-    activeTeamRegistry.clear();
     wrapperSessionRegistry.clear();
+    parentSessionRegistry.clear();
+    sessionTeamRegistry.clear();
 }
-export function setActiveTeamSession(worktree, teamId) {
-    activeTeamRegistry.set(worktree, teamId);
+export function registerParentSession(childId, parentId) {
+    parentSessionRegistry.set(childId, parentId);
 }
-export function getActiveTeamSession(worktree) {
-    return activeTeamRegistry.get(worktree) ?? null;
+export function getParentSessionId(childId) {
+    return parentSessionRegistry.get(childId);
 }
-export async function getPersistedActiveTeam(worktree) {
-    const services = serviceRegistry.get(worktree);
-    if (!services) {
-        return null;
-    }
-    return services.teamStore.getActiveTeam(worktree);
+export function registerSessionTeam(sessionId, teamId) {
+    sessionTeamRegistry.set(sessionId, teamId);
 }
-export async function setPersistedActiveTeam(worktree, teamId) {
-    const services = serviceRegistry.get(worktree);
-    if (!services) {
-        return;
-    }
-    await services.teamStore.setActiveTeam(worktree, teamId);
+export function getSessionTeam(sessionId) {
+    return sessionTeamRegistry.get(sessionId);
 }
 export function setWrapperSessionMapping(worktree, wrapperSessionId, mapping) {
     wrapperSessionRegistry.set(`${worktree}:${wrapperSessionId}`, mapping);

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

@@ -7,10 +7,7 @@ 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

@@ -62,31 +62,9 @@ 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,10 +7,7 @@ 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

@@ -62,31 +62,9 @@ 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.js

@@ -1,12 +1,19 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+/**
+ * Tests for the session-per-team CTO model:
+ * - Each CTO session ID is its own team ID (no shared repo-global state).
+ * - Same CTO session ID recovers the same team context across restarts.
+ * - A different CTO session ID in the same worktree creates an independent team.
+ * - Engineers spawned within a CTO session resolve to that CTO's team.
+ * - CTO task permissions do not allow self-delegation.
+ */
+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 } 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', () => {
+import { clearPluginServices, getOrCreatePluginServices, getSessionTeam, getWrapperSessionMapping, registerParentSession, } from '../src/plugin/service-factory.js';
+import { AGENT_CTO, ENGINEER_AGENT_IDS } from '../src/plugin/agents/index.js';
+describe('CTO chat.message — session-per-team model', () => {
     let tempRoot;
     beforeEach(async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'cto-team-'));
@@ -18,35 +25,175 @@ describe('CTO chat.message — persisted active team', () => {
             await rm(tempRoot, { recursive: true, force: true });
         }
     });
-    it('persists the active team on the first CTO message', async () => {
+    it('CTO session ID is used directly as the team ID', 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');
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        expect(getSessionTeam('cto-session-1')).toBe('cto-session-1');
+    });
+    it('same CTO session ID recovers its team context after a process restart', async () => {
+        // Phase 1: CTO session 'cto-1' runs and a team record is created on disk.
+        const plugin1 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage1 = plugin1['chat.message'];
+        await chatMessage1({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        const services1 = getOrCreatePluginServices(tempRoot);
+        await services1.orchestrator.getOrCreateTeam(tempRoot, 'cto-1'); // persist team to disk
+        expect(getSessionTeam('cto-1')).toBe('cto-1');
+        // Phase 2: Simulate a process restart (all in-memory state is lost).
+        clearPluginServices();
+        // Phase 3: The same CTO session ID resumes — it should re-register itself.
+        const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage2 = plugin2['chat.message'];
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        expect(getSessionTeam('cto-1')).toBe('cto-1');
+        // The persisted team record from Phase 1 should still be accessible.
+        const services2 = getOrCreatePluginServices(tempRoot);
+        const team = await services2.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
+        expect(team.id).toBe('cto-1');
+    });
+    it('a different CTO session ID creates an independent team, not adopting prior state', async () => {
+        // Phase 1: CTO session 'cto-1' runs.
+        const plugin1 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage1 = plugin1['chat.message'];
+        await chatMessage1({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        const services1 = getOrCreatePluginServices(tempRoot);
+        await services1.orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
+        // Phase 2: Process restart.
+        clearPluginServices();
+        // Phase 3: A brand-new CTO session 'cto-2' starts.
+        const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage2 = plugin2['chat.message'];
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
+        // Must use its OWN session ID as team — must NOT adopt 'cto-1'.
+        expect(getSessionTeam('cto-2')).toBe('cto-2');
+        expect(getSessionTeam('cto-1')).toBeUndefined(); // cleared by restart
+        // 'cto-1' team data remains on disk, untouched.
+        const services2 = getOrCreatePluginServices(tempRoot);
+        const team1 = await services2.teamStore.getTeam(tempRoot, 'cto-1');
+        expect(team1).not.toBeNull(); // still present
+        expect(team1.id).toBe('cto-1');
+    });
+    it('multiple chat.message calls from the same CTO session do not change the active team', async () => {
         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');
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-session-1' });
+        expect(getSessionTeam('cto-session-1')).toBe('cto-session-1');
+    });
+    it("engineers spawned during a CTO session resolve to that CTO session's team", async () => {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        // CTO session fires first, establishing the active team.
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-A' });
+        // Simulate session.created event: OpenCode fires this before chat.message for the engineer.
+        registerParentSession('wrapper-tom-1', 'cto-A');
+        // Engineer wrapper session fires (spawned by the CTO).
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-1' });
+        // The wrapper session must be mapped to the CTO's team, not a new orphan team.
+        const mapping = getWrapperSessionMapping(tempRoot, 'wrapper-tom-1');
+        expect(mapping).toBeDefined();
+        expect(mapping.teamId).toBe('cto-A');
+        expect(mapping.workerName).toBe('Tom');
+    });
+    it('two concurrent CTO sessions each bind their own engineers independently', async () => {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        // Two CTO sessions start concurrently in the same worktree.
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-alpha' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-beta' });
+        // Simulate session.created events: each CTO spawns one engineer sub-session.
+        // The event hook normally calls registerParentSession; call it directly here.
+        registerParentSession('wrapper-tom-alpha', 'cto-alpha');
+        registerParentSession('wrapper-sara-beta', 'cto-beta');
+        // Engineer wrapper sessions check in.
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-alpha' });
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Sara, sessionID: 'wrapper-sara-beta' });
+        // Tom must bind to cto-alpha's team, not cto-beta's.
+        const tomMapping = getWrapperSessionMapping(tempRoot, 'wrapper-tom-alpha');
+        expect(tomMapping).toBeDefined();
+        expect(tomMapping.teamId).toBe('cto-alpha');
+        // Sara must bind to cto-beta's team, not cto-alpha's.
+        const saraMapping = getWrapperSessionMapping(tempRoot, 'wrapper-sara-beta');
+        expect(saraMapping).toBeDefined();
+        expect(saraMapping.teamId).toBe('cto-beta');
+    });
+});
+describe('CTO task permissions — self-delegation', () => {
+    let tempRoot;
+    beforeEach(async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'cto-perms-'));
+        clearPluginServices();
+    });
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot)
+            await rm(tempRoot, { recursive: true, force: true });
+    });
+    it('CTO task permissions deny delegation to cto', async () => {
         const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        const cto = agents[AGENT_CTO];
+        const taskPerms = cto.permission.task;
+        // Default deny must apply, and cto must not be explicitly allowed.
+        expect(taskPerms['*']).toBe('deny');
+        expect(taskPerms['cto']).toBeUndefined();
+        expect(taskPerms['CTO']).toBeUndefined();
+    });
+});
+describe('CTO tool isolation — concurrent sessions', () => {
+    let tempRoot;
+    beforeEach(async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'cto-isolation-'));
+        clearPluginServices();
+    });
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot)
+            await rm(tempRoot, { recursive: true, force: true });
+    });
+    it('team_status called from CTO-A uses CTO-A team even after CTO-B has chatted', async () => {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        // CTO-A registers first, then CTO-B registers (simulating two concurrent sessions).
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-A' });
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-B' });
+        // Execute team_status as CTO-A (sessionID = 'cto-A').
+        const teamStatusTool = plugin.tool['team_status'];
+        const ctx = {
+            metadata: vi.fn(),
+            worktree: tempRoot,
+            sessionID: 'cto-A',
+            agent: AGENT_CTO,
+            abort: new AbortController().signal,
+        };
+        const result = JSON.parse(await teamStatusTool.execute({}, ctx));
+        // Must load cto-A's team, NOT cto-B's (last-write-wins global would give 'cto-B').
+        expect(result.id).toBe('cto-A');
+    });
+    it('resolves engineer team via live SDK lookup when session.created was not received', async () => {
+        // Simulate a client whose session.get returns parentID for the engineer session.
+        const mockClient = {
+            session: {
+                get: vi.fn().mockImplementation(async ({ path }) => {
+                    if (path.id === 'wrapper-tom-live') {
+                        return { data: { id: 'wrapper-tom-live', parentID: 'cto-live' } };
+                    }
+                    return { data: undefined };
+                }),
+            },
+        };
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot, client: mockClient });
         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');
+        // CTO registers its team via chat.message.
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-live' });
+        // No registerParentSession call — simulates session.created arriving late or being missed.
+        // Engineer wrapper fires; resolveTeamId must fall through to live SDK lookup.
+        await chatMessage({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-live' });
+        const mapping = getWrapperSessionMapping(tempRoot, 'wrapper-tom-live');
+        expect(mapping?.teamId).toBe('cto-live');
+        expect(mockClient.session.get).toHaveBeenCalledWith({ path: { id: 'wrapper-tom-live' } });
     });
 });

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

@@ -8,7 +8,7 @@ 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 { clearPluginServices, getOrCreatePluginServices, getSessionTeam, registerParentSession, } 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';
@@ -197,23 +197,25 @@ describe('second invocation continuity', () => {
         if (tempRoot)
             await rm(tempRoot, { recursive: true, force: true });
     });
-    it('wrapper memory is injected after clearPluginServices and a new plugin instance', async () => {
+    it('wrapper memory is injected after clearPluginServices and same CTO session resumes', async () => {
         // ── Phase 1: first task via orchestrator (no real SDK needed) ──────────
+        // Team ID = 'cto-1' (the CTO session ID that originally ran this work).
         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', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         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 ──────────────────────
+        // ── Phase 3: same CTO session resumes, engineers run a new wrapper ──────
         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.
+        // Same CTO session ID resumes — re-registers itself as the team.
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        expect(getSessionTeam('cto-1')).toBe('cto-1');
+        // Simulate session.created: OpenCode fires this when cto-1 spawns the new wrapper.
+        registerParentSession('wrapper-tom-2', 'cto-1');
+        // Tom's new wrapper session is registered under the same 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: [] };
@@ -224,9 +226,8 @@ describe('second invocation continuity', () => {
         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 ───────────────────────
+        // ── Phase 1: pre-seed Tom with a claudeSessionId under team 'cto-1' ────
         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', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         await orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
         await store.updateTeam(tempRoot, 'cto-1', (team) => ({
@@ -235,10 +236,13 @@ describe('second invocation continuity', () => {
         }));
         // ── Phase 2: process restart ───────────────────────────────────────────
         clearPluginServices();
-        // ── Phase 3: new plugin, new CTO, engineer runs second task ───────────
+        // ── Phase 3: same CTO session resumes, engineer runs second task ───────
         const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
         const chatMessage2 = plugin2['chat.message'];
-        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
+        // Same CTO session ID — re-registers as the team so Tom can find his session.
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        // Simulate session.created: OpenCode fires this when cto-1 spawns the new wrapper.
+        registerParentSession('wrapper-tom-2', 'cto-1');
         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

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

@@ -51,22 +51,4 @@ 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.58",
+  "version": "0.1.59",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",