@doingdev/opencode-claude-manager-plugin 0.1.64 → 0.1.66

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

@@ -1,38 +0,0 @@
-import { ClaudeSessionService } from '../claude/claude-session.service.js';
-import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
-import { PersistentManager } from '../manager/persistent-manager.js';
-import { TeamOrchestrator } from '../manager/team-orchestrator.js';
-import { TeamStateStore } from '../state/team-state-store.js';
-import type { EngineerName, WorkerCapabilities } from '../types/contracts.js';
-interface ClaudeManagerPluginServices {
-    manager: PersistentManager;
-    sessions: ClaudeSessionService;
-    approvalManager: ToolApprovalManager;
-    teamStore: TeamStateStore;
-    orchestrator: TeamOrchestrator;
-    workerCapabilities: Partial<Record<EngineerName, WorkerCapabilities>>;
-    debugLogPath: string;
-}
-export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
-export declare function clearPluginServices(): void;
-export declare function isRevertAlreadyProcessed(ctoSessionId: string, revertMessageId: string): boolean;
-export declare function markRevertProcessed(ctoSessionId: string, revertMessageId: string): void;
-export declare function clearRevertProcessed(ctoSessionId: string, revertMessageId: string): void;
-/**
- * Clear the latest dedup entry for a CTO session — called when the revert marker disappears
- * so that a subsequent undo of the same message can be processed again.
- */
-export declare function clearLatestRevertProcessed(ctoSessionId: string): 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;
-}): void;
-export declare function getWrapperSessionMapping(worktree: string, wrapperSessionId: string): {
-    teamId: string;
-    workerName: EngineerName;
-} | null;
-export {};

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

@@ -1,101 +0,0 @@
-import path from 'node:path';
-import { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
-import { ClaudeSessionService } from '../claude/claude-session.service.js';
-import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
-import { GitOperations } from '../manager/git-operations.js';
-import { PersistentManager } from '../manager/persistent-manager.js';
-import { TeamOrchestrator } from '../manager/team-orchestrator.js';
-import { managerPromptRegistry } from '../prompts/registry.js';
-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 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();
-/**
- * Dedupe set for processed CTO undo events.
- * Key format: "${ctoSessionId}:${revertMessageId}".
- * Cleared when the session no longer shows a revert marker (via a subsequent session.updated
- * with no revert field) or on a full service reset.
- */
-const processedRevertRegistry = new Set();
-/** ctoSessionId → latest processed revertMessageId — used to clear stale dedup entries when the revert marker disappears */
-const latestRevertRegistry = new Map();
-export function getOrCreatePluginServices(worktree) {
-    const existing = serviceRegistry.get(worktree);
-    if (existing) {
-        return existing;
-    }
-    const approvalPolicyPath = path.join(worktree, '.claude-manager', 'approval-policy.json');
-    const debugLogPath = path.join(worktree, '.claude-manager', 'debug.log');
-    const approvalManager = new ToolApprovalManager(undefined, undefined, approvalPolicyPath);
-    const sdkAdapter = new ClaudeAgentSdkAdapter(undefined, approvalManager, debugLogPath);
-    const sessionService = new ClaudeSessionService(sdkAdapter);
-    const gitOps = new GitOperations(worktree);
-    const teamStore = new TeamStateStore();
-    const transcriptStore = new TranscriptStore();
-    const manager = new PersistentManager(gitOps, transcriptStore);
-    const workerCapabilities = buildWorkerCapabilities(managerPromptRegistry);
-    const orchestrator = new TeamOrchestrator(sessionService, teamStore, transcriptStore, managerPromptRegistry.engineerSessionPrompt, managerPromptRegistry.planSynthesisPrompt, workerCapabilities);
-    const services = {
-        manager,
-        sessions: sessionService,
-        approvalManager,
-        teamStore,
-        orchestrator,
-        workerCapabilities,
-        debugLogPath,
-    };
-    serviceRegistry.set(worktree, services);
-    return services;
-}
-export function clearPluginServices() {
-    serviceRegistry.clear();
-    wrapperSessionRegistry.clear();
-    parentSessionRegistry.clear();
-    sessionTeamRegistry.clear();
-    processedRevertRegistry.clear();
-    latestRevertRegistry.clear();
-}
-export function isRevertAlreadyProcessed(ctoSessionId, revertMessageId) {
-    return processedRevertRegistry.has(`${ctoSessionId}:${revertMessageId}`);
-}
-export function markRevertProcessed(ctoSessionId, revertMessageId) {
-    processedRevertRegistry.add(`${ctoSessionId}:${revertMessageId}`);
-    latestRevertRegistry.set(ctoSessionId, revertMessageId);
-}
-export function clearRevertProcessed(ctoSessionId, revertMessageId) {
-    processedRevertRegistry.delete(`${ctoSessionId}:${revertMessageId}`);
-}
-/**
- * Clear the latest dedup entry for a CTO session — called when the revert marker disappears
- * so that a subsequent undo of the same message can be processed again.
- */
-export function clearLatestRevertProcessed(ctoSessionId) {
-    const revertMessageId = latestRevertRegistry.get(ctoSessionId);
-    if (revertMessageId !== undefined) {
-        processedRevertRegistry.delete(`${ctoSessionId}:${revertMessageId}`);
-        latestRevertRegistry.delete(ctoSessionId);
-    }
-}
-export function registerParentSession(childId, parentId) {
-    parentSessionRegistry.set(childId, parentId);
-}
-export function getParentSessionId(childId) {
-    return parentSessionRegistry.get(childId);
-}
-export function registerSessionTeam(sessionId, teamId) {
-    sessionTeamRegistry.set(sessionId, teamId);
-}
-export function getSessionTeam(sessionId) {
-    return sessionTeamRegistry.get(sessionId);
-}
-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,2 +0,0 @@
-import type { ManagerPromptRegistry } from '../types/contracts.js';
-export declare const managerPromptRegistry: ManagerPromptRegistry;

package/dist/src/prompts/registry.js

@@ -1,210 +0,0 @@
-export const managerPromptRegistry = {
-    ctoSystemPrompt: [
-        'You are a principal engineer orchestrating a team of AI-powered engineers.',
-        'Your role is to investigate first, 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 → Investigate → Decide → Delegate → Review → Verify → Close',
-        'Treat this loop as adaptive, not rigid. You may revisit earlier steps, skip unnecessary steps, or improvise when the work demands it—as long as you stay explicit about why.',
-        '',
-        '## 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.',
-        '- Light investigation is fine: read files briefly to understand scope, check what already exists, avoid re-inventing.',
-        '- When a bug is reported, ask: what is the root cause? Do not assume. Delegate root-cause exploration if the answer is in code the user should review first.',
-        '- If requirements are vague or architecture is unclear, use `question` tool with 2–3 concrete options, your recommendation, and what breaks if user picks differently.',
-        '- Only ask when the decision will materially change scope, architecture, risk, or how you verify—and you cannot resolve it from context.',
-        '',
-        '## Investigate: Reduce uncertainty before choosing a path',
-        '- Start with the smallest useful investigation. For a bug, get to root cause. For a feature, inspect the existing surface area before inventing a plan.',
-        '- You may investigate yourself with read-only tools or delegate exploration to one engineer when that is faster or gives better continuity.',
-        '- When delegating exploration, explicitly say what artifact you want back: root cause, findings, affected files, options, risk review, file map, or a concrete plan.',
-        '- Do not default exploration to planning. Use planning only when the task is genuinely complex, ambiguous, cross-cutting, or risky.',
-        '',
-        '## Decide: Choose the lightest process that fits 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)?',
-        '- For trivial or simple work with clear scope: delegate directly to one engineer.',
-        '- For bugs or unclear requests: investigate first, then decide whether implementation is now straightforward.',
-        "- For complex or cross-cutting work: use `task(subagent_type: 'team-planner', ...)` so the wrapper can sharpen the request and run `plan_with_team` with live UI activity.",
-        '- Ask the user to confirm only when the decision materially changes scope, risk, rollout, or architecture. Do not force confirmation for every non-trivial task.',
-        '',
-        '## Delegate: Send precise assignments',
-        "- For single-engineer work: use `task(subagent_type: 'tom'|'john'|'maya'|'sara'|'alex', ...)` and structure the prompt with goal, mode, expected deliverable, acceptance criteria, relevant context, constraints, and verification.",
-        "- For complex planning work: use `task(subagent_type: 'team-planner', ...)`. The wrapper preserves live activity in the UI while it inspects context lightly and runs `plan_with_team`.",
-        "- 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.",
-        '- For large tasks: break work into genuine vertical slices before implementation. 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.',
-        '- Break work into independent pieces that can run in parallel. Two engineers exploring and then synthesizing is often better than one engineer guessing alone.',
-        '- Before delegating, state success criteria and expected output shape, not just the task. Say what done looks like and how you will verify it.',
-        '- If planning surfaced a recommendedQuestion or the work is risky enough to need confirmation, use the `question` tool before implementation. Otherwise, delegate directly.',
-        '',
-        '- Each assignment includes: goal, mode, expected deliverable, acceptance criteria, relevant context, constraints, and verification method.',
-        '- 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.',
-        '- Use `git_log` and `git_status` for recent context.',
-        '- Check for these production-risk patterns (issues tests may not catch):',
-        '  - Race conditions: concurrent access to shared state, missing locks or atomic operations.',
-        '  - N+1 queries: loops that fetch data repeatedly instead of batch-loading.',
-        '  - Missing error handling: uncaught exceptions, unhandled promise rejections, missing null checks.',
-        '  - Trust boundary violations: user input used without validation, permissions not checked.',
-        '  - Stale reads: reading state without synchronization or caching without invalidation logic.',
-        '  - Forgotten enum cases: switches without default, missing case handlers.',
-        '  - Backwards compatibility: breaking API changes, schema migrations without rollback plan.',
-        '  - Observability gaps: no logging, metrics, or tracing for critical paths.',
-        '  - Rollout risk: changes that must be coordinated across services or require staged rollout.',
-        '- Give specific, actionable feedback. Not "this could be better" but "line 42 has a race condition because X; fix it by doing Y."',
-        '- Trust engineer findings but verify critical claims.',
-        '- Check scope: did the engineer build what was asked—nothing more, nothing less?',
-        '',
-        '## Verify: Run checks before shipping',
-        '- After review passes, dispatch an engineer in verify mode to run the most relevant checks (tests, lint, typecheck, build) for what changed.',
-        '- Do not declare a task complete until verification passes. If it fails, fix and re-verify.',
-        '',
-        '## Close: Report outcome to user',
-        '- If everything verifies and passes review, tell the user the work is done and what changed.',
-        '- If a recommended question from planning was not yet surfaced to the user, surface it now with `question` tool before closing.',
-        '- If the work discovered unexpected scope or product decisions, ask the user before proceeding further.',
-        '',
-        '# Decision-Making Rules',
-        '',
-        '- 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.',
-        '- Exploration outputs: when you send an engineer in explore mode, specify the expected output explicitly. Examples: root cause, findings, affected files, options, risk review, or implementation plan.',
-        '- 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.',
-        '  - engineerBusy: Wait, or choose a different engineer.',
-        '  - aborted: The user cancelled the work. Stop and report the cancellation.',
-        '',
-        '# Constraints',
-        '',
-        '- Do not edit files or run bash directly. Engineers do the hands-on work.',
-        '- Light investigation is fine for orientation (read, grep, glob). Delegate deeper exploration if it saves the engineer context.',
-        '- Communicate proactively. If the plan changes or you discover something unexpected, tell the user.',
-        '- Do not proceed with implementation if you cannot state success criteria.',
-    ].join('\n'),
-    engineerAgentPrompt: [
-        "You are a named engineer on the CTO's team.",
-        'The CTO sends assignments through a structured prompt containing: goal, mode (explore/implement/verify), context, acceptance criteria, relevant paths, constraints, and verification method.',
-        'Your job is to parse the assignment and run it through the `claude` tool, which connects to a persistent Claude Code session that remembers your prior turns.',
-        '',
-        'How to handle assignments:',
-        '- Extract goal, mode, acceptance criteria, relevant files, and verification from the prompt.',
-        '- If any critical field is missing (e.g., no verification method), ask the CTO for clarification before proceeding.',
-        '- Frame the assignment for Claude Code using the provided structure.',
-        '- Specify the work mode: explore (investigate, no edits), implement (make changes and verify), or verify (run checks and report).',
-        '',
-        '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.",
-        'Explore mode is caller-directed. Follow the requested output shape instead of defaulting to a plan. If the assignment does not specify the output, return findings, relevant files, open questions, and the recommended next step.',
-        '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.',
-        'Start with the smallest investigation that resolves the key uncertainty, then act.',
-        'Follow repository conventions, AGENTS.md, and any project-level instructions.',
-        '',
-        'When investigating bugs:',
-        '- Always explore the root cause before implementing a fix. Do not assume; verify.',
-        '- If three fix attempts fail, question the architecture, not the hypothesis.',
-        '- In explore mode, return the artifact the caller asked for. Do not default to a plan unless the caller explicitly asks for one.',
-        '',
-        'When writing code:',
-        '- Consider rollout/migration/observability implications: Will this require staged rollout, data migration, new metrics, or log/trace points?',
-        '- Check for backwards compatibility: Will this change break existing APIs, integrations, or data formats?',
-        '- Think about failure modes: What happens if this code fails? Is it recoverable? Is there an audit trail?',
-        '',
-        'Verify your work before reporting done:',
-        '- Run the most relevant check (test, lint, typecheck, build) for what you changed.',
-        '- Review your own diff. Look for these issues tests may not catch:',
-        '  - Race conditions (concurrent access, missing locks).',
-        '  - N+1 queries or similar performance patterns.',
-        '  - Missing error handling or unhandled edge cases.',
-        '  - Hardcoded values that should be configurable.',
-        '  - Incomplete enum handling (missing cases).',
-        '  - Trust boundary violations (user input not validated).',
-        '  - Stale reads or cache invalidation bugs.',
-        '',
-        'Report blockers immediately with exact error output. Do not retry silently more than once.',
-        'Do not run git commit, git push, git reset, git checkout, or git stash.',
-    ].join('\n'),
-    planSynthesisPrompt: [
-        'You are synthesizing two independent engineering plans into one stronger, unified plan.',
-        'Compare the lead and challenger plans on clarity, feasibility, risk, and fit to the user request.',
-        'Prefer the simplest path that fully addresses the goal. Surface tradeoffs honestly.',
-        '',
-        'Identify the single most important decision the user must make to execute this plan safely and correctly.',
-        '- Look for disagreements between plans, scope boundaries, deployment/rollout strategy, backwards compatibility, or architectural tradeoffs.',
-        '- The user may have stated preferences in their request; check if anything is still unsolved.',
-        'Write it as Recommended Question and Recommended Answer. Only write NONE if no external decision is genuinely required.',
-        '',
-        'Do not editorialize or over-explain. Be direct and concise.',
-        '',
-        'Use this output format exactly:',
-        '## Synthesis',
-        '<combined plan>',
-        '## Recommended Question',
-        '<question or NONE>',
-        '## Recommended Answer',
-        '<answer or NONE>',
-    ].join('\n'),
-    teamPlannerPrompt: [
-        'You are the team-planner wrapper. Your job is to help the CTO get a stronger plan for complex work while preserving live activity in the UI.',
-        '`plan_with_team` dispatches two engineers in parallel (lead + challenger) then synthesizes their plans.',
-        '',
-        'Call `plan_with_team` with the task and any engineer names provided.',
-        '- 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.',
-        '- Keep the wrapper thin. Do not do your own repo investigation or solo planning.',
-        '- If the request is blocked by a missing decision, ask one focused question with a recommendation instead of guessing.',
-        'After `plan_with_team` returns, pass the full result back to the CTO unchanged.',
-    ].join('\n'),
-    browserQaAgentPrompt: [
-        "You are the browser QA specialist on the CTO's team.",
-        'Your job is to run browser verification tasks through the `claude` tool.',
-        'The CTO will send tasks requesting you to test a website or web feature using the Playwright skill/command.',
-        '',
-        'How to handle verification tasks:',
-        '- Extract the verification goal and relevant context from the prompt.',
-        '- Use the `claude` tool with mode: "verify" and request Claude Code to use the Playwright skill/command.',
-        '- Instruct Claude Code: "Use the Playwright skill/command for real browser testing. If unavailable, report PLAYWRIGHT_UNAVAILABLE: <reason> and stop."',
-        '- Return the tool result directly—do not add commentary unless something unexpected occurred.',
-        '',
-        'Important:',
-        '- 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.',
-        '',
-        'For each verification task:',
-        '1. Use the Playwright skill/command to control a real browser.',
-        '2. Navigate to the specified URL, interact with the UI, and verify the expected behavior.',
-        '3. Take screenshots and collect specific error messages if verification fails.',
-        '4. Report results concisely: what was tested, pass/fail status, any errors or unexpected behavior.',
-        '',
-        'CRITICAL: If the Playwright skill or command is unavailable (not installed, command not found, skill not loaded):',
-        '- Output EXACTLY as the first line of your response:',
-        '  PLAYWRIGHT_UNAVAILABLE: <specific reason>',
-        '- Do not attempt to verify by other means.',
-        '- Do not simulate or fabricate test results.',
-        '- Stop after reporting unavailability.',
-        '',
-        '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 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/file-run-state-store.d.ts

@@ -1,14 +0,0 @@
-import type { PersistentRunRecord } from '../types/contracts.js';
-export declare class FileRunStateStore {
-    private readonly baseDirectoryName;
-    private readonly writeQueues;
-    constructor(baseDirectoryName?: string);
-    saveRun(run: PersistentRunRecord): Promise<void>;
-    getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
-    listRuns(cwd: string): Promise<PersistentRunRecord[]>;
-    updateRun(cwd: string, runId: string, update: (run: PersistentRunRecord) => PersistentRunRecord): Promise<PersistentRunRecord>;
-    private getRunKey;
-    private getRunsDirectory;
-    private getRunPath;
-    private enqueueWrite;
-}

package/dist/src/state/file-run-state-store.js

@@ -1,85 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { isFileNotFoundError, writeJsonAtomically } from '../util/fs-helpers.js';
-export class FileRunStateStore {
-    baseDirectoryName;
-    writeQueues = new Map();
-    constructor(baseDirectoryName = '.claude-manager') {
-        this.baseDirectoryName = baseDirectoryName;
-    }
-    async saveRun(run) {
-        await this.enqueueWrite(this.getRunKey(run.cwd, run.id), async () => {
-            const runPath = this.getRunPath(run.cwd, run.id);
-            await fs.mkdir(path.dirname(runPath), { recursive: true });
-            await writeJsonAtomically(runPath, run);
-        });
-    }
-    async getRun(cwd, runId) {
-        const runPath = this.getRunPath(cwd, runId);
-        try {
-            const content = await fs.readFile(runPath, 'utf8');
-            return JSON.parse(content);
-        }
-        catch (error) {
-            if (isFileNotFoundError(error)) {
-                return null;
-            }
-            throw error;
-        }
-    }
-    async listRuns(cwd) {
-        const runsDirectory = this.getRunsDirectory(cwd);
-        try {
-            const entries = await fs.readdir(runsDirectory);
-            const runs = await Promise.all(entries
-                .filter((entry) => entry.endsWith('.json'))
-                .map(async (entry) => {
-                const content = await fs.readFile(path.join(runsDirectory, entry), 'utf8');
-                return JSON.parse(content);
-            }));
-            return runs.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-        }
-        catch (error) {
-            if (isFileNotFoundError(error)) {
-                return [];
-            }
-            throw error;
-        }
-    }
-    async updateRun(cwd, runId, update) {
-        return this.enqueueWrite(this.getRunKey(cwd, runId), async () => {
-            const existingRun = await this.getRun(cwd, runId);
-            if (!existingRun) {
-                throw new Error(`Run ${runId} does not exist.`);
-            }
-            const updatedRun = update(existingRun);
-            const runPath = this.getRunPath(cwd, runId);
-            await fs.mkdir(path.dirname(runPath), { recursive: true });
-            await writeJsonAtomically(runPath, updatedRun);
-            return updatedRun;
-        });
-    }
-    getRunKey(cwd, runId) {
-        return `${cwd}:${runId}`;
-    }
-    getRunsDirectory(cwd) {
-        return path.join(cwd, this.baseDirectoryName, 'runs');
-    }
-    getRunPath(cwd, runId) {
-        return path.join(this.getRunsDirectory(cwd), `${runId}.json`);
-    }
-    async enqueueWrite(key, operation) {
-        const previousOperation = this.writeQueues.get(key) ?? Promise.resolve();
-        const resultPromise = previousOperation.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/state/team-state-store.d.ts

@@ -1,14 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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 results = await Promise.allSettled(entries
-                .filter((entry) => entry.endsWith('.json'))
-                .map(async (entry) => {
-                const content = await fs.readFile(path.join(directory, entry), 'utf8');
-                return JSON.parse(content);
-            }));
-            const teams = results
-                .filter((r) => r.status === 'fulfilled')
-                .map((r) => r.value);
-            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/state/transcript-store.d.ts

@@ -1,15 +0,0 @@
-import type { ClaudeSessionEvent } from '../types/contracts.js';
-export declare class TranscriptStore {
-    private readonly baseDirectoryName;
-    constructor(baseDirectoryName?: string);
-    /**
-     * Append new events to the transcript file for the given session.
-     * Creates the file if it does not exist. Strips trailing partials before persisting.
-     */
-    appendEvents(cwd: string, sessionId: string, newEvents: ClaudeSessionEvent[]): Promise<void>;
-    /**
-     * Read all persisted transcript events for a session.
-     */
-    readEvents(cwd: string, sessionId: string): Promise<ClaudeSessionEvent[]>;
-    private getTranscriptPath;
-}

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

@@ -1,44 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { appendTranscriptEvents, stripTrailingPartials } from '../util/transcript-append.js';
-import { isFileNotFoundError, writeJsonAtomically } from '../util/fs-helpers.js';
-export class TranscriptStore {
-    baseDirectoryName;
-    constructor(baseDirectoryName = '.claude-manager') {
-        this.baseDirectoryName = baseDirectoryName;
-    }
-    /**
-     * Append new events to the transcript file for the given session.
-     * Creates the file if it does not exist. Strips trailing partials before persisting.
-     */
-    async appendEvents(cwd, sessionId, newEvents) {
-        if (newEvents.length === 0) {
-            return;
-        }
-        const filePath = this.getTranscriptPath(cwd, sessionId);
-        const existing = await this.readEvents(cwd, sessionId);
-        const merged = appendTranscriptEvents(existing, newEvents);
-        const cleaned = stripTrailingPartials(merged);
-        await fs.mkdir(path.dirname(filePath), { recursive: true });
-        await writeJsonAtomically(filePath, cleaned);
-    }
-    /**
-     * Read all persisted transcript events for a session.
-     */
-    async readEvents(cwd, sessionId) {
-        const filePath = this.getTranscriptPath(cwd, sessionId);
-        try {
-            const content = await fs.readFile(filePath, 'utf8');
-            return JSON.parse(content);
-        }
-        catch (error) {
-            if (isFileNotFoundError(error)) {
-                return [];
-            }
-            throw error;
-        }
-    }
-    getTranscriptPath(cwd, sessionId) {
-        return path.join(cwd, this.baseDirectoryName, 'transcripts', `${sessionId}.json`);
-    }
-}

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

@@ -1,5 +0,0 @@
-import { PLANNER_ELIGIBLE_ENGINEERS, type EngineerName, type TeamEngineerRecord, type TeamRecord } from '../types/contracts.js';
-export { PLANNER_ELIGIBLE_ENGINEERS };
-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;