create-claude-workspace 1.1.152 → 2.1.0

package/README.md

@@ -29,10 +29,42 @@ Answer the discovery questions (non-technical). Claude generates the full pipeli
 
 Pick one:
 
-- **Unattended** (recommended): `npx create-claude-workspace run` — clean context per task, survives rate limits
+- **Multi-agent scheduler (v2)**: `npx create-claude-workspace scheduler` — parallel agents, short contexts, TS-driven workflow
+- **Multi-agent parallel**: `npx create-claude-workspace scheduler --concurrency 3` — up to N agents working simultaneously
+- **Classic loop (v1)**: `npx create-claude-workspace run` — single orchestrator, sequential tasks
 - **Docker** (fully isolated): `npx create-claude-workspace docker` — container sandbox, safe `--skip-permissions`
 - **Interactive**: `claude --agent orchestrator`, then `/ralph-loop:ralph-loop Continue autonomous development according to CLAUDE.md`
 
+### Scheduler v2 (Multi-Agent)
+
+The scheduler replaces the single-orchestrator model with parallel agent execution:
+
+- **TS scheduler** handles workflow (task picking, git, CI, merges) — zero AI tokens on routing
+- **Claude agents** get short, focused prompts (~500 tokens vs ~20k+ in v1)
+- **Each task = fresh context** — no accumulating context across tasks
+- **N agents in parallel** — independent tasks run concurrently in separate git worktrees
+
+```bash
+npx create-claude-workspace scheduler                    # start (1 agent)
+npx create-claude-workspace scheduler --concurrency 3    # 3 parallel agents
+npx create-claude-workspace scheduler --resume           # resume from saved state
+npx create-claude-workspace scheduler --help             # all options
+```
+
+#### Communicate at runtime
+
+Write to `.claude/scheduler/inbox.json` while the scheduler is running:
+
+```json
+[
+  { "type": "add-task", "title": "Add dark mode toggle", "taskType": "frontend", "complexity": "S" },
+  { "type": "message", "text": "Focus on performance optimization" },
+  { "type": "stop" }
+]
+```
+
+The scheduler reads the inbox every iteration and processes messages immediately.
+
 ### npx Options
 
 ```bash

package/dist/index.js

@@ -25,7 +25,6 @@ function parseArgs() {
         targetDir: process.cwd(),
         update: false,
         run: false,
-        docker: false,
         help: false,
     };
     for (let i = 0; i < args.length; i++) {
@@ -40,9 +39,6 @@ function parseArgs() {
             case '--run':
                 opts.run = true;
                 break;
-            case '--docker':
-                opts.docker = true;
-                break;
             default:
                 if (!args[i].startsWith('-')) {
                     opts.targetDir = resolve(args[i]);
@@ -57,44 +53,39 @@ function parseArgs() {
 }
 function printHelp() {
     console.log(`
-${C.b}create-claude-workspace${C.n} — Scaffold autonomous AI-driven development with Claude Code
+${C.b}create-claude-workspace${C.n} — Autonomous AI-driven development with Claude Code
 
 ${C.b}Usage:${C.n}
   npx create-claude-workspace [directory] [options]     # scaffold
-  npx create-claude-workspace run [options]             # autonomous loop
-  npx create-claude-workspace docker [options]          # Docker runner
+  npx create-claude-workspace run [options]             # multi-agent scheduler
   npx create-claude-workspace validate                  # check prerequisites
 
 ${C.b}Scaffold options:${C.n}
   directory          Target directory (default: current directory)
   --update           Overwrite existing agent files with latest version
-  --run              Start autonomous development after scaffolding
-  --docker           Use Docker for autonomous run (implies --run)
+  --run              Start scheduler after scaffolding
   -h, --help         Show this help
 
-${C.b}Run options:${C.n}
+${C.b}Scheduler options:${C.n}
+  --concurrency <n>            Parallel agents (default: 1)
   --max-iterations <n>         Max iterations (default: 50)
-  --max-turns <n>              Max turns per invocation (default: 50)
-  --process-timeout <ms>       Max time per invocation (default: 1800000)
-  --activity-timeout <ms>      Max silence before kill (default: 300000)
-  --notify-command <cmd>       Shell command on critical events
-  --resume                     Resume from checkpoint
+  --max-turns <n>              Max turns per agent invocation (default: 50)
+  --resume                     Resume from saved state
   --dry-run                    Validate prerequisites only
   See 'npx create-claude-workspace run --help' for all options.
 
 ${C.b}Examples:${C.n}
-  npx create-claude-workspace                    # scaffold in current directory
-  npx create-claude-workspace run                # start autonomous loop
-  npx create-claude-workspace run --resume       # resume from checkpoint
-  npx create-claude-workspace docker             # run in Docker
-  npx create-claude-workspace validate           # check prerequisites
+  npx create-claude-workspace                          # scaffold in current directory
+  npx create-claude-workspace run                      # start scheduler
+  npx create-claude-workspace run --concurrency 3      # 3 parallel agents
+  npx create-claude-workspace run --resume             # resume from state
+  npx create-claude-workspace validate                 # check prerequisites
 
 ${C.b}What it creates:${C.n}
-  .claude/agents/        10 specialist agents (orchestrator, architects, etc.)
+  .claude/agents/        Specialist agents (orchestrator, architects, etc.)
   .claude/templates/     CLAUDE.md template for project initialization
   .claude/profiles/      Frontend framework profiles (Angular, React, Vue, Svelte)
   .claude/CLAUDE.md      Agent routing instructions
-  .claude/docker/        Docker config (Dockerfile, compose, entrypoint)
   .claude/.kit-version   Kit version (for upgrade detection)
 `);
 }
@@ -144,7 +135,7 @@ function writeKitVersion(targetDir) {
 }
 function ensureGitignore(targetDir) {
     const gitignorePath = join(targetDir, '.gitignore');
-    const entries = ['.npmrc', '.docker-compose.auth.yml', '.claude/autonomous.log', '.claude/autonomous.log.1', '.claude/autonomous.lock', '.claude/autonomous-state.json', '.claude/.kit-version', '.worktrees/'];
+    const entries = ['.claude/scheduler/', '.claude/.kit-version', '.worktrees/'];
     if (existsSync(gitignorePath)) {
         let content = readFileSync(gitignorePath, 'utf-8');
         const added = [];
@@ -163,21 +154,11 @@ function ensureGitignore(targetDir) {
     }
 }
 // ─── Run ───
-function runAutonomous(targetDir, docker, extraArgs = []) {
-    // Run scripts from the package itself, not from .claude/scripts/ in target dir
-    const scriptsDir = resolve(__dirname, 'scripts');
-    const script = docker
-        ? resolve(scriptsDir, 'docker-run.mjs')
-        : resolve(scriptsDir, 'autonomous.mjs');
-    const args = docker ? [script, ...extraArgs] : [script, '--skip-permissions', ...extraArgs];
-    if (docker) {
-        info('Starting Docker-based autonomous development...');
-    }
-    else {
-        info('Starting autonomous development...');
-        info('(Use Ctrl+C to stop)');
-    }
-    const child = spawn('node', args, {
+function runScheduler(targetDir, extraArgs = []) {
+    const script = resolve(__dirname, 'scheduler', 'index.mjs');
+    info('Starting multi-agent scheduler...');
+    info('(Use Ctrl+C to stop)');
+    const child = spawn('node', [script, '--project-dir', targetDir, ...extraArgs], {
         cwd: targetDir,
         stdio: 'inherit',
     });
@@ -185,20 +166,15 @@ function runAutonomous(targetDir, docker, extraArgs = []) {
 }
 // ─── Main ───
 async function main() {
-    // Subcommand routing: run, docker, validate, plan
+    // Subcommand routing
     const firstArg = process.argv[2];
-    if (firstArg === 'run') {
-        const extraArgs = process.argv.slice(3);
-        runAutonomous(process.cwd(), false, extraArgs);
-        return;
-    }
-    if (firstArg === 'docker') {
+    if (firstArg === 'run' || firstArg === 'scheduler') {
         const extraArgs = process.argv.slice(3);
-        runAutonomous(process.cwd(), true, extraArgs);
+        runScheduler(process.cwd(), extraArgs);
         return;
     }
     if (firstArg === 'validate') {
-        runAutonomous(process.cwd(), false, ['--dry-run']);
+        runScheduler(process.cwd(), ['--dry-run']);
         return;
     }
     const opts = parseArgs();
@@ -206,8 +182,6 @@ async function main() {
         printHelp();
         process.exit(0);
     }
-    if (opts.docker)
-        opts.run = true;
     console.log(`\n${C.c}  create-claude-workspace${C.n}\n`);
     const targetDir = opts.targetDir;
     const hasExisting = existsSync(join(targetDir, '.claude'));
@@ -220,7 +194,7 @@ async function main() {
         else {
             info('Skipping file copy. Use --update to force.');
             if (opts.run) {
-                runAutonomous(targetDir, opts.docker);
+                runScheduler(targetDir);
                 return;
             }
             process.exit(0);
@@ -256,7 +230,6 @@ async function main() {
         info(`Copied ${copied} files`);
     if (skipped > 0)
         info(`Skipped ${skipped} existing files`);
-    // Write kit version for orchestrator to detect upgrades
     writeKitVersion(targetDir);
     ensureGitignore(targetDir);
     console.log('');
@@ -268,15 +241,15 @@ async function main() {
         console.log(`  ${C.d}# Interactive setup (recommended first time)${C.n}`);
         console.log(`  claude --agent project-initializer`);
         console.log('');
-        console.log(`  ${C.d}# Autonomous development in Docker${C.n}`);
-        console.log(`  npx create-claude-workspace docker`);
-        console.log('');
-        console.log(`  ${C.d}# Autonomous development without Docker${C.n}`);
+        console.log(`  ${C.d}# Multi-agent scheduler${C.n}`);
         console.log(`  npx create-claude-workspace run`);
         console.log('');
+        console.log(`  ${C.d}# With parallel agents${C.n}`);
+        console.log(`  npx create-claude-workspace run --concurrency 3`);
+        console.log('');
     }
     if (opts.run) {
-        runAutonomous(targetDir, opts.docker);
+        runScheduler(targetDir);
     }
 }
 main().catch((err) => {

package/dist/scheduler/agents/health-checker.mjs

@@ -0,0 +1,98 @@
+// ─── Startup validation: auth, files, agents, worktrees, git identity ───
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { listOrphanedWorktrees } from '../git/manager.mjs';
+import { hasGitIdentity } from '../git/manager.mjs';
+// ─── Auth ───
+export function checkAuth() {
+    if (process.env.ANTHROPIC_API_KEY)
+        return true;
+    try {
+        const home = process.env.HOME || process.env.USERPROFILE || '';
+        const creds = resolve(home, '.claude', '.credentials.json');
+        if (existsSync(creds)) {
+            const data = JSON.parse(readFileSync(creds, 'utf-8'));
+            if (data.claudeAiOauth?.accessToken)
+                return true;
+        }
+    }
+    catch { /* ignore */ }
+    return false;
+}
+// ─── Required files ───
+const REQUIRED_FILES = [
+    { path: 'CLAUDE.md', critical: false },
+    { path: 'PRODUCT.md', critical: false },
+    { path: '.claude/scheduler/tasks.json', critical: false },
+];
+export function checkRequiredFiles(projectDir) {
+    return REQUIRED_FILES
+        .filter(f => !existsSync(resolve(projectDir, f.path)))
+        .map(f => ({ path: f.path, critical: f.critical }));
+}
+// ─── Agent scanning ───
+export function scanAgents(projectDir) {
+    const agentsDir = resolve(projectDir, '.claude', 'agents');
+    if (!existsSync(agentsDir))
+        return [];
+    const agents = [];
+    for (const file of readdirSync(agentsDir)) {
+        if (!file.endsWith('.md'))
+            continue;
+        const content = readFileSync(resolve(agentsDir, file), 'utf-8');
+        const agent = parseAgentFile(file, content);
+        if (agent)
+            agents.push(agent);
+    }
+    return agents;
+}
+export function parseAgentFile(filename, content) {
+    const name = filename.replace('.md', '');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch)
+        return null;
+    const fm = fmMatch[1];
+    const description = extractYamlValue(fm, 'description') ?? name;
+    const model = extractYamlValue(fm, 'model') ?? 'sonnet';
+    const stepsRaw = extractYamlValue(fm, 'steps');
+    const steps = stepsRaw
+        ? stepsRaw.split(',').map(s => s.trim()).filter(s => s.length > 0)
+        : inferSteps(name);
+    const prompt = content.slice(fmMatch[0].length).trim();
+    return { name, description, model, steps, prompt };
+}
+function extractYamlValue(yaml, key) {
+    const match = yaml.match(new RegExp(`^${key}:\\s*["']?(.*?)["']?\\s*$`, 'm'));
+    return match ? match[1].trim() : null;
+}
+function inferSteps(name) {
+    if (name.includes('reviewer') || name.includes('review'))
+        return ['review'];
+    if (name.includes('test'))
+        return ['test'];
+    return ['plan', 'implement', 'rework'];
+}
+// ─── Kit version ───
+export function checkKitVersion(projectDir) {
+    const versionFile = resolve(projectDir, '.claude', '.kit-version');
+    if (!existsSync(versionFile))
+        return null;
+    try {
+        const current = readFileSync(versionFile, 'utf-8').trim();
+        return { current, latest: null };
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Full health check ───
+export function runHealthCheck(projectDir, knownWorktrees) {
+    return {
+        auth: checkAuth(),
+        requiredFiles: checkRequiredFiles(projectDir),
+        agents: scanAgents(projectDir).map(a => a.name),
+        orphanedWorktrees: listOrphanedWorktrees(projectDir, knownWorktrees),
+        gitIdentity: hasGitIdentity(projectDir),
+        kitVersion: checkKitVersion(projectDir),
+    };
+}

package/dist/scheduler/agents/health-checker.spec.js

@@ -0,0 +1,143 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execSync } from 'node:child_process';
+import { checkRequiredFiles, scanAgents, parseAgentFile, checkKitVersion, runHealthCheck, } from './health-checker.mjs';
+let testDir;
+beforeEach(() => {
+    testDir = mkdtempSync(join(tmpdir(), 'health-checker-test-'));
+    mkdirSync(resolve(testDir, '.claude/agents'), { recursive: true });
+    mkdirSync(resolve(testDir, '.claude/scheduler'), { recursive: true });
+});
+afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+});
+// ─── checkRequiredFiles ───
+describe('checkRequiredFiles', () => {
+    it('reports all missing files', () => {
+        const missing = checkRequiredFiles(testDir);
+        expect(missing.length).toBeGreaterThan(0);
+        expect(missing.some(f => f.path === 'CLAUDE.md')).toBe(true);
+    });
+    it('does not report existing files', () => {
+        writeFileSync(resolve(testDir, 'CLAUDE.md'), '# Project');
+        writeFileSync(resolve(testDir, 'PRODUCT.md'), '# Product');
+        writeFileSync(resolve(testDir, '.claude/scheduler/tasks.json'), '{}');
+        const missing = checkRequiredFiles(testDir);
+        expect(missing).toEqual([]);
+    });
+});
+// ─── parseAgentFile ───
+describe('parseAgentFile', () => {
+    it('parses agent with full frontmatter', () => {
+        const content = `---
+name: backend-ts-architect
+description: Backend TypeScript specialist
+model: opus
+steps: plan, implement, rework
+---
+
+You are a backend architect...`;
+        const agent = parseAgentFile('backend-ts-architect.md', content);
+        expect(agent).not.toBeNull();
+        expect(agent.name).toBe('backend-ts-architect');
+        expect(agent.description).toBe('Backend TypeScript specialist');
+        expect(agent.model).toBe('opus');
+        expect(agent.steps).toEqual(['plan', 'implement', 'rework']);
+        expect(agent.prompt).toBe('You are a backend architect...');
+    });
+    it('infers steps for reviewer agents', () => {
+        const content = `---
+name: senior-code-reviewer
+description: Code reviewer
+model: opus
+---
+Review code.`;
+        const agent = parseAgentFile('senior-code-reviewer.md', content);
+        expect(agent.steps).toEqual(['review']);
+    });
+    it('infers steps for test agents', () => {
+        const content = `---
+name: test-engineer
+description: Test specialist
+model: sonnet
+---
+Write tests.`;
+        const agent = parseAgentFile('test-engineer.md', content);
+        expect(agent.steps).toEqual(['test']);
+    });
+    it('defaults to plan/implement/rework for unknown agents', () => {
+        const content = `---
+name: custom-agent
+description: Custom specialist
+---
+Do things.`;
+        const agent = parseAgentFile('custom-agent.md', content);
+        expect(agent.steps).toEqual(['plan', 'implement', 'rework']);
+        expect(agent.model).toBe('sonnet');
+    });
+    it('returns null for files without frontmatter', () => {
+        expect(parseAgentFile('no-frontmatter.md', '# Just a heading')).toBeNull();
+    });
+});
+// ─── scanAgents ───
+describe('scanAgents', () => {
+    it('scans all agent files in directory', () => {
+        writeFileSync(resolve(testDir, '.claude/agents/backend.md'), `---
+name: backend
+description: Backend specialist
+model: opus
+---
+Backend agent.`);
+        writeFileSync(resolve(testDir, '.claude/agents/frontend.md'), `---
+name: frontend
+description: Frontend specialist
+model: opus
+---
+Frontend agent.`);
+        writeFileSync(resolve(testDir, '.claude/agents/readme.txt'), 'Not an agent');
+        const agents = scanAgents(testDir);
+        expect(agents).toHaveLength(2);
+        expect(agents.map(a => a.name)).toContain('backend');
+        expect(agents.map(a => a.name)).toContain('frontend');
+    });
+    it('returns empty array when no agents directory', () => {
+        rmSync(resolve(testDir, '.claude/agents'), { recursive: true });
+        expect(scanAgents(testDir)).toEqual([]);
+    });
+});
+// ─── checkKitVersion ───
+describe('checkKitVersion', () => {
+    it('reads kit version from .kit-version file', () => {
+        writeFileSync(resolve(testDir, '.claude/.kit-version'), '1.5.0');
+        const result = checkKitVersion(testDir);
+        expect(result).not.toBeNull();
+        expect(result.current).toBe('1.5.0');
+        expect(result.latest).toBeNull();
+    });
+    it('returns null when no .kit-version file', () => {
+        expect(checkKitVersion(testDir)).toBeNull();
+    });
+});
+// ─── runHealthCheck ───
+describe('runHealthCheck', () => {
+    it('returns complete health check result', () => {
+        // Set up a git repo
+        execSync('git init -b main', { cwd: testDir, stdio: 'pipe' });
+        execSync('git config user.name "Test"', { cwd: testDir, stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', { cwd: testDir, stdio: 'pipe' });
+        writeFileSync(resolve(testDir, 'file.txt'), 'init');
+        execSync('git add . && git commit -m "init"', { cwd: testDir, stdio: 'pipe' });
+        writeFileSync(resolve(testDir, '.claude/agents/test-agent.md'), `---
+name: test-agent
+description: Test agent
+---
+Agent.`);
+        const result = runHealthCheck(testDir, []);
+        expect(result.gitIdentity).toBe(true);
+        expect(result.agents).toContain('test-agent');
+        expect(result.requiredFiles.length).toBeGreaterThan(0);
+        expect(result.orphanedWorktrees).toEqual([]);
+    });
+});

package/dist/scheduler/agents/orchestrator.mjs

@@ -0,0 +1,149 @@
+// ─── Spawn orchestrator AI only for decisions scheduler can't make ───
+// Short, decision-focused prompts. Returns structured JSON decisions.
+import { buildRoutingPrompt } from './prompt-builder.mjs';
+const ORCHESTRATOR_MODEL = 'claude-sonnet-4-6';
+export class OrchestratorClient {
+    pool;
+    projectDir;
+    logger;
+    constructor(opts) {
+        this.pool = opts.pool;
+        this.projectDir = opts.projectDir;
+        this.logger = opts.logger;
+    }
+    /**
+     * Ask orchestrator to route a task to the best agent.
+     */
+    async routeTask(task, step, agents) {
+        const prompt = buildRoutingPrompt(task, step, agents);
+        const result = await this.consult(prompt);
+        return parseRoutingDecision(result.output);
+    }
+    /**
+     * Ask orchestrator what to do after a failure.
+     */
+    async handleFailure(taskTitle, step, error, attempts) {
+        const prompt = [
+            `An agent failed. Decide what to do next.`,
+            ``,
+            `## Context`,
+            `- Task: ${taskTitle}`,
+            `- Pipeline step: ${step}`,
+            `- Error: ${error}`,
+            `- Attempts so far: ${attempts}`,
+            ``,
+            `## Options`,
+            `1. "retry" — try again (maybe with different approach)`,
+            `2. "skip" — skip this task, log as blocked`,
+            `3. "escalate" — needs human intervention`,
+            ``,
+            `## Required Output`,
+            `Respond with JSON only:`,
+            '```json',
+            `{ "action": "retry" | "skip" | "escalate", "reason": "why", "guidance": "optional instructions for retry" }`,
+            '```',
+        ].join('\n');
+        const result = await this.consult(prompt);
+        return parseFailureDecision(result.output);
+    }
+    /**
+     * Ask orchestrator to resolve a merge conflict.
+     */
+    async handleMergeConflict(taskTitle, conflictFiles) {
+        const prompt = [
+            `A merge conflict occurred. Decide the resolution strategy.`,
+            ``,
+            `## Task: ${taskTitle}`,
+            `## Conflicting files`,
+            ...conflictFiles.map(f => `- ${f}`),
+            ``,
+            `## Options`,
+            `1. "rebase" — rebase the feature branch on main`,
+            `2. "resolve" — spawn an agent to resolve conflicts manually`,
+            `3. "skip" — skip this task`,
+            ``,
+            `## Required Output`,
+            `Respond with JSON only:`,
+            '```json',
+            `{ "action": "rebase" | "resolve" | "skip", "reason": "why" }`,
+            '```',
+        ].join('\n');
+        const result = await this.consult(prompt);
+        return parseMergeConflictDecision(result.output);
+    }
+    /**
+     * Low-level: send a prompt to the orchestrator and get raw result.
+     */
+    async consult(prompt) {
+        const slot = this.pool.idleSlot();
+        if (!slot) {
+            throw new Error('No idle worker available for orchestrator consultation');
+        }
+        const spawnOpts = {
+            cwd: this.projectDir,
+            prompt,
+            model: ORCHESTRATOR_MODEL,
+        };
+        this.logger.info('Consulting orchestrator AI...');
+        return this.pool.spawn(slot.id, spawnOpts);
+    }
+}
+// ─── JSON parsing helpers ───
+function extractJson(output) {
+    // Try to find JSON in code blocks
+    const codeBlock = output.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (codeBlock)
+        return codeBlock[1].trim();
+    // Try to find raw JSON object
+    const jsonMatch = output.match(/\{[\s\S]*\}/);
+    return jsonMatch ? jsonMatch[0] : null;
+}
+function parseRoutingDecision(output) {
+    const json = extractJson(output);
+    if (!json)
+        return { agent: null, reason: 'Failed to parse orchestrator response' };
+    try {
+        const parsed = JSON.parse(json);
+        return {
+            agent: parsed.agent ?? null,
+            reason: parsed.reason ?? 'No reason provided',
+            create: parsed.create ?? undefined,
+        };
+    }
+    catch {
+        return { agent: null, reason: 'Invalid JSON from orchestrator' };
+    }
+}
+function parseFailureDecision(output) {
+    const json = extractJson(output);
+    if (!json)
+        return { action: 'skip', reason: 'Failed to parse orchestrator response' };
+    try {
+        const parsed = JSON.parse(json);
+        return {
+            action: parsed.action ?? 'skip',
+            reason: parsed.reason ?? 'No reason provided',
+            guidance: parsed.guidance,
+        };
+    }
+    catch {
+        return { action: 'skip', reason: 'Invalid JSON from orchestrator' };
+    }
+}
+function parseMergeConflictDecision(output) {
+    const json = extractJson(output);
+    if (!json)
+        return { action: 'skip', reason: 'Failed to parse orchestrator response' };
+    try {
+        const parsed = JSON.parse(json);
+        return {
+            action: parsed.action ?? 'skip',
+            reason: parsed.reason ?? 'No reason provided',
+        };
+    }
+    catch {
+        return { action: 'skip', reason: 'Invalid JSON from orchestrator' };
+    }
+}
+// Export for testing
+export { extractJson, parseRoutingDecision, parseFailureDecision, parseMergeConflictDecision };