agent-rev 0.1.0

package/dist/commands/run.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function runCommand(program: Command): void;

package/dist/commands/run.js

@@ -0,0 +1,52 @@
+import * as path from 'path';
+import { loadProjectConfig } from '../utils/config.js';
+import { AgentEngine } from '../core/engine.js';
+import { log } from '../utils/logger.js';
+import { readJson } from '../utils/fs.js';
+export function runCommand(program) {
+    const run = program.command('run')
+        .description('Run the full agent cycle: orchestrator -> implementor -> reviewer')
+        .argument('<task>', 'Task description')
+        .action(async (task) => {
+        const dir = process.cwd();
+        const config = await loadProjectConfig(dir);
+        const engine = new AgentEngine(config, dir);
+        await engine.runFullCycle(task);
+    });
+    run.command('orchestrator')
+        .alias('orch')
+        .description('Run only the orchestrator phase')
+        .argument('<task>', 'Task description')
+        .action(async (task) => {
+        const dir = process.cwd();
+        const config = await loadProjectConfig(dir);
+        const engine = new AgentEngine(config, dir);
+        const result = await engine.runOrchestrator(task);
+        log.ok(`Task ID: ${result.taskId}`);
+    });
+    run.command('implementor')
+        .alias('impl')
+        .description('Run only the implementor phase')
+        .argument('<taskId>', 'Task ID')
+        .action(async (taskId) => {
+        const dir = process.cwd();
+        const config = await loadProjectConfig(dir);
+        const engine = new AgentEngine(config, dir);
+        const taskDir = path.join(dir, '.agent', 'tasks', taskId);
+        const plan = await readJson(path.join(taskDir, 'plan.json'));
+        await engine.runImplementor(taskId, plan);
+    });
+    run.command('reviewer')
+        .alias('rev')
+        .description('Run only the reviewer phase')
+        .argument('<taskId>', 'Task ID')
+        .action(async (taskId) => {
+        const dir = process.cwd();
+        const config = await loadProjectConfig(dir);
+        const engine = new AgentEngine(config, dir);
+        const taskDir = path.join(dir, '.agent', 'tasks', taskId);
+        const plan = await readJson(path.join(taskDir, 'plan.json'));
+        const progress = await readJson(path.join(taskDir, 'progress.json'));
+        await engine.runReviewer(taskId, plan, progress);
+    });
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function setupCommand(program: Command): void;

package/dist/commands/setup.js

@@ -0,0 +1,353 @@
+import * as readline from 'readline';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { CLI_REGISTRY } from '../types.js';
+import { writeJson, ensureDir } from '../utils/fs.js';
+import { loadAuth, saveAuth, loadCliConfig, saveCliConfig } from '../utils/config.js';
+import { log } from '../utils/logger.js';
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.agent-cli');
+const AUTH_FILE = path.join(CONFIG_DIR, 'auth.json');
+function ask(rl, q) {
+    return new Promise((resolve) => rl.question(q, resolve));
+}
+function detectInstalledClis() {
+    const installed = [];
+    for (const [name, info] of Object.entries(CLI_REGISTRY)) {
+        try {
+            const p = execSync(`which ${info.command}`, { encoding: 'utf-8' }).trim();
+            installed.push({ name, info, path: p });
+        }
+        catch { /* not installed */ }
+    }
+    return installed;
+}
+function detectModels(cliName) {
+    try {
+        switch (cliName) {
+            case 'claude': {
+                const help = execSync('claude --help 2>/dev/null', { encoding: 'utf-8' });
+                const models = help.match(/'([^']+)'/g)?.map((m) => m.replace(/'/g, '')).filter(Boolean);
+                if (models?.length)
+                    return [...new Set(models)];
+                return ['opus', 'sonnet', 'haiku'];
+            }
+            case 'qwen':
+                return ['coder-model'];
+            case 'gemini': {
+                const help = execSync('gemini --help 2>/dev/null', { encoding: 'utf-8' });
+                const models = help.match(/'([^']+)'/g)?.map((m) => m.replace(/'/g, '')).filter(Boolean);
+                if (models?.length)
+                    return [...new Set(models)];
+                return ['gemini-2.5-pro', 'gemini-2.5-flash'];
+            }
+            case 'codex': {
+                const help = execSync('codex --help 2>/dev/null', { encoding: 'utf-8' });
+                const models = help.match(/-m\s+(\S+)/g)?.map((m) => m.split(/\s+/)[1]);
+                if (models?.length)
+                    return [...new Set(models)];
+                return ['gpt-4o'];
+            }
+            case 'cn':
+                return ['default (hub)'];
+            case 'opencode': {
+                const out = execSync('opencode models 2>/dev/null', { encoding: 'utf-8' });
+                return out.trim().split('\n').filter(Boolean);
+            }
+            case 'aider':
+                return ['default'];
+            default:
+                return ['default'];
+        }
+    }
+    catch {
+        return ['default'];
+    }
+}
+function buildCmd(cliName, model) {
+    const info = CLI_REGISTRY[cliName];
+    if (!info)
+        return `${cliName} -m ${model}`;
+    if (cliName === 'codex')
+        return `codex exec -m ${model}`;
+    if (cliName === 'cn' && model === 'default (hub)')
+        return 'cn --auto -p';
+    const extra = info.extraFlags ? ` ${info.extraFlags}` : '';
+    const promptFlag = info.promptFlag ? ` ${info.promptFlag}` : '';
+    return `${info.command} ${info.modelFlag} ${model}${extra}${promptFlag}`.trim();
+}
+function numberedSelect(title, options, maxShow = 20) {
+    console.log(chalk.bold(`  ${title}`));
+    console.log(chalk.dim('  ' + '-'.repeat(36)));
+    const show = options.slice(0, maxShow);
+    show.forEach((opt, i) => {
+        console.log(chalk.dim(`    ${i + 1}. ${opt}`));
+    });
+    if (options.length > maxShow) {
+        console.log(chalk.dim(`    ... and ${options.length - maxShow} more (type name for unlisted)`));
+    }
+    return show;
+}
+function resolveChoice(input, options) {
+    const trimmed = input.trim();
+    const num = parseInt(trimmed);
+    if (!isNaN(num) && num >= 1 && num <= options.length) {
+        return options[num - 1];
+    }
+    return trimmed;
+}
+// ─── shared helpers ───────────────────────────────────────────────────────────
+async function configureOneRole(rl, role, installed, cliConfig) {
+    const current = cliConfig.roles[role];
+    console.log(chalk.yellow(`\n  ${role.toUpperCase()}${current ? ` [current: ${current.cli}/${current.model}]` : ''}`));
+    const cliOptions = numberedSelect(`CLI for ${role}:`, installed.map((c) => c.name));
+    const cliChoice = await ask(rl, `  CLI: `);
+    const cliName = resolveChoice(cliChoice, cliOptions);
+    if (!CLI_REGISTRY[cliName]) {
+        console.log(chalk.red(`  Unknown CLI: ${cliName}`));
+        return false;
+    }
+    const models = detectModels(cliName);
+    const modelOptions = numberedSelect(`Models for ${cliName}:`, models);
+    const modelChoice = await ask(rl, `  Model: `);
+    cliConfig.roles[role] = {
+        cli: cliName,
+        model: resolveChoice(modelChoice, modelOptions),
+    };
+    return true;
+}
+async function persistConfig(cliConfig) {
+    await saveCliConfig(cliConfig);
+    const projectDir = process.cwd();
+    const projectName = path.basename(projectDir);
+    const r = cliConfig.roles;
+    const agentConfig = {
+        project: projectName,
+        description: '',
+        stack: 'generic',
+        roles: {
+            orchestrator: { cli: r.orchestrator?.cli || '', model: r.orchestrator?.model || '', cmd: buildCmd(r.orchestrator?.cli || '', r.orchestrator?.model || '') },
+            implementor: { cli: r.implementor?.cli || '', model: r.implementor?.model || '', cmd: buildCmd(r.implementor?.cli || '', r.implementor?.model || '') },
+            reviewer: { cli: r.reviewer?.cli || '', model: r.reviewer?.model || '', cmd: buildCmd(r.reviewer?.cli || '', r.reviewer?.model || '') },
+            ...(r.explorer ? { explorer: { cli: r.explorer.cli, model: r.explorer.model, cmd: buildCmd(r.explorer.cli, r.explorer.model) } } : {}),
+        },
+        deliberation: cliConfig.deliberation?.enabled ? {
+            proposer: { cli: r.proposer?.cli || '', model: r.proposer?.model || '', cmd: buildCmd(r.proposer?.cli || '', r.proposer?.model || '') },
+            critic: { cli: r.critic?.cli || '', model: r.critic?.model || '', cmd: buildCmd(r.critic?.cli || '', r.critic?.model || '') },
+            max_rounds: cliConfig.deliberation.max_rounds,
+            stop_on: 'ACCEPT',
+            output_dir: '.agent/tasks/{ID}/debate/',
+        } : undefined,
+        structure: { approved_dirs: ['.'], forbidden_dirs: ['node_modules', 'dist', '.git'] },
+    };
+    await ensureDir(path.join(projectDir, '.agent'));
+    await writeJson(path.join(projectDir, '.agent', 'config.json'), agentConfig);
+}
+// ─── single-role command factory ──────────────────────────────────────────────
+function addRoleCommand(setup, cmd, role, description) {
+    setup
+        .command(cmd)
+        .description(description)
+        .action(async () => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const installed = detectInstalledClis();
+        if (installed.length === 0) {
+            console.log(chalk.red('  No CLIs detected.'));
+            rl.close();
+            return;
+        }
+        const cliConfig = await loadCliConfig();
+        const ok = await configureOneRole(rl, role, installed, cliConfig);
+        if (ok) {
+            await persistConfig(cliConfig);
+            console.log(chalk.green(`\n  ✓ ${role} updated`));
+        }
+        rl.close();
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+export function setupCommand(program) {
+    const setup = program.command('setup')
+        .description('Full interactive setup — login, configure CLIs, initialize project');
+    setup
+        .command('init')
+        .description('Interactive setup wizard')
+        .action(async () => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        console.log(chalk.bold.cyan('\n  Agent CLI — Setup Wizard\n'));
+        // Step 1: Show installed CLIs
+        const installed = detectInstalledClis();
+        if (installed.length === 0) {
+            console.log(chalk.red('  No CLIs detected. Install at least one.'));
+            rl.close();
+            return;
+        }
+        console.log(chalk.bold('  Detected CLIs:'));
+        for (const c of installed) {
+            log.cliList(c.name, c.path);
+        }
+        // Step 2: Login
+        console.log(chalk.bold('\n  Authentication'));
+        console.log(chalk.dim('  ' + '-'.repeat(36)));
+        const auth = await loadAuth();
+        if (auth.entries.length > 0) {
+            console.log(chalk.green(`  Already logged in: ${auth.entries.map((e) => e.provider).join(', ')}`));
+        }
+        else {
+            const doLogin = await ask(rl, '  Login now? (y/N): ');
+            if (doLogin.toLowerCase() === 'y') {
+                const provider = await ask(rl, '  Provider (opencode/google): ');
+                const method = await ask(rl, '  Method (oauth/apikey): ');
+                if (method === 'apikey') {
+                    const key = await ask(rl, '  API Key: ');
+                    auth.entries.push({ provider: provider.trim(), method: 'apikey', apiKey: key.trim() });
+                }
+                else {
+                    auth.entries.push({ provider: provider.trim(), method: 'oauth' });
+                }
+                auth.activeProvider = provider.trim();
+                await saveAuth(auth);
+                console.log(chalk.green('  ✓ Auth saved'));
+            }
+        }
+        // Step 3: Config multi-CLI
+        console.log(chalk.bold('\n  Multi-CLI Configuration'));
+        console.log(chalk.dim('  ' + '-'.repeat(36)));
+        const cliConfig = await loadCliConfig();
+        const roles = ['orchestrator', 'implementor', 'reviewer'];
+        for (const role of roles) {
+            console.log(chalk.yellow(`\n  ${role.toUpperCase()}`));
+            const cliOptions = numberedSelect(`CLI for ${role}:`, installed.map((c) => c.name));
+            const cliChoice = await ask(rl, `  CLI: `);
+            const cliName = resolveChoice(cliChoice, cliOptions);
+            if (!CLI_REGISTRY[cliName]) {
+                console.log(chalk.red(`  Unknown CLI: ${cliName}`));
+                rl.close();
+                return;
+            }
+            const models = detectModels(cliName);
+            const modelOptions = numberedSelect(`Models for ${cliName}:`, models);
+            const modelChoice = await ask(rl, `  Model: `);
+            const model = resolveChoice(modelChoice, modelOptions);
+            cliConfig.roles[role] = { cli: cliName, model };
+        }
+        // Deliberation
+        const delib = await ask(rl, '\n  Enable deliberation? (y/N): ');
+        if (delib.toLowerCase() === 'y') {
+            cliConfig.deliberation.enabled = true;
+            const rounds = await ask(rl, '  Max rounds [4]: ');
+            cliConfig.deliberation.max_rounds = parseInt(rounds) || 4;
+            console.log(chalk.yellow('\n  PROPOSER'));
+            const pp = await ask(rl, '  CLI: ');
+            const pm = await ask(rl, '  Model: ');
+            cliConfig.roles.proposer = { cli: pp.trim(), model: pm.trim() };
+            console.log(chalk.yellow('\n  CRITIC'));
+            const cp = await ask(rl, '  CLI: ');
+            const cm = await ask(rl, '  Model: ');
+            cliConfig.roles.critic = { cli: cp.trim(), model: cm.trim() };
+        }
+        await saveCliConfig(cliConfig);
+        console.log(chalk.green('\n  ✓ CLI config saved'));
+        // Step 4: Generate .agent/config.json
+        const projectDir = process.cwd();
+        const projectName = path.basename(projectDir);
+        const agentConfig = {
+            project: projectName,
+            description: '',
+            stack: 'generic',
+            roles: {
+                orchestrator: { cli: cliConfig.roles.orchestrator?.cli || '', model: cliConfig.roles.orchestrator?.model || '', cmd: buildCmd(cliConfig.roles.orchestrator?.cli || '', cliConfig.roles.orchestrator?.model || '') },
+                implementor: { cli: cliConfig.roles.implementor?.cli || '', model: cliConfig.roles.implementor?.model || '', cmd: buildCmd(cliConfig.roles.implementor?.cli || '', cliConfig.roles.implementor?.model || '') },
+                reviewer: { cli: cliConfig.roles.reviewer?.cli || '', model: cliConfig.roles.reviewer?.model || '', cmd: buildCmd(cliConfig.roles.reviewer?.cli || '', cliConfig.roles.reviewer?.model || '') },
+            },
+            deliberation: cliConfig.deliberation.enabled ? {
+                proposer: { cli: cliConfig.roles.proposer?.cli || '', model: cliConfig.roles.proposer?.model || '', cmd: buildCmd(cliConfig.roles.proposer?.cli || '', cliConfig.roles.proposer?.model || '') },
+                critic: { cli: cliConfig.roles.critic?.cli || '', model: cliConfig.roles.critic?.model || '', cmd: buildCmd(cliConfig.roles.critic?.cli || '', cliConfig.roles.critic?.model || '') },
+                max_rounds: cliConfig.deliberation.max_rounds,
+                stop_on: 'ACCEPT',
+                output_dir: '.agent/tasks/{ID}/debate/',
+            } : undefined,
+            structure: { approved_dirs: ['.'], forbidden_dirs: ['node_modules', 'dist', '.git'] },
+        };
+        await ensureDir(path.join(projectDir, '.agent'));
+        await writeJson(path.join(projectDir, '.agent', 'config.json'), agentConfig);
+        console.log(chalk.green('  ✓ .agent/config.json generated'));
+        // Generate templates
+        const templates = {
+            '.agent/INDEX.md': `# ${projectName} — Agent Entry Point\n\n> Leé este archivo antes de cualquier accion.\n\n## Proyecto\n\n## Navegacion por rol\n| Si sos... | Lee primero... |\n|-----------|----------------|\n| ORCHESTRATOR | .agent/rules/workflow.md |\n| IMPLEMENTOR | .agent/tasks/{ID}/plan.json |\n| REVIEWER | .agent/rules/workflow.md |\n`,
+            '.agent/rules/workflow.md': '# Agent Workflow Contract\n\n## REGLA #1 — Separacion de roles\nUn rol NUNCA ejecuta acciones de otro rol.\n\n## REGLA #2 — Un CLI NO cambia de rol\n\n## Roles\n- ORCHESTRATOR: planifica, genera plan.json\n- IMPLEMENTOR: ejecuta el plan\n- REVIEWER: valida, genera result.md\n',
+            '.agent/rules/structure.md': '# Estructura\n\n## Aprobados\n.\n\n## Prohibidos\nnode_modules, dist, .git\n',
+            '.agent/rules/patterns.md': '# Patrones\n\n- kebab-case para archivos\n- PascalCase para clases\n- camelCase para variables\n',
+            '.agent/context/architecture.md': '# Arquitectura — NIVEL 0\n\n| Servicio | Stack | Puerto | Detalle |\n|----------|-------|--------|---------|\n| - | - | - | - |\n',
+            '.agent/AGENT.md': '# Sub-Agentes\n\n1. Lee .agent/INDEX.md\n2. Lee .agent/rules/workflow.md\n3. Actua SOLO dentro de tu rol\n',
+        };
+        for (const [fp, content] of Object.entries(templates)) {
+            await fs.mkdir(path.join(projectDir, path.dirname(fp)), { recursive: true });
+            await fs.writeFile(path.join(projectDir, fp), content, 'utf-8');
+        }
+        console.log(chalk.green('  ✓ Templates generated'));
+        rl.close();
+    });
+    setup
+        .command('config-multi')
+        .description('Configure multi-CLI agents (orchestrator, implementor, reviewer)')
+        .action(async () => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        console.log(chalk.bold.cyan('\n  Multi-CLI Configuration\n'));
+        const installed = detectInstalledClis();
+        if (installed.length === 0) {
+            console.log(chalk.red('  No CLIs detected.'));
+            rl.close();
+            return;
+        }
+        console.log(chalk.bold('  Detected CLIs:'));
+        for (const c of installed)
+            log.cliList(c.name, c.path);
+        const cliConfig = await loadCliConfig();
+        const roles = ['orchestrator', 'implementor', 'reviewer'];
+        for (const role of roles) {
+            const current = cliConfig.roles[role];
+            console.log(chalk.yellow(`\n  ${role.toUpperCase()}${current ? ` [current: ${current.cli}/${current.model}]` : ''}`));
+            const cliOptions = numberedSelect(`CLI for ${role}:`, installed.map((c) => c.name));
+            console.log(chalk.dim('  (Enter to keep current)'));
+            const cliChoice = await ask(rl, `  CLI: `);
+            if (cliChoice.trim() === '' && current) {
+                console.log(chalk.dim(`  → keeping ${current.cli}/${current.model}`));
+                continue;
+            }
+            const cliName = resolveChoice(cliChoice, cliOptions);
+            const models = detectModels(cliName);
+            const modelOptions = numberedSelect(`Models for ${cliName}:`, models);
+            const modelChoice = await ask(rl, `  Model: `);
+            cliConfig.roles[role] = { cli: cliName, model: resolveChoice(modelChoice, modelOptions) };
+        }
+        await persistConfig(cliConfig);
+        console.log(chalk.green('\n  ✓ Config updated'));
+        rl.close();
+    });
+    setup
+        .command('status')
+        .description('Show current configuration')
+        .action(async () => {
+        const cliConfig = await loadCliConfig();
+        const auth = await loadAuth();
+        console.log(chalk.bold.cyan('\n  Agent CLI Status\n'));
+        console.log(chalk.yellow('  Auth:'), auth.entries.map((e) => `${e.provider} (${e.method})`).join(', ') || 'none');
+        console.log(chalk.yellow('  Roles:'));
+        for (const [role, r] of Object.entries(cliConfig.roles)) {
+            console.log(chalk.dim(`    ${role}: ${r.cli}/${r.model}`));
+        }
+        if (cliConfig.deliberation?.enabled) {
+            console.log(chalk.yellow('  Deliberation:'), `enabled (${cliConfig.deliberation.max_rounds} rounds)`);
+        }
+        console.log('');
+    });
+    // ── individual role commands ──────────────────────────────────────────────
+    addRoleCommand(setup, 'orch', 'orchestrator', 'Configure orchestrator role only');
+    addRoleCommand(setup, 'impl', 'implementor', 'Configure implementor role only');
+    addRoleCommand(setup, 'rev', 'reviewer', 'Configure reviewer role only');
+    addRoleCommand(setup, 'explorer', 'explorer', 'Configure explorer role only');
+    addRoleCommand(setup, 'proposer', 'proposer', 'Configure proposer role only (deliberation)');
+    addRoleCommand(setup, 'critic', 'critic', 'Configure critic role only (deliberation)');
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function statusCommand(program: Command): void;

package/dist/commands/status.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+import { loadProjectConfig } from '../utils/config.js';
+import { readJson, listDir } from '../utils/fs.js';
+import * as path from 'path';
+export function statusCommand(program) {
+    program
+        .command('status')
+        .description('Show project status and task list')
+        .action(async () => {
+        const dir = process.cwd();
+        try {
+            const config = await loadProjectConfig(dir);
+            console.log(chalk.bold.cyan(`\n  ${config.project}`));
+            console.log(chalk.dim(`  Stack: ${config.stack}`));
+            console.log(chalk.dim('  ' + '-'.repeat(36)));
+            console.log(chalk.yellow('  Roles:'));
+            for (const [role, r] of Object.entries(config.roles)) {
+                if (r)
+                    console.log(chalk.dim(`    ${role}: ${r.cli}/${r.model}`));
+            }
+            const tasksDir = path.join(dir, '.agent', 'tasks');
+            const tasks = await listDir(tasksDir);
+            if (tasks.length > 0) {
+                console.log(chalk.yellow('\n  Tasks:'));
+                for (const t of tasks.sort().reverse()) {
+                    try {
+                        const progress = await readJson(path.join(tasksDir, t, 'progress.json'));
+                        const s = progress?.status || 'unknown';
+                        const icon = s === 'completed' ? chalk.green('v') : s === 'planned' ? chalk.yellow('o') : chalk.red('x');
+                        console.log(`    ${icon} ${t} - ${s}`);
+                    }
+                    catch {
+                        console.log(`    ? ${t} - unknown`);
+                    }
+                }
+            }
+            else {
+                console.log(chalk.dim('\n  No tasks yet'));
+            }
+            console.log('');
+        }
+        catch {
+            console.log(chalk.red('  No .agent/config.json found. Run: agent-mp setup init'));
+        }
+    });
+}

package/dist/core/engine.d.ts

@@ -0,0 +1,36 @@
+import * as readline from 'readline';
+import { AgentConfig, TaskPlan, TaskProgress } from '../types.js';
+import type { FixedInput } from '../ui/input.js';
+export declare class AgentEngine {
+    private config;
+    private projectDir;
+    private coordinatorCmd;
+    private rl?;
+    private fi?;
+    private totalTokens;
+    private phaseTokens;
+    constructor(config: AgentConfig, projectDir: string, coordinatorCmd?: string, rl?: readline.Interface, fi?: FixedInput);
+    /**
+     * FASE 0 — Clarificacion con el programador.
+     * El coordinador (CLI activo, ej: Qwen) conversa con el usuario
+     * hasta tener toda la info necesaria. Retorna la tarea refinada.
+     */
+    runClarification(initialTask: string): Promise<string>;
+    private runWithFallback;
+    private buildRolePrompt;
+    generateTaskId(task: string): Promise<string>;
+    /** Context for the ORCHESTRATOR only — planning-relevant files */
+    private buildOrchestratorContext;
+    /** Minimal context for COORDINATOR clarification only */
+    private buildCoordinatorContext;
+    runOrchestrator(task: string): Promise<{
+        taskId: string;
+        plan: TaskPlan;
+    }>;
+    runDeliberation(taskId: string, plan: TaskPlan): Promise<void>;
+    runImplementor(taskId: string, plan: TaskPlan): Promise<TaskProgress>;
+    runReviewer(taskId: string, plan: TaskPlan, progress: TaskProgress): Promise<{
+        verdict: string;
+    }>;
+    runFullCycle(task: string): Promise<void>;
+}