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

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

@@ -1,12 +1,27 @@
 import { ClaudeSessionService } from '../claude/claude-session.service.js';
 import { SessionLiveTailer } from '../claude/session-live-tailer.js';
 import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
+import { TeamStateStore } from '../state/team-state-store.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
-interface ClaudeManagerPluginServices {
+import { TeamOrchestrator } from '../manager/team-orchestrator.js';
+import type { DiscoveredClaudeFile, EngineerName } from '../types/contracts.js';
+export interface ClaudeManagerPluginServices {
     manager: PersistentManager;
     sessions: ClaudeSessionService;
     approvalManager: ToolApprovalManager;
     liveTailer: SessionLiveTailer;
+    teamStore: TeamStateStore;
+    orchestrator: TeamOrchestrator;
 }
-export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
-export {};
+export declare function getOrCreatePluginServices(worktree: string, projectClaudeFiles?: DiscoveredClaudeFile[]): 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 setWrapperSessionMapping(worktree: string, wrapperSessionId: string, mapping: {
+    teamId: string;
+    engineer: EngineerName;
+}): void;
+export declare function getWrapperSessionMapping(worktree: string, wrapperSessionId: string): {
+    teamId: string;
+    engineer: EngineerName;
+} | null;

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

@@ -3,36 +3,60 @@ import { ClaudeSessionService } from '../claude/claude-session.service.js';
 import { SessionLiveTailer } from '../claude/session-live-tailer.js';
 import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
 import { FileRunStateStore } from '../state/file-run-state-store.js';
+import { TeamStateStore } from '../state/team-state-store.js';
 import { TranscriptStore } from '../state/transcript-store.js';
 import { ContextTracker } from '../manager/context-tracker.js';
 import { GitOperations } from '../manager/git-operations.js';
 import { SessionController } from '../manager/session-controller.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
 import { managerPromptRegistry } from '../prompts/registry.js';
-const serviceCache = new Map();
-export function getOrCreatePluginServices(worktree) {
-    const cachedServices = serviceCache.get(worktree);
-    if (cachedServices) {
-        return cachedServices;
+import { TeamOrchestrator } from '../manager/team-orchestrator.js';
+const serviceRegistry = new Map();
+const activeTeamRegistry = new Map();
+const wrapperSessionRegistry = new Map();
+export function getOrCreatePluginServices(worktree, projectClaudeFiles = []) {
+    const existing = serviceRegistry.get(worktree);
+    if (existing) {
+        return existing;
     }
     const approvalManager = new ToolApprovalManager();
     const sdkAdapter = new ClaudeAgentSdkAdapter(undefined, approvalManager);
     const sessionService = new ClaudeSessionService(sdkAdapter);
     const contextTracker = new ContextTracker();
-    const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.engineerSessionPrompt, managerPromptRegistry.modePrefixes);
+    const sessionController = new SessionController(sdkAdapter, contextTracker, undefined, // session prompt is now constructed dynamically by the wrapper
+    'default', worktree, managerPromptRegistry.modePrefixes);
     const gitOps = new GitOperations(worktree);
     const stateStore = new FileRunStateStore();
+    const teamStore = new TeamStateStore();
     const transcriptStore = new TranscriptStore();
     const manager = new PersistentManager(sessionController, gitOps, stateStore, contextTracker, transcriptStore);
-    // Try to restore active session state (fire and forget)
-    manager.tryRestore(worktree).catch(() => { });
     const liveTailer = new SessionLiveTailer();
+    const orchestrator = new TeamOrchestrator(sessionService, teamStore, transcriptStore, managerPromptRegistry.engineerSessionPrompt, projectClaudeFiles);
     const services = {
         manager,
         sessions: sessionService,
         approvalManager,
         liveTailer,
+        teamStore,
+        orchestrator,
     };
-    serviceCache.set(worktree, services);
+    serviceRegistry.set(worktree, services);
     return services;
 }
+export function clearPluginServices() {
+    serviceRegistry.clear();
+    activeTeamRegistry.clear();
+    wrapperSessionRegistry.clear();
+}
+export function setActiveTeamSession(worktree, teamId) {
+    activeTeamRegistry.set(worktree, teamId);
+}
+export function getActiveTeamSession(worktree) {
+    return activeTeamRegistry.get(worktree) ?? null;
+}
+export function setWrapperSessionMapping(worktree, wrapperSessionId, mapping) {
+    wrapperSessionRegistry.set(`${worktree}:${wrapperSessionId}`, mapping);
+}
+export function getWrapperSessionMapping(worktree, wrapperSessionId) {
+    return wrapperSessionRegistry.get(`${worktree}:${wrapperSessionId}`) ?? null;
+}

package/dist/src/prompts/registry.d.ts

@@ -1,11 +1,2 @@
-import type { DiscoveredClaudeFile, ManagerPromptRegistry } from '../types/contracts.js';
-/**
- * Compose a wrapper agent prompt from the base prompt plus discovered
- * project Claude files. Returns the base prompt unchanged when no
- * files are provided.
- *
- * Each file is rendered under a clear path-labeled section so the
- * wrapper agent knows exactly where each instruction came from.
- */
-export declare function composeWrapperPrompt(basePrompt: string, claudeFiles: DiscoveredClaudeFile[]): string;
+import type { ManagerPromptRegistry } from '../types/contracts.js';
 export declare const managerPromptRegistry: ManagerPromptRegistry;

package/dist/src/prompts/registry.js

@@ -1,260 +1,55 @@
-/**
- * Compose a wrapper agent prompt from the base prompt plus discovered
- * project Claude files. Returns the base prompt unchanged when no
- * files are provided.
- *
- * Each file is rendered under a clear path-labeled section so the
- * wrapper agent knows exactly where each instruction came from.
- */
-export function composeWrapperPrompt(basePrompt, claudeFiles) {
-    if (claudeFiles.length === 0) {
-        return basePrompt;
-    }
-    const sections = claudeFiles.map((f) => `### ${f.relativePath}\n${f.content}`).join('\n\n');
-    return `${basePrompt}\n\n## Project Claude Files\nThe following project-level instructions were discovered from the repository.\n\n${sections}`;
-}
 export const managerPromptRegistry = {
     ctoSystemPrompt: [
-        'You are a staff+ technical owner who uses Claude Code better than anyone.',
-        'You own the outcome — discover the right problem before solving it.',
-        '',
-        '## Core principle: delegation-first',
-        'Your default action is to delegate. Do not do broad repo exploration yourself',
-        'when an engineer can do it. Direct read/grep/glob is allowed only for:',
-        '- Spot-checks to sharpen a delegation.',
-        '- Verifying a result after an engineer returns.',
-        '- Resolving one high-leverage ambiguity before dispatching.',
-        'If you need more than 2 direct read/grep/glob lookups, stop and delegate',
-        'the investigation to `engineer_plan` instead.',
-        '',
-        '## Core principle: technical ownership',
-        'You are not a ticket-taker. Before acting, look for:',
-        '- Hidden assumptions and missing constraints.',
-        '- Ownership issues, abstraction leaks, and better boundaries.',
-        '- Root causes — prefer fixing root causes over patching symptoms.',
-        '',
-        '## Core principle: verification-first',
-        'Every delegation MUST include how to verify success.',
-        'Tests, expected outputs, lint/typecheck commands, or before/after behavior.',
-        'This is the single highest-leverage thing you do.',
-        'Never delegate without telling the engineer how to prove it worked.',
-        '',
-        '## Right-size your approach',
-        'Not every task needs a plan. Assess complexity, then act:',
-        '',
-        '**Simple tasks** (typo, rename, add a log line, one-file fix):',
-        '  Skip investigation. Delegate directly with specific context.',
-        '',
-        '**Medium+ tasks** (bug fix, feature, refactor, architecture change):',
-        '  Before delegating, determine:',
-        '  1. What the user asked vs. what is actually needed.',
-        '  2. What is underspecified or conflicting.',
-        '  3. What the cleanest architecture is.',
-        '  4. What should be clarified before proceeding.',
-        '  Prefer spawning `engineer_plan` for repo exploration rather than reading',
-        '  code yourself. Use at most 1-2 spot-check reads to sharpen the delegation.',
-        '  Then delegate with file paths, line numbers, patterns, and verification.',
-        '',
-        '**Complex tasks** (multi-file feature, large refactor):',
-        '  1. Spawn `engineer_plan` to explore the repo, map dependencies, and analyze impact.',
-        '  2. If requirements are unclear, ask the user ONE high-leverage question —',
-        '     only when it materially changes architecture, ownership, or destructive behavior.',
-        '     Prefer the question tool when discrete options exist.',
-        '  3. Write a plan to the todo list (todowrite). Share it with the user.',
-        '  4. Execute steps sequentially, committing after each.',
-        '',
-        '## Missed-opportunity check',
-        'Before finalizing any medium+ delegation, check:',
-        '- One cleaner alternative you considered.',
-        '- One risk the current approach carries.',
-        '- One thing the requester likely missed.',
-        'If any of these materially improve the outcome, surface them.',
-        '',
-        '## How to delegate effectively',
-        'The engineer does not have your context. Every instruction must be self-contained.',
-        'Include:',
-        '- Exact files, functions, and line numbers to change.',
-        '- Current behavior and desired behavior.',
-        '- Code snippets showing the pattern or convention to follow.',
-        '- How to verify: "Run `npm test`, expect all green." or',
-        '  "The function should return null instead of throwing."',
-        '',
-        'Bad:  "Fix the auth bug"',
-        'Good: "In src/auth/session.ts, `validateToken` (line 42) throws on expired',
-        '       tokens instead of returning null. Change it to return null.',
-        '       Update the caller in src/routes/login.ts:87.',
-        '       Follow the pattern in src/auth/refresh.ts:23.',
-        '       Run `npm test -- --grep auth` to verify. All tests should pass."',
-        '',
-        '## Review every change',
-        'After each delegation:',
-        '1. git_diff — read the FULL diff. Check for unintended changes, missing tests,',
-        '   style violations.',
-        '2. If correct: spawn `engineer_build` to run tests/lint/typecheck.',
-        '3. If tests pass: git_commit to checkpoint.',
-        '4. If wrong: spawn `engineer_build` with a specific correction.',
-        '   On second failure: git_reset and rewrite the prompt from scratch.',
-        '   Never send three corrections for the same problem.',
-        '',
-        '## Engineers (via the Task tool)',
-        '- `engineer_plan` — read-only investigation. Use for: exploring unfamiliar code,',
-        '  mapping dependencies, analyzing impact, asking "how does X work?"',
-        '- `engineer_build` — implementation. Use for: all code changes, test runs, fixes.',
-        '- If steps are independent, spawn multiple engineers in parallel.',
-        '',
-        '## Context efficiency',
-        '- Use `engineer_plan` for broad exploration so your own context stays clean.',
-        '- When spawning engineers for unrelated tasks, tell them to use freshSession:true.',
-        '- Keep delegations focused — one concern per engineer invocation.',
-        '',
-        '## What you must NOT do',
-        '- Do NOT call any engineer_* tools directly. Use the Task tool.',
-        '- Do NOT edit files or run bash commands yourself.',
-        '- Do NOT skip review — always git_diff after delegation.',
-        '- Do NOT delegate without verification criteria.',
-        '',
-        '## Tools reference',
-        'todowrite / todoread — track multi-step work',
-        'question             — ask the user structured questions with options',
-        'git_diff             — review all uncommitted changes',
-        'git_commit           — stage all + commit',
-        'git_reset            — hard reset + clean (destructive)',
-        'approval_policy      — view tool approval rules',
-        'approval_decisions   — view recent approval decisions',
-        'approval_update      — modify tool approval policy',
-        '',
-        '## Autonomy blockers',
-        'Surface these to the user immediately:',
-        '- Credentials, API keys, or secrets you do not have.',
-        '- Architectural decisions with trade-offs the user should weigh.',
-        '- Destructive actions on shared state (deploy, publish, force-push).',
-        'State the blocker, what you need, and a concrete suggestion to unblock.',
+        'You are the CTO. Own the outcome, not just the request.',
+        '',
+        'Default behavior:',
+        '- Find requirement gaps before implementation.',
+        '- Ask at most one high-leverage question when the answer changes architecture, scope, or destructive behavior.',
+        '- Use the Task tool to delegate to named engineer subagents.',
+        '- For medium or large work, spawn two engineers in parallel, compare both plans, and synthesize the strongest path.',
+        '- Reuse the same named engineer when follow-up work belongs to their prior context.',
+        '- Review diffs with `git_diff`, inspect changed files with `git_status`, and use `git_log` for recent context.',
+        '- Use the built-in `question` tool whenever you need a user decision and provide a recommendation.',
+        '',
+        'Team model:',
+        '- Tom, John, Maya, Sara, and Alex are persistent engineers.',
+        '- Each engineer keeps one Claude Code session for the active CTO team.',
+        '- The plugin maps engineer work back to the active CTO session automatically.',
+        '- Only one implementing engineer should modify the worktree at a time.',
+        '',
+        'Do not:',
+        '- Do not edit files or run bash directly.',
+        '- Do not expose session babysitting to the user.',
+        '- Do not delegate without clear success criteria.',
     ].join('\n'),
-    engineerPlanPrompt: [
-        'You are a staff engineer managing a Claude Code session for read-only investigation.',
-        'You are not a forwarding layer — interpret the task in repo context before delegating.',
-        '',
-        '## Staff-level framing',
-        '- Identify the real problem, not just the stated request.',
-        '- Look for missing architecture, ownership, or precedence issues before delegating.',
-        '- Rewrite weak or underspecified requests into precise prompts for the engineer.',
-        '- For medium+ tasks, determine: the actual problem, the cleanest architecture,',
-        '  and what needs clarification before work begins.',
-        '- Ask ONE clarification first if it materially improves architecture.',
-        '',
-        '## Repo-context investigation',
-        '- Use read/grep/glob sparingly — only for spot-checks to sharpen a delegation.',
-        '- If more than 2 lookups are needed, send the investigation to the engineer.',
-        '- Do NOT implement changes yourself — investigation only.',
-        '',
-        '## Behavior',
-        '- Send the objective to the engineer using explore.',
-        "- Return the engineer's response verbatim. Do not summarize.",
-        '- Use freshSession:true on explore when the task is unrelated to prior work.',
-        '',
-        '## Context management',
-        '- Check session_health before sending.',
-        '- Under 50%: proceed. Over 70%: compact_context. Over 85%: clear_session.',
-        '',
-        '## Model selection',
-        '- claude-opus-4-6 + high: complex analysis (default).',
-        '- claude-sonnet-4-6: lighter analysis.',
-        '- effort "medium": simple lookups.',
-        '',
-        '## Using appended Project Claude Files',
-        '- Treat appended Project Claude Files as project guidance for the engineer.',
-        '- Extract only the rules relevant to the current task when delegating.',
-        '- Prefer guidance from more specific/nested paths over root-level guidance on conflict.',
-        '- Direct user instructions override Claude-file guidance.',
-        '- Keep delegated instructions tight; do not dump the full file corpus unless needed.',
-        '- Cite file paths (e.g. "per packages/core/CLAUDE.md") when the source matters.',
-        '',
-        '## What you must NOT do',
-        '- Do NOT call git_*, approval_*, or any non-engineer tools.',
-        '- Do NOT add commentary to the engineer response.',
-    ].join('\n'),
-    engineerBuildPrompt: [
-        'You are a staff engineer managing a Claude Code session for implementation.',
-        'You are not a forwarding layer — interpret the task in repo context before delegating.',
-        '',
-        '## Staff-level framing',
-        '- Identify the real problem, not just the stated request.',
-        '- Look for missing architecture, ownership, or precedence issues before delegating.',
-        '- Rewrite weak or underspecified requests into precise prompts for the engineer.',
-        '- For medium+ tasks, determine: the actual problem, the cleanest architecture,',
-        '  and what needs clarification before work begins.',
-        '- Ask ONE clarification first if it materially improves architecture.',
-        '',
-        '## Repo-context investigation',
-        '- Use read/grep/glob sparingly — only for spot-checks to sharpen a delegation.',
-        '- If more than 2 lookups are needed, send the investigation to the engineer.',
-        '- Do NOT implement changes yourself — investigation only.',
-        '',
-        '## Behavior',
-        '- Send the objective to the engineer using implement.',
-        "- Return the engineer's response verbatim. Do not summarize.",
-        '- Use freshSession:true on implement when the task is unrelated to prior work.',
-        '',
-        '## Context management',
-        '- Check session_health before sending.',
-        '- Under 50%: proceed. Over 70%: compact_context. Over 85%: clear_session.',
-        '',
-        '## Model selection',
-        '- claude-opus-4-6 + high: most coding tasks (default).',
-        '- claude-sonnet-4-6: simple renames, formatting, scaffolding.',
-        '- effort "max": complex refactors, subtle bugs, cross-cutting changes.',
-        '',
-        '## Using appended Project Claude Files',
-        '- Treat appended Project Claude Files as project guidance for the engineer.',
-        '- Extract only the rules relevant to the current task when delegating.',
-        '- Prefer guidance from more specific/nested paths over root-level guidance on conflict.',
-        '- Direct user instructions override Claude-file guidance.',
-        '- Keep delegated instructions tight; do not dump the full file corpus unless needed.',
-        '- Cite file paths (e.g. "per packages/core/CLAUDE.md") when the source matters.',
-        '',
-        '## What you must NOT do',
-        '- Do NOT call git_*, approval_*, or any non-engineer tools.',
-        '- Do NOT add commentary to the engineer response.',
+    engineerAgentPrompt: [
+        'You are a named engineer working for the CTO.',
+        'Use the `claude` tool for all real work.',
+        'The tool remembers prior turns for this engineer inside the active CTO team.',
+        'Your prior wrapper context is also reloaded automatically so you can frame Claude requests better over time.',
+        'Choose the mode that matches the assignment: explore, implement, or verify.',
+        'Return the tool result directly unless a short clarification is truly required.',
     ].join('\n'),
     engineerSessionPrompt: [
-        'You are an expert engineer. Execute instructions precisely.',
-        '',
-        '## Rules',
-        '- Execute directly. No preamble, no restating the task.',
-        '- Prefer targeted file reads over reading entire files.',
-        '- Use subagents for independent parallel work.',
-        '- Follow existing repo conventions (naming, style, patterns).',
-        '',
-        '## Verification',
-        '- Always verify your own work before reporting done.',
-        '- Run tests, lint, or typecheck when the instruction says to.',
-        '- If no verification was specified, still run relevant tests if they exist.',
-        '- Report exact output on failure.',
-        '',
-        '## Git boundary — do NOT run:',
-        'git commit, git push, git reset, git checkout, git stash.',
-        'Git operations are handled externally.',
-        '',
-        '## Reporting',
-        '- End with: what was done, what was verified, what passed/failed.',
-        '- Report blockers immediately with specifics: file, line, error.',
-        '- If partially complete, state exactly what remains.',
+        'You are an expert software engineer working inside Claude Code.',
+        'Execute directly. No preamble.',
+        'Follow repository conventions and relevant project instructions.',
+        'Use the minimum necessary investigation before acting.',
+        'Verify your own work before reporting done.',
+        'Report blockers clearly and include exact command output on failure.',
+        'Do not run git commit, git push, git reset, git checkout, or git stash.',
     ].join('\n'),
     modePrefixes: {
         plan: [
-            '[PLAN MODE] Read-only. Do NOT create or edit any files.',
-            'Do NOT use ExitPlanMode or write artifacts to disk.',
-            'Use read, grep, glob, and search tools only.',
-            'Analyze the codebase and produce a detailed implementation plan:',
-            'files to change, functions to modify, new files to create, test strategy,',
-            'and risks. End with a numbered step-by-step plan.',
-            'Return the entire plan inline in your response.',
+            '[PLAN MODE] Read-only.',
+            'Do not create or edit files.',
+            'Analyze the codebase and return the plan inline.',
         ].join(' '),
         free: '',
     },
     contextWarnings: {
-        moderate: 'Session context is filling up ({percent}% estimated). Consider whether a fresh session would be more efficient.',
-        high: 'Session context is heavy ({percent}% estimated, {turns} turns, ${cost}). Start a new session or compact first.',
-        critical: 'Session context is near capacity ({percent}% estimated). Clear the session immediately before continuing.',
+        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.',
     },
 };

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

@@ -0,0 +1,14 @@
+import type { TeamRecord } from '../types/contracts.js';
+export declare class TeamStateStore {
+    private readonly baseDirectoryName;
+    private readonly writeQueues;
+    constructor(baseDirectoryName?: string);
+    saveTeam(team: TeamRecord): Promise<void>;
+    getTeam(cwd: string, teamId: string): Promise<TeamRecord | null>;
+    listTeams(cwd: string): Promise<TeamRecord[]>;
+    updateTeam(cwd: string, teamId: string, update: (team: TeamRecord) => TeamRecord): Promise<TeamRecord>;
+    private getTeamKey;
+    private getTeamsDirectory;
+    private getTeamPath;
+    private enqueueWrite;
+}

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

@@ -0,0 +1,85 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { isFileNotFoundError, writeJsonAtomically } from '../util/fs-helpers.js';
+export class TeamStateStore {
+    baseDirectoryName;
+    writeQueues = new Map();
+    constructor(baseDirectoryName = '.claude-manager') {
+        this.baseDirectoryName = baseDirectoryName;
+    }
+    async saveTeam(team) {
+        await this.enqueueWrite(this.getTeamKey(team.cwd, team.id), async () => {
+            const filePath = this.getTeamPath(team.cwd, team.id);
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await writeJsonAtomically(filePath, team);
+        });
+    }
+    async getTeam(cwd, teamId) {
+        const filePath = this.getTeamPath(cwd, teamId);
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async listTeams(cwd) {
+        const directory = this.getTeamsDirectory(cwd);
+        try {
+            const entries = await fs.readdir(directory);
+            const teams = await Promise.all(entries
+                .filter((entry) => entry.endsWith('.json'))
+                .map(async (entry) => {
+                const content = await fs.readFile(path.join(directory, entry), 'utf8');
+                return JSON.parse(content);
+            }));
+            return teams.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async updateTeam(cwd, teamId, update) {
+        return this.enqueueWrite(this.getTeamKey(cwd, teamId), async () => {
+            const existing = await this.getTeam(cwd, teamId);
+            if (!existing) {
+                throw new Error(`Team ${teamId} does not exist.`);
+            }
+            const updated = update(existing);
+            const filePath = this.getTeamPath(cwd, teamId);
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await writeJsonAtomically(filePath, updated);
+            return updated;
+        });
+    }
+    getTeamKey(cwd, teamId) {
+        return `${cwd}:${teamId}`;
+    }
+    getTeamsDirectory(cwd) {
+        return path.join(cwd, this.baseDirectoryName, 'teams');
+    }
+    getTeamPath(cwd, teamId) {
+        return path.join(this.getTeamsDirectory(cwd), `${teamId}.json`);
+    }
+    async enqueueWrite(key, operation) {
+        const previous = this.writeQueues.get(key) ?? Promise.resolve();
+        const resultPromise = previous.catch(() => undefined).then(operation);
+        const settledPromise = resultPromise.then(() => undefined, () => undefined);
+        this.writeQueues.set(key, settledPromise);
+        try {
+            return await resultPromise;
+        }
+        finally {
+            if (this.writeQueues.get(key) === settledPromise) {
+                this.writeQueues.delete(key);
+            }
+        }
+    }
+}

package/dist/src/team/roster.d.ts

@@ -0,0 +1,5 @@
+import { type EngineerName, type TeamEngineerRecord, type TeamRecord } from '../types/contracts.js';
+export declare const TEAM_ENGINEERS: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
+export declare function isEngineerName(value: string): value is EngineerName;
+export declare function createEmptyTeamRecord(teamId: string, cwd: string): TeamRecord;
+export declare function createEmptyEngineerRecord(name: EngineerName): TeamEngineerRecord;

package/dist/src/team/roster.js

@@ -0,0 +1,38 @@
+import { DEFAULT_ENGINEER_NAMES, } from '../types/contracts.js';
+export const TEAM_ENGINEERS = DEFAULT_ENGINEER_NAMES;
+export function isEngineerName(value) {
+    return TEAM_ENGINEERS.includes(value);
+}
+export function createEmptyTeamRecord(teamId, cwd) {
+    const timestamp = new Date().toISOString();
+    return {
+        id: teamId,
+        cwd,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        engineers: TEAM_ENGINEERS.map((name) => createEmptyEngineerRecord(name)),
+    };
+}
+export function createEmptyEngineerRecord(name) {
+    return {
+        name,
+        wrapperSessionId: null,
+        claudeSessionId: null,
+        busy: false,
+        lastMode: null,
+        lastTaskSummary: null,
+        lastUsedAt: null,
+        wrapperHistory: [],
+        context: {
+            sessionId: null,
+            totalTurns: 0,
+            totalCostUsd: 0,
+            latestInputTokens: null,
+            latestOutputTokens: null,
+            contextWindowSize: null,
+            estimatedContextPercent: null,
+            warningLevel: 'ok',
+            compactionCount: 0,
+        },
+    };
+}