create-claude-workspace 1.1.151 → 2.0.0

package/dist/scheduler/agents/orchestrator.spec.js

@@ -0,0 +1,87 @@
+import { describe, it, expect } from 'vitest';
+import { extractJson, parseRoutingDecision, parseFailureDecision, parseMergeConflictDecision, } from './orchestrator.mjs';
+// ─── extractJson ───
+describe('extractJson', () => {
+    it('extracts JSON from code block', () => {
+        const output = 'Some text\n```json\n{"agent": "backend"}\n```\nMore text';
+        expect(extractJson(output)).toBe('{"agent": "backend"}');
+    });
+    it('extracts JSON from code block without language tag', () => {
+        const output = '```\n{"action": "retry"}\n```';
+        expect(extractJson(output)).toBe('{"action": "retry"}');
+    });
+    it('extracts raw JSON object', () => {
+        const output = 'I think {"agent": "ui-engineer", "reason": "frontend task"} is the best choice.';
+        expect(extractJson(output)).toBe('{"agent": "ui-engineer", "reason": "frontend task"}');
+    });
+    it('returns null for no JSON', () => {
+        expect(extractJson('Just plain text with no JSON')).toBeNull();
+    });
+});
+// ─── parseRoutingDecision ───
+describe('parseRoutingDecision', () => {
+    it('parses valid routing decision', () => {
+        const output = '```json\n{"agent": "backend-ts-architect", "reason": "Backend task"}\n```';
+        const decision = parseRoutingDecision(output);
+        expect(decision.agent).toBe('backend-ts-architect');
+        expect(decision.reason).toBe('Backend task');
+    });
+    it('parses create decision', () => {
+        const output = '```json\n{"agent": null, "reason": "No DB specialist", "create": {"name": "db-specialist", "description": "DB expert", "model": "opus", "steps": ["plan"], "prompt": "You are a DB expert"}}\n```';
+        const decision = parseRoutingDecision(output);
+        expect(decision.agent).toBeNull();
+        expect(decision.create).toBeDefined();
+        expect(decision.create.name).toBe('db-specialist');
+    });
+    it('returns fallback for unparseable output', () => {
+        const decision = parseRoutingDecision('random text');
+        expect(decision.agent).toBeNull();
+        expect(decision.reason).toContain('Failed to parse');
+    });
+    it('returns fallback for invalid JSON', () => {
+        const decision = parseRoutingDecision('```json\n{broken json\n```');
+        expect(decision.agent).toBeNull();
+        expect(decision.reason).toContain('Invalid JSON');
+    });
+});
+// ─── parseFailureDecision ───
+describe('parseFailureDecision', () => {
+    it('parses retry decision', () => {
+        const output = '```json\n{"action": "retry", "reason": "Transient error", "guidance": "Try with a different approach"}\n```';
+        const decision = parseFailureDecision(output);
+        expect(decision.action).toBe('retry');
+        expect(decision.reason).toBe('Transient error');
+        expect(decision.guidance).toBe('Try with a different approach');
+    });
+    it('parses skip decision', () => {
+        const output = '{"action": "skip", "reason": "Dependency not available"}';
+        const decision = parseFailureDecision(output);
+        expect(decision.action).toBe('skip');
+    });
+    it('parses escalate decision', () => {
+        const output = '```json\n{"action": "escalate", "reason": "Needs human review"}\n```';
+        const decision = parseFailureDecision(output);
+        expect(decision.action).toBe('escalate');
+    });
+    it('defaults to skip on parse failure', () => {
+        const decision = parseFailureDecision('no json here');
+        expect(decision.action).toBe('skip');
+    });
+});
+// ─── parseMergeConflictDecision ───
+describe('parseMergeConflictDecision', () => {
+    it('parses rebase decision', () => {
+        const output = '```json\n{"action": "rebase", "reason": "Simple conflict, rebase will work"}\n```';
+        const decision = parseMergeConflictDecision(output);
+        expect(decision.action).toBe('rebase');
+    });
+    it('parses resolve decision', () => {
+        const output = '{"action": "resolve", "reason": "Complex conflict in shared code"}';
+        const decision = parseMergeConflictDecision(output);
+        expect(decision.action).toBe('resolve');
+    });
+    it('defaults to skip on parse failure', () => {
+        const decision = parseMergeConflictDecision('unparseable');
+        expect(decision.action).toBe('skip');
+    });
+});

package/dist/scheduler/agents/prompt-builder.mjs

@@ -0,0 +1,204 @@
+// ─── Minimal prompt construction for each pipeline step ───
+// No workflow instructions. Just task + context + expected output format.
+// ─── Planning prompts ───
+export function buildPlanPrompt(ctx) {
+    const lines = [
+        `Plan the implementation for the following task.`,
+        ``,
+        `## Task`,
+        `**${ctx.task.title}** (${ctx.task.type}, Complexity: ${ctx.task.complexity})`,
+        ``,
+        `## Working Directory`,
+        ctx.worktreePath,
+        ``,
+        `## Project Root`,
+        ctx.projectDir,
+    ];
+    if (ctx.apiContract) {
+        lines.push(``, `## API Contract (from backend architect)`, ctx.apiContract);
+    }
+    if (ctx.profileContent) {
+        lines.push(``, `## Frontend Profile`, ctx.profileContent);
+    }
+    lines.push(``, `## Instructions`, `Read the codebase at the working directory. Produce a structured plan.`, ``, `## Required Output Format`, ``, `### EXISTING CODE`, `List relevant existing files, functions, and patterns that can be reused.`, ``, `### SCOPE`, `What needs to change — be specific about additions vs modifications.`, ``, `### FILES`, `List every file to create or modify, with the intended change.`, ``, `### IMPLEMENTATION ORDER`, `Numbered sequence of steps.`, ``, `### INTERFACES`, `TypeScript interfaces/types to define or modify.`, ``, `### REUSE OPPORTUNITIES`, `Existing code that can be leveraged to avoid duplication.`, ``, `### PATTERNS`, `Architectural patterns to follow (from existing codebase).`, ``, `### PITFALLS`, `Known risks or edge cases.`, ``, `### TESTING`, `What to test, what to skip, and why. This section will be forwarded to the test engineer.`, ``, `### SPLIT RECOMMENDATION`, `If this task is too large for a single implementation pass, recommend how to split it. Otherwise write "No split needed."`);
+    return lines.join('\n');
+}
+// ─── Implementation prompt ───
+export function buildImplementPrompt(ctx) {
+    const lines = [
+        `Implement the following task according to the architect's plan.`,
+        ``,
+        `## Task`,
+        `**${ctx.task.title}** (${ctx.task.type}, Complexity: ${ctx.task.complexity})`,
+        ``,
+        `## Working Directory`,
+        ctx.worktreePath,
+    ];
+    if (ctx.architectPlan) {
+        lines.push(``, `## Architect's Plan`, ctx.architectPlan);
+    }
+    if (ctx.apiContract) {
+        lines.push(``, `## API Contract`, ctx.apiContract);
+    }
+    if (ctx.profileContent) {
+        lines.push(``, `## Frontend Profile`, ctx.profileContent);
+    }
+    lines.push(``, `## Instructions`, `Follow the plan exactly. Write production code. Run build/lint to verify.`, `If build or lint fails, fix the issues before finishing.`);
+    return lines.join('\n');
+}
+// ─── Test prompt ───
+export function buildTestPrompt(ctx) {
+    const lines = [
+        `Write and run tests for the following task.`,
+        ``,
+        `## Task`,
+        `**${ctx.task.title}** (${ctx.task.type})`,
+        ``,
+        `## Working Directory`,
+        ctx.worktreePath,
+    ];
+    if (ctx.changedFiles && ctx.changedFiles.length > 0) {
+        lines.push(``, `## Changed Files`, ...ctx.changedFiles.map(f => `- ${f}`));
+    }
+    if (ctx.testingSection) {
+        lines.push(``, `## Architect's Testing Decisions`, ctx.testingSection);
+    }
+    lines.push(``, `## Instructions`, `- Auto-detect test framework (Vitest or Jest) from project config`, `- Write unit tests for pure logic and business rules`, `- Write integration tests for API endpoints and DB operations (*.integration.spec.ts)`, `- Co-locate test files next to source (foo.spec.ts beside foo.ts)`, `- Run tests with --coverage and ensure 80% threshold`, `- If E2E tests are appropriate for this task, write Playwright tests`);
+    return lines.join('\n');
+}
+// ─── Review prompt ───
+export function buildReviewPrompt(ctx) {
+    const lines = [
+        `Review the code changes for the following task.`,
+        ``,
+        `## Task`,
+        `**${ctx.task.title}** (${ctx.task.type})`,
+        ``,
+        `## Working Directory`,
+        ctx.worktreePath,
+    ];
+    if (ctx.changedFiles && ctx.changedFiles.length > 0) {
+        lines.push(``, `## Changed Files`, ...ctx.changedFiles.map(f => `- ${f}`));
+    }
+    if (ctx.testingSection) {
+        lines.push(``, `## Architect's Testing Decisions`, ctx.testingSection);
+    }
+    lines.push(``, `## Instructions`, `Review all changed files. Use this structured output format:`, ``, `### CRITICAL`, `Bugs, security issues, data loss risks. Must be fixed before merge.`, ``, `### WARN`, `Code quality issues, potential problems. Should be fixed.`, ``, `### NICE-TO-HAVE`, `Improvements that would be good but are not blocking.`, ``, `### GREEN`, `What was done well.`, ``, `End with a verdict: **PASS** (no CRITICAL/WARN) or **FAIL** (has CRITICAL/WARN items).`);
+    return lines.join('\n');
+}
+// ─── Rework prompt ───
+export function buildReworkPrompt(ctx) {
+    const lines = [
+        `Fix the review findings for the following task.`,
+        ``,
+        `## Task`,
+        `**${ctx.task.title}**`,
+        ``,
+        `## Working Directory`,
+        ctx.worktreePath,
+    ];
+    if (ctx.reviewFindings) {
+        lines.push(``, `## Review Findings`, ctx.reviewFindings);
+    }
+    lines.push(``, `## Instructions`, `Fix all CRITICAL and WARN items. Only change what is flagged.`, `Run build/lint/tests after changes to verify nothing broke.`);
+    return lines.join('\n');
+}
+// ─── Decomposition prompt (for L-tasks) ───
+export function buildDecomposePrompt(task) {
+    return [
+        `This task is Complexity: L and should be split into smaller tasks.`,
+        ``,
+        `## Task`,
+        `**${task.title}** (${task.type}, Phase ${task.phase})`,
+        ``,
+        `## Instructions`,
+        `Split this task into 2-4 smaller tasks (Complexity S or M).`,
+        `Each sub-task must be independently implementable and testable.`,
+        ``,
+        `## Required Output Format`,
+        `Return a JSON array:`,
+        '```json',
+        `[`,
+        `  { "title": "Sub-task title", "type": "${task.type}", "complexity": "S", "dependsOn": [] },`,
+        `  { "title": "Next sub-task", "type": "${task.type}", "complexity": "M", "dependsOn": ["Sub-task title"] }`,
+        `]`,
+        '```',
+    ].join('\n');
+}
+// ─── Routing prompt (orchestrator decides which agent handles a task) ───
+export function buildRoutingPrompt(task, step, agents) {
+    const agentList = agents
+        .map(a => `- **${a.name}**: ${a.description} (steps: ${a.steps.join(', ')})`)
+        .join('\n');
+    return [
+        `Select the best agent for this task and step.`,
+        ``,
+        `## Task`,
+        `**${task.title}** (${task.type}, Complexity: ${task.complexity})`,
+        ``,
+        `## Pipeline Step`,
+        step,
+        ``,
+        `## Available Agents`,
+        agentList,
+        ``,
+        `## Instructions`,
+        `Choose the most qualified agent. If no agent fits, respond with agent: null and provide a new agent definition.`,
+        ``,
+        `## Required Output Format`,
+        `Respond with JSON only:`,
+        '```json',
+        `{ "agent": "agent-name", "reason": "why this agent" }`,
+        '```',
+        `Or if a new agent is needed:`,
+        '```json',
+        `{ "agent": null, "reason": "why no existing agent fits", "create": { "name": "new-agent", "description": "...", "model": "opus", "steps": ["plan", "implement"], "prompt": "You are a..." } }`,
+        '```',
+    ].join('\n');
+}
+// ─── CI fix prompt ───
+export function buildCIFixPrompt(ctx, ciLogs) {
+    return [
+        `The CI pipeline failed. Diagnose and fix the issue.`,
+        ``,
+        `## Task`,
+        `**${ctx.task.title}**`,
+        ``,
+        `## Working Directory`,
+        ctx.worktreePath,
+        ``,
+        `## CI Failure Logs`,
+        '```',
+        ciLogs,
+        '```',
+        ``,
+        `## Instructions`,
+        `- Analyze the logs to find the root cause`,
+        `- Fix the issue in the code`,
+        `- Run build/lint/tests locally to verify the fix`,
+    ].join('\n');
+}
+// ─── Phase transition prompt (for product-owner re-evaluation) ───
+export function buildPhaseTransitionPrompt(completedPhase, nextPhase) {
+    return [
+        `Phase ${completedPhase} is complete. Evaluate whether to proceed to Phase ${nextPhase}.`,
+        ``,
+        `## Instructions`,
+        `Review PRODUCT.md and the completed tasks. Respond with a structured evaluation:`,
+        ``,
+        `### CONFIRM`,
+        `Tasks in Phase ${nextPhase} that should proceed as planned.`,
+        ``,
+        `### REPRIORITIZE`,
+        `Tasks that should change priority order.`,
+        ``,
+        `### ADD`,
+        `New tasks discovered during Phase ${completedPhase} that should be added.`,
+        ``,
+        `### REMOVE`,
+        `Tasks that are no longer needed.`,
+        ``,
+        `### VERDICT`,
+        `PROCEED (continue to Phase ${nextPhase}) or REVISE (update TODO.md first).`,
+    ].join('\n');
+}

package/dist/scheduler/agents/prompt-builder.spec.js

@@ -0,0 +1,240 @@
+import { describe, it, expect } from 'vitest';
+import { buildPlanPrompt, buildImplementPrompt, buildTestPrompt, buildReviewPrompt, buildReworkPrompt, buildDecomposePrompt, buildRoutingPrompt, buildCIFixPrompt, buildPhaseTransitionPrompt, } from './prompt-builder.mjs';
+// ─── Fixtures ───
+const backendTask = {
+    id: 'p1-1',
+    title: 'Create auth API endpoint',
+    phase: 1,
+    type: 'backend',
+    complexity: 'M',
+    status: 'todo',
+    dependsOn: [],
+    issueMarker: '#5',
+    kitUpgrade: false,
+    lineNumber: 10,
+    changelog: 'added',
+};
+const frontendTask = {
+    id: 'p1-2',
+    title: 'User registration form',
+    phase: 1,
+    type: 'frontend',
+    complexity: 'S',
+    status: 'todo',
+    dependsOn: ['p1-1'],
+    issueMarker: null,
+    kitUpgrade: false,
+    lineNumber: 20,
+    changelog: 'added',
+};
+const largeTask = {
+    id: 'p2-1',
+    title: 'Full dashboard with analytics',
+    phase: 2,
+    type: 'fullstack',
+    complexity: 'L',
+    status: 'todo',
+    dependsOn: [],
+    issueMarker: null,
+    kitUpgrade: false,
+    lineNumber: 30,
+    changelog: 'added',
+};
+const baseCtx = {
+    task: backendTask,
+    worktreePath: '/project/.worktrees/feat/5-auth',
+    projectDir: '/project',
+};
+const agents = [
+    { name: 'backend-ts-architect', description: 'Backend specialist', model: 'opus', steps: ['plan', 'implement', 'rework'], prompt: '' },
+    { name: 'ui-engineer', description: 'Frontend specialist', model: 'opus', steps: ['plan', 'implement', 'rework'], prompt: '' },
+    { name: 'test-engineer', description: 'Test specialist', model: 'sonnet', steps: ['test'], prompt: '' },
+];
+// ─── Plan prompt ───
+describe('buildPlanPrompt', () => {
+    it('includes task title and metadata', () => {
+        const prompt = buildPlanPrompt(baseCtx);
+        expect(prompt).toContain('Create auth API endpoint');
+        expect(prompt).toContain('backend');
+        expect(prompt).toContain('Complexity: M');
+    });
+    it('includes working directory', () => {
+        const prompt = buildPlanPrompt(baseCtx);
+        expect(prompt).toContain('/project/.worktrees/feat/5-auth');
+    });
+    it('includes required output sections', () => {
+        const prompt = buildPlanPrompt(baseCtx);
+        expect(prompt).toContain('### EXISTING CODE');
+        expect(prompt).toContain('### SCOPE');
+        expect(prompt).toContain('### FILES');
+        expect(prompt).toContain('### IMPLEMENTATION ORDER');
+        expect(prompt).toContain('### TESTING');
+        expect(prompt).toContain('### SPLIT RECOMMENDATION');
+    });
+    it('includes API contract when provided', () => {
+        const ctx = { ...baseCtx, apiContract: 'POST /users → 201' };
+        const prompt = buildPlanPrompt(ctx);
+        expect(prompt).toContain('API Contract');
+        expect(prompt).toContain('POST /users → 201');
+    });
+    it('includes frontend profile when provided', () => {
+        const ctx = { ...baseCtx, task: frontendTask, profileContent: 'Use React hooks' };
+        const prompt = buildPlanPrompt(ctx);
+        expect(prompt).toContain('Frontend Profile');
+        expect(prompt).toContain('Use React hooks');
+    });
+    it('omits API contract section when not provided', () => {
+        const prompt = buildPlanPrompt(baseCtx);
+        expect(prompt).not.toContain('API Contract');
+    });
+    it('does not contain workflow instructions', () => {
+        const prompt = buildPlanPrompt(baseCtx);
+        expect(prompt).not.toContain('STEP 1');
+        expect(prompt).not.toContain('STEP 2');
+        // "worktree" appears in path which is fine, but not as workflow instruction
+        expect(prompt).not.toContain('create worktree');
+        expect(prompt.toLowerCase()).not.toContain('commit');
+        expect(prompt.toLowerCase()).not.toContain('merge');
+    });
+});
+// ─── Implement prompt ───
+describe('buildImplementPrompt', () => {
+    it('includes task and plan', () => {
+        const ctx = { ...baseCtx, architectPlan: 'Create users.ts with POST handler' };
+        const prompt = buildImplementPrompt(ctx);
+        expect(prompt).toContain('Create auth API endpoint');
+        expect(prompt).toContain("Architect's Plan");
+        expect(prompt).toContain('Create users.ts with POST handler');
+    });
+    it('instructs to run build/lint', () => {
+        const prompt = buildImplementPrompt(baseCtx);
+        expect(prompt).toContain('build/lint');
+    });
+    it('does not contain workflow instructions', () => {
+        const prompt = buildImplementPrompt(baseCtx);
+        expect(prompt).not.toContain('STEP');
+        expect(prompt.toLowerCase()).not.toContain('commit');
+    });
+});
+// ─── Test prompt ───
+describe('buildTestPrompt', () => {
+    it('includes changed files', () => {
+        const ctx = { ...baseCtx, changedFiles: ['src/routes/users.ts', 'src/models/user.ts'] };
+        const prompt = buildTestPrompt(ctx);
+        expect(prompt).toContain('src/routes/users.ts');
+        expect(prompt).toContain('src/models/user.ts');
+    });
+    it('includes testing section from architect', () => {
+        const ctx = { ...baseCtx, testingSection: 'Skip E2E, focus on unit tests' };
+        const prompt = buildTestPrompt(ctx);
+        expect(prompt).toContain("Architect's Testing Decisions");
+        expect(prompt).toContain('Skip E2E, focus on unit tests');
+    });
+    it('mentions coverage threshold', () => {
+        const prompt = buildTestPrompt(baseCtx);
+        expect(prompt).toContain('80%');
+    });
+    it('mentions co-located test files', () => {
+        const prompt = buildTestPrompt(baseCtx);
+        expect(prompt).toContain('Co-locate');
+    });
+});
+// ─── Review prompt ───
+describe('buildReviewPrompt', () => {
+    it('includes structured output sections', () => {
+        const prompt = buildReviewPrompt(baseCtx);
+        expect(prompt).toContain('### CRITICAL');
+        expect(prompt).toContain('### WARN');
+        expect(prompt).toContain('### NICE-TO-HAVE');
+        expect(prompt).toContain('### GREEN');
+        expect(prompt).toContain('**PASS**');
+        expect(prompt).toContain('**FAIL**');
+    });
+    it('includes changed files when provided', () => {
+        const ctx = { ...baseCtx, changedFiles: ['src/foo.ts'] };
+        const prompt = buildReviewPrompt(ctx);
+        expect(prompt).toContain('src/foo.ts');
+    });
+});
+// ─── Rework prompt ───
+describe('buildReworkPrompt', () => {
+    it('includes review findings', () => {
+        const ctx = { ...baseCtx, reviewFindings: 'CRITICAL: SQL injection in query builder' };
+        const prompt = buildReworkPrompt(ctx);
+        expect(prompt).toContain('SQL injection in query builder');
+    });
+    it('instructs to fix only flagged items', () => {
+        const prompt = buildReworkPrompt(baseCtx);
+        expect(prompt).toContain('Only change what is flagged');
+    });
+});
+// ─── Decompose prompt ───
+describe('buildDecomposePrompt', () => {
+    it('references the task details', () => {
+        const prompt = buildDecomposePrompt(largeTask);
+        expect(prompt).toContain('Full dashboard with analytics');
+        expect(prompt).toContain('fullstack');
+        expect(prompt).toContain('Phase 2');
+    });
+    it('requests JSON output', () => {
+        const prompt = buildDecomposePrompt(largeTask);
+        expect(prompt).toContain('JSON array');
+        expect(prompt).toContain('"title"');
+        expect(prompt).toContain('"complexity"');
+    });
+    it('mentions Complexity L', () => {
+        const prompt = buildDecomposePrompt(largeTask);
+        expect(prompt).toContain('Complexity: L');
+    });
+});
+// ─── Routing prompt ───
+describe('buildRoutingPrompt', () => {
+    it('lists all available agents', () => {
+        const prompt = buildRoutingPrompt(backendTask, 'plan', agents);
+        expect(prompt).toContain('backend-ts-architect');
+        expect(prompt).toContain('ui-engineer');
+        expect(prompt).toContain('test-engineer');
+    });
+    it('includes task details', () => {
+        const prompt = buildRoutingPrompt(backendTask, 'plan', agents);
+        expect(prompt).toContain('Create auth API endpoint');
+        expect(prompt).toContain('backend');
+    });
+    it('includes the pipeline step', () => {
+        const prompt = buildRoutingPrompt(backendTask, 'implement', agents);
+        expect(prompt).toContain('implement');
+    });
+    it('requests JSON output with create option', () => {
+        const prompt = buildRoutingPrompt(backendTask, 'plan', agents);
+        expect(prompt).toContain('"agent"');
+        expect(prompt).toContain('"create"');
+    });
+});
+// ─── CI fix prompt ───
+describe('buildCIFixPrompt', () => {
+    it('includes CI logs', () => {
+        const prompt = buildCIFixPrompt(baseCtx, 'Error: test failed at line 42');
+        expect(prompt).toContain('Error: test failed at line 42');
+    });
+    it('instructs to analyze and fix', () => {
+        const prompt = buildCIFixPrompt(baseCtx, 'logs');
+        expect(prompt).toContain('root cause');
+        expect(prompt).toContain('Fix the issue');
+    });
+});
+// ─── Phase transition prompt ───
+describe('buildPhaseTransitionPrompt', () => {
+    it('references completed and next phases', () => {
+        const prompt = buildPhaseTransitionPrompt(1, 2);
+        expect(prompt).toContain('Phase 1');
+        expect(prompt).toContain('Phase 2');
+    });
+    it('includes evaluation sections', () => {
+        const prompt = buildPhaseTransitionPrompt(0, 1);
+        expect(prompt).toContain('### CONFIRM');
+        expect(prompt).toContain('### REPRIORITIZE');
+        expect(prompt).toContain('### ADD');
+        expect(prompt).toContain('### REMOVE');
+        expect(prompt).toContain('### VERDICT');
+    });
+});

package/dist/scheduler/agents/worker-pool.mjs

@@ -0,0 +1,137 @@
+// ─── Manage N concurrent Claude processes via Agent SDK ───
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { emptyWorker } from '../state/state.mjs';
+// Disable SDK built-in agents
+process.env.CLAUDE_AGENT_SDK_DISABLE_BUILTIN_AGENTS = '1';
+export class WorkerPool {
+    workers;
+    queries = new Map();
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+        this.workers = Array.from({ length: opts.concurrency }, (_, i) => emptyWorker(i));
+    }
+    get slots() {
+        return this.workers;
+    }
+    activeCount() {
+        return this.workers.filter(w => w.status === 'running').length;
+    }
+    idleSlot() {
+        return this.workers.find(w => w.status === 'idle') ?? null;
+    }
+    getSlot(id) {
+        return this.workers[id] ?? null;
+    }
+    async spawn(slotId, opts) {
+        const slot = this.workers[slotId];
+        if (!slot)
+            throw new Error(`Invalid worker slot: ${slotId}`);
+        if (slot.status === 'running')
+            throw new Error(`Worker ${slotId} is already running`);
+        const startTime = Date.now();
+        slot.status = 'running';
+        slot.agentType = opts.agent ?? null;
+        slot.startedAt = startTime;
+        const queryOptions = {
+            settingSources: ['project'],
+            maxTurns: this.opts.maxTurns,
+            cwd: opts.cwd,
+        };
+        if (opts.agent)
+            queryOptions.agent = opts.agent;
+        if (opts.model)
+            queryOptions.model = opts.model;
+        if (opts.resume) {
+            queryOptions.resume = opts.resume;
+        }
+        if (this.opts.skipPermissions) {
+            queryOptions.permissionMode = 'bypassPermissions';
+            queryOptions.allowDangerouslySkipPermissions = true;
+        }
+        let output = '';
+        let sessionId = '';
+        let success = true;
+        let error;
+        let cost = 0;
+        try {
+            const q = query({
+                prompt: opts.prompt,
+                options: queryOptions,
+            });
+            this.queries.set(slotId, q);
+            for await (const message of q) {
+                // Track session ID
+                if (message.type === 'system' && message.subtype === 'init') {
+                    sessionId = message.session_id || '';
+                    slot.sessionId = sessionId;
+                }
+                // Collect text output
+                if (message.type === 'assistant') {
+                    const content = message.message?.content;
+                    if (Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type === 'text')
+                                output += block.text;
+                        }
+                    }
+                }
+                // Track result
+                if (message.type === 'result') {
+                    sessionId = message.session_id ?? sessionId;
+                    slot.sessionId = sessionId;
+                    if ('is_error' in message && message.is_error) {
+                        success = false;
+                        error = 'errors' in message ? message.errors?.join('; ') : 'Agent failed';
+                    }
+                    if ('total_cost_usd' in message) {
+                        cost = message.total_cost_usd ?? 0;
+                    }
+                }
+                // Forward to caller
+                opts.onMessage?.(message);
+            }
+        }
+        catch (err) {
+            success = false;
+            error = err.message;
+            this.opts.logger.error(`Worker ${slotId} error: ${error}`);
+        }
+        finally {
+            this.queries.delete(slotId);
+            slot.status = 'idle';
+            slot.taskId = null;
+            slot.pid = null;
+            slot.startedAt = null;
+            slot.agentType = null;
+            slot.step = null;
+        }
+        return {
+            success,
+            sessionId,
+            output,
+            error,
+            duration: Date.now() - startTime,
+            cost,
+        };
+    }
+    async killAll() {
+        for (const [slotId, q] of this.queries) {
+            try {
+                await q.return(undefined);
+            }
+            catch { /* ignore */ }
+            const slot = this.workers[slotId];
+            slot.status = 'idle';
+            slot.taskId = null;
+            slot.pid = null;
+        }
+        this.queries.clear();
+    }
+    reset() {
+        for (let i = 0; i < this.workers.length; i++) {
+            this.workers[i] = emptyWorker(i);
+        }
+        this.queries.clear();
+    }
+}