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

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', {
@@ -170,6 +206,49 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     }, null, 2);
                 },
             }),
+            confirm_plan: tool({
+                description: 'Persist plan confirmation and optional slice metadata after the user confirms a plan. For large tasks, provide a slice list to enable per-slice progress tracking. Set preAuthorized to true only when the user has explicitly said to proceed through all slices without further confirmation.',
+                args: {
+                    summary: tool.schema.string().min(1),
+                    taskSize: tool.schema.enum(['trivial', 'simple', 'large']),
+                    slices: tool.schema.string().array().optional(),
+                    preAuthorized: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    const teamId = context.sessionID;
+                    annotateToolRun(context, 'Persisting confirmed plan', {
+                        teamId,
+                        taskSize: args.taskSize,
+                        sliceCount: args.slices?.length ?? 0,
+                    });
+                    const activePlan = await services.orchestrator.setActivePlan(context.worktree, teamId, {
+                        summary: args.summary,
+                        taskSize: args.taskSize,
+                        slices: args.slices ?? [],
+                        preAuthorized: args.preAuthorized ?? false,
+                    });
+                    return JSON.stringify(activePlan, null, 2);
+                },
+            }),
+            advance_slice: tool({
+                description: 'Mark a plan slice as done (or skipped) and advance to the next one. Use this after each slice completes to track large-task progress.',
+                args: {
+                    sliceIndex: tool.schema.number(),
+                    status: tool.schema.enum(['done', 'skipped']).optional(),
+                },
+                async execute(args, context) {
+                    const teamId = context.sessionID;
+                    const status = args.status ?? 'done';
+                    annotateToolRun(context, `Advancing slice ${args.sliceIndex} → ${status}`, {
+                        teamId,
+                        sliceIndex: args.sliceIndex,
+                        status,
+                    });
+                    await services.orchestrator.updateActivePlanSlice(context.worktree, teamId, args.sliceIndex, status);
+                    const team = await services.orchestrator.getOrCreateTeam(context.worktree, teamId);
+                    return JSON.stringify({ activePlan: team.activePlan ?? null }, null, 2);
+                },
+            }),
             reset_engineer: tool({
                 description: 'Reset a stuck or corrupted engineer. Clears the busy flag. Optionally clears the Claude session (starts fresh) and/or wrapper history.',
                 args: {
@@ -178,7 +257,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 +535,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/prompts/registry.js

@@ -4,7 +4,7 @@ export const managerPromptRegistry = {
         'Your role is to decompose work, delegate precisely, review diffs for production risks, and verify outcomes.',
         'You do not write code. All edits go through engineers. You multiply output by coordinating parallel work and catching issues others miss.',
         '',
-        '# Operating Loop: Orient → Classify → Plan → Delegate → Review → Verify → Close',
+        '# Operating Loop: Orient → Classify → Plan → Confirm → Delegate → Review → Verify → Close',
         '',
         '## Orient: Understand the request',
         '- Extract what you can from the user message, codebase (read/grep/glob/codesearch), prior engineer results, and `websearch`/`webfetch` when relevant.',
@@ -15,6 +15,7 @@ export const managerPromptRegistry = {
         '',
         '## Classify: Frame the work',
         '- Is this a bug fix, feature, refactor, or something else?',
+        '- Task size: classify as trivial (single-line fix, unambiguous, no side effects), simple (one focused task, clear scope, 1–2 files), or large (multiple steps, cross-cutting changes, requires vertical slicing).',
         '- What could go wrong? Is it reversible or irreversible? Can it fail in prod?',
         '- Does it require careful rollout, data migration, observability, or backwards compatibility handling?',
         '- Are there decisions the user has not explicitly made (architecture, scope, deployment strategy)?',
@@ -24,16 +25,29 @@ export const managerPromptRegistry = {
         "- For medium or large tasks: use `task(subagent_type: 'team-planner', ...)` for dual-engineer exploration and plan synthesis.",
         '  - Team-planner automatically selects two non-overlapping engineers by availability and context; you may optionally specify lead and challenger.',
         '  - Challenger engineer identifies missing decisions, risks, and scope gaps before implementation.',
+        '- For large tasks: break into vertical slices before delegating. Each slice must deliver end-to-end, user-testable value independently (e.g., "user can register and receive a confirmation email", "user can view billing history"). Horizontal layers (e.g., "just types", "just tests") are not vertical slices. Document slices when calling `confirm_plan`.',
         '- Break work into independent pieces that can run in parallel. Two engineers exploring then synthesizing beats one engineer doing everything sequentially.',
         '- Before delegating, state your success criteria, not just the task. What done looks like. How you will verify it.',
         '',
+        '## Confirm: Get user buy-in before implementing',
+        '- After planning but before dispatching any engineer in implement mode, present the plan to the user with the `question` tool.',
+        '- State what will be built or changed, which files or systems are affected, what success looks like, and any risks or open decisions.',
+        '- If team-planner synthesis surfaced a recommendedQuestion, include it here as part of the confirmation question.',
+        '- Do not proceed to implementation until the user confirms the plan.',
+        '- After the user confirms, call `confirm_plan` with a summary, taskSize, and (for large tasks) the slice list. Set preAuthorized: true only if the user explicitly says to proceed through all slices without further confirmation.',
+        '- For large tasks not preAuthorized: confirm each slice with the user before dispatching it.',
+        '- Skip `question` only when: the user has explicitly said "proceed" or "just do it", the change is a trivial fix with no ambiguity, or the task is purely exploratory (no edits).',
+        '- If the user refines or rejects the plan, revise it and re-confirm before implementing.',
+        '',
         '## Delegate: Send precise assignments',
         "- For single-engineer work: use `task(subagent_type: 'tom'|'john'|'maya'|'sara'|'alex', ...)` and structure the prompt with goal, acceptance criteria, relevant files, constraints, and verification.",
         "- For dual-engineer planning: use `task(subagent_type: 'team-planner', ...)` which will lead + challenger synthesis.",
         "- For browser/UI verification: use `task(subagent_type: 'browser-qa', ...)` with a clear verification goal. BrowserQA uses the Playwright skill to verify in a real browser and can run safe bash when needed.",
         '- Each assignment includes: goal, acceptance criteria, relevant context, constraints, and verification method.',
+        '- For large tasks: after each slice completes, call `advance_slice` to record progress, then confirm the next slice with the user before dispatching (unless preAuthorized).',
         '- Reuse the same engineer when follow-up work builds on their prior context.',
         '- Only one implementing engineer modifies the worktree at a time. Parallelize exploration, research, and browser verification freely.',
+        '- Context warnings (moderate/high/critical) are informational only. Do NOT reset an engineer session in response to a context warning. Sessions auto-reset only on an actual contextExhausted error.',
         '',
         '## Review: Inspect diffs for production safety',
         '- After an engineer reports implementation done, review the diff with `git_diff` before declaring it complete.',
@@ -66,6 +80,7 @@ export const managerPromptRegistry = {
         '- Questions: Use the `question` tool when a decision will materially affect scope, architecture, or how you verify the outcome. Name the decision, offer 2–3 concrete options, state your recommendation, and say what breaks if the user picks differently. One high-leverage question at a time.',
         '- Reframing: Before planning, ask what the user is actually trying to achieve, not just what they asked for. If the request sounds like a feature, ask what job-to-be-done it serves.',
         '- Engineer selection: When assigning to a single engineer, prefer lower context pressure and less-recently-used engineers. Reuse if follow-up work builds on prior context.',
+        '- Context warnings: At moderate/high/critical context levels the system surfaces a warning. These are advisory — do not force session reset. Reserve reset for actual contextExhausted errors only.',
         '- Failure handling:',
         "  - contextExhausted: The engineer's session ran out of tokens. The system automatically resets and retries once with the same task on a fresh session.",
         '  - sdkError or toolDenied: The underlying SDK failed or a tool call was denied. Investigate the error, adjust constraints, and retry.',
@@ -92,6 +107,7 @@ export const managerPromptRegistry = {
         '',
         'Your wrapper context from prior turns is reloaded automatically. Use it to avoid repeating work or re-explaining context that Claude Code already knows.',
         "Return the tool result directly. Add your own commentary only when something was unexpected or needs the CTO's attention.",
+        'If you discover during implementation that the agreed approach is not viable (unexpected constraints, wrong files, missing context), stop immediately and surface the deviation to the CTO before proceeding with a different approach. Do not silently implement something different from what was confirmed.',
     ].join('\n'),
     engineerSessionPrompt: [
         'You are an expert software engineer working inside Claude Code.',
@@ -149,6 +165,7 @@ export const managerPromptRegistry = {
         '- If lead and challenger engineer names are both specified, use them.',
         '- If either name is missing, `plan_with_team` will auto-select two non-overlapping engineers based on availability and context.',
         'Do not attempt any planning or analysis yourself. Delegate entirely to `plan_with_team`.',
+        'After `plan_with_team` returns, pass the full result back to the CTO unchanged. Do not modify, summarize, or act on the synthesis; the CTO will present it to the user for confirmation.',
     ].join('\n'),
     browserQaAgentPrompt: [
         "You are the browser QA specialist on the CTO's team.",
@@ -165,6 +182,7 @@ export const managerPromptRegistry = {
         '- Never simulate or fabricate test results.',
         '- If the Playwright tool is not available, the result will start with PLAYWRIGHT_UNAVAILABLE:.',
         '- Your persistent Claude Code session remembers prior verification runs.',
+        '- If the verification scope changes unexpectedly (feature absent, URL wrong, task cannot be completed as specified), stop and report the scope mismatch rather than silently verifying something else.',
     ].join('\n'),
     browserQaSessionPrompt: [
         'You are a browser QA specialist. Your job is to verify web features and user flows using the Playwright skill/command.',
@@ -185,8 +203,8 @@ export const managerPromptRegistry = {
         'Allowed tools: Playwright skill/command, safe bash, read-only tools (Read, Grep, Glob). No file editing or code modifications.',
     ].join('\n'),
     contextWarnings: {
-        moderate: 'Engineer context is getting full ({percent}% estimated). Reuse is still fine, but keep the next prompt focused.',
-        high: 'Engineer context is heavy ({percent}% estimated, {turns} turns, ${cost}). Prefer a narrowly scoped follow-up or internal compaction.',
-        critical: 'Engineer context is near capacity ({percent}% estimated). Avoid piling unrelated work into this engineer session.',
+        moderate: 'Engineer context is at {percent}% estimated. Session is healthy; keep the next task focused.',
+        high: 'Engineer context is at {percent}% estimated ({turns} turns, ${cost}). Session continues — prefer a narrowly scoped follow-up.',
+        critical: 'Engineer context is near capacity ({percent}% estimated). Warn only — do not force a reset; avoid large new tasks in this session.',
     },
 };

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/src/types/contracts.d.ts

@@ -116,6 +116,24 @@ export interface SessionContextSnapshot {
     warningLevel: ContextWarningLevel;
     compactionCount: number;
 }
+export type TaskSize = 'trivial' | 'simple' | 'large';
+export interface PlanSlice {
+    index: number;
+    description: string;
+    status: 'pending' | 'in_progress' | 'done' | 'skipped';
+    completedAt?: string;
+}
+export interface ActivePlan {
+    id: string;
+    summary: string;
+    taskSize: TaskSize;
+    createdAt: string;
+    confirmedAt: string | null;
+    preAuthorized: boolean;
+    slices: PlanSlice[];
+    /** Null when the plan has no slices (trivial/simple tasks). */
+    currentSliceIndex: number | null;
+}
 export interface TeamEngineerRecord {
     name: EngineerName;
     wrapperSessionId: string | null;
@@ -142,6 +160,7 @@ export interface TeamRecord {
     createdAt: string;
     updatedAt: string;
     engineers: TeamEngineerRecord[];
+    activePlan?: ActivePlan;
 }
 export interface EngineerTaskResult {
     teamId: string;

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');
     }