flanders 0.1.0 → 0.2.0

package/lib/commands/Implement.js

@@ -1,15 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Implement = void 0;
-const ClaudeSession_1 = require("../ClaudeSession");
-const fsUtils_1 = require("../fsUtils");
-const Git_1 = require("../Git");
-const PlanFile_1 = require("../PlanFile");
-const prompts_1 = require("../prompts");
-const ScriptRunner_1 = require("../ScriptRunner");
+const AiSession_1 = require("../ai/AiSession");
+const ClaudeAdapter_1 = require("../ai/ClaudeAdapter");
+const CodexAdapter_1 = require("../ai/CodexAdapter");
+const FlandersConfig_1 = require("../workspace/FlandersConfig");
+const fsUtils_1 = require("../system/fsUtils");
+const Git_1 = require("../system/Git");
+const SpecDiscovery_1 = require("../workspace/SpecDiscovery");
+const PlanFile_1 = require("../plan/PlanFile");
+const prompts_1 = require("../prompts/prompts");
+const ScriptRunner_1 = require("../system/ScriptRunner");
 const BottomBlock_1 = require("../ui/BottomBlock");
 const formatters_1 = require("../ui/formatters");
-const Workspace_1 = require("../Workspace");
+const Workspace_1 = require("../workspace/Workspace");
 const MAX_ITER = 5;
 class LineBufferedBlock {
     constructor(_block) {
@@ -45,18 +49,23 @@ class LineBufferedBlock {
     }
 }
 class Implement {
+    get config() { return this._config; }
     constructor(rawArgs, _options, _contexts) {
         this._options = _options;
         this._contexts = _contexts;
         this._disposed = false;
+        this._config = null;
         this._contractList = [];
         this._ruleList = [];
+        this._behaviorRuleList = [];
         this._workspace = null;
         this._block = null;
         this._currentWorkerSessionId = null;
         this._currentPrepSessionId = null;
         this._activeSession = null;
         this._activeScript = null;
+        this._activeReviewerSessions = new Set();
+        this._reviewerStates = null;
         this._currentIndexLabel = "";
         this._currentIteration = 0;
         this._currentTask = null;
@@ -64,6 +73,7 @@ class Implement {
         this._taskRateLimitMs = 0;
         this._taskRateLimitStartedAt = null;
         this._taskTokens = { it: 0, ot: 0 };
+        this._restingFooterKind = "working";
         this._runPromise = this._run(rawArgs);
         this._runPromise.catch(() => { });
     }
@@ -81,12 +91,8 @@ class Implement {
         this._buffered = new LineBufferedBlock(block);
         try {
             const positional = [];
-            let noGitFlag = false;
             for (const arg of rawArgs) {
-                if (arg === "--no-git") {
-                    noGitFlag = true;
-                }
-                else if (arg.startsWith("-")) {
+                if (arg.startsWith("-")) {
                     this._buffered.writeError(`Unknown flag: ${arg}\n`);
                     this._finalizeBlock("Failed");
                     return 1;
@@ -95,6 +101,16 @@ class Implement {
                     positional.push(arg);
                 }
             }
+            const config = await (0, FlandersConfig_1.read)(this._contexts.fs, {
+                projectRoot: this._options.projectRoot,
+                homeDir: this._contexts.platform.homedir()
+            });
+            if (config === null) {
+                this._buffered.writeError("Missing Flanders configuration. Run 'npx flanders install'.\n");
+                this._finalizeBlock("Failed");
+                return 1;
+            }
+            this._config = config;
             const planPath = await this._selectPlan(positional);
             if (this._disposed) {
                 this._finalizeBlock("Interrupted");
@@ -130,26 +146,25 @@ class Implement {
             }
             this._block.setHeader({ indexLabel: `0/${totalTasks}` });
             this._block.setMetrics({ plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t } });
-            let gitActive = false;
-            if (!noGitFlag) {
-                if (await (0, Git_1.isGitAvailable)(this._contexts.script, this._contexts.time)) {
-                    gitActive = await (0, Git_1.isInsideWorkTree)(this._contexts.script, this._contexts.time, this._options.projectRoot);
-                }
+            const gitAvailable = await (0, Git_1.isGitAvailable)(this._contexts.script, this._contexts.time);
+            const insideWorkTree = gitAvailable && await (0, Git_1.isInsideWorkTree)(this._contexts.script, this._contexts.time, this._options.projectRoot);
+            if (!insideWorkTree) {
+                this._buffered.writeError("The project must be a git repository. Flanders implement requires git on PATH and the project root inside a git work tree.\n");
+                this._finalizeBlock("Failed");
+                return 1;
             }
-            if (gitActive) {
-                const pending = await (0, Git_1.countPendingChangesExcept)(this._contexts.script, this._contexts.time, this._options.projectRoot, planPath);
-                if (pending > 0) {
-                    this._buffered.writeError("Working tree has uncommitted changes. Please commit or stash them before re-running.\n");
-                    this._finalizeBlock("Failed");
-                    return 1;
-                }
+            const pending = await (0, Git_1.countUnstagedChangesExcept)(this._contexts.script, this._contexts.time, this._options.projectRoot, planPath);
+            if (pending > 0) {
+                this._buffered.writeError("Working tree has unstaged changes. Please stage, commit, or stash them before re-running.\n");
+                this._finalizeBlock("Failed");
+                return 1;
             }
-            const contractFiles = await (0, fsUtils_1.listFilesRecursive)(this._contexts.fs, (0, fsUtils_1.joinPath)(this._options.projectRoot, "contracts"));
-            this._contractList = contractFiles.map(f => `contracts/${f}`);
-            const ruleFiles = await (0, fsUtils_1.listFilesRecursive)(this._contexts.fs, (0, fsUtils_1.joinPath)(this._options.projectRoot, "rules"));
-            this._ruleList = ruleFiles.map(f => `rules/${f}`);
+            const specs = await (0, SpecDiscovery_1.discoverSpecs)(this._contexts.script, this._contexts.time, this._options.projectRoot);
+            this._contractList = specs.contracts;
+            this._ruleList = specs.rules;
+            this._behaviorRuleList = specs.flanders;
             this._workspace = new Workspace_1.Workspace(this._contexts.fs, this._contexts.platform);
-            const wsPaths = await this._workspace.setup();
+            const wsPaths = await this._workspace.setup(this._config.reviewers.length);
             await this._detectBuildAndTest(wsPaths);
             if (this._disposed) {
                 this._finalizeBlock("Interrupted");
@@ -167,7 +182,7 @@ class Implement {
                 const refreshed = plan.parse();
                 const completedSoFar = refreshed.tasks.filter(t => t.done).length;
                 const indexLabel = `${completedSoFar + 1}/${totalTasks}`;
-                const taskOk = await this._runTask(plan, open, wsPaths, indexLabel, completedSoFar, gitActive);
+                const taskOk = await this._runTask(plan, open, wsPaths, indexLabel, completedSoFar);
                 if (this._disposed) {
                     this._finalizeBlock("Interrupted");
                     return 1;
@@ -212,51 +227,26 @@ class Implement {
         if (files.length === 1) {
             return (0, fsUtils_1.joinPath)(plansFolder, files[0]);
         }
-        return await this._promptPlanChoice(plansFolder, files);
-    }
-    _askOutput() {
-        return {
-            write: text => this._buffered.write(text),
-            writeError: text => this._buffered.writeError(text),
-            columns: () => this._contexts.output.columns(),
-            rows: () => this._contexts.output.rows(),
-            onResize: listener => this._contexts.output.onResize(listener)
-        };
-    }
-    async _promptPlanChoice(plansFolder, files) {
-        const askOutput = this._askOutput();
-        for (;;) {
-            if (this._disposed) {
-                return null;
-            }
-            const [answer] = await this._contexts.ask.askChoices([{
-                    header: "Plan file",
-                    question: `Multiple plans found in ${plansFolder}. Which one do you want to implement?`,
-                    options: files.map(f => ({ label: f })),
-                    multiSelect: false
-                }], askOutput);
-            if (this._disposed) {
-                return null;
-            }
-            if (answer && answer.picked.length > 0) {
-                return (0, fsUtils_1.joinPath)(plansFolder, answer.picked[0].label);
-            }
-            this._buffered.writeError("Please pick one of the listed plans by its number.\n");
+        this._buffered.writeError(`Multiple plan files found in ${plansFolder}:\n`);
+        for (const f of files) {
+            this._buffered.writeError(`  ${f}\n`);
         }
+        this._buffered.writeError("Re-run with the chosen plan as the [plan] argument.\n");
+        return null;
     }
     async _detectBuildAndTest(ws) {
         const prompt = prompts_1.prompts.detectBuildAndTest
             .split("<BUILD_SCRIPT_PATH>").join(ws.buildScript)
             .split("<TEST_SCRIPT_PATH>").join(ws.testScript)
             .split("<RULE_LIST>").join(this._formatPathList(this._ruleList));
-        await this._runClaude(prompt);
+        await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, prompt);
     }
-    _setActivity(activity) {
+    _setActivity(activity, iteration) {
         if (!this._currentTask)
             return;
         this._block.setHeader({
             indexLabel: this._currentIndexLabel,
-            iteration: this._currentIteration,
+            iteration: iteration === undefined ? this._currentIteration : iteration,
             activity,
             taskNumber: this._currentTask.taskNumber || undefined,
             title: this._currentTask.title
@@ -282,7 +272,23 @@ class Implement {
             plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t }
         });
     }
-    async _runTask(plan, task, ws, indexLabel, taskIndex, gitActive) {
+    _reviewerMatchesWorker(reviewer) {
+        const w = this._config.worker;
+        return reviewer.tool === w.tool && reviewer.model === w.model && reviewer.effort === w.effort;
+    }
+    _prepActive() {
+        return this._config.reviewers.some(r => this._reviewerMatchesWorker(r));
+    }
+    _gitOutputContext() {
+        return {
+            write: text => this._buffered.write(text),
+            writeError: text => this._buffered.writeError(text),
+            columns: () => this._contexts.output.columns(),
+            rows: () => this._contexts.output.rows(),
+            onResize: listener => this._contexts.output.onResize(listener)
+        };
+    }
+    async _runTask(plan, task, ws, indexLabel, taskIndex) {
         this._currentTask = task;
         this._currentIndexLabel = indexLabel;
         this._currentWorkerSessionId = null;
@@ -292,12 +298,20 @@ class Implement {
         this._taskRateLimitStartedAt = null;
         this._taskTokens = { it: 0, ot: 0 };
         this._updateMetrics(plan);
-        const prepOk = await this._prepStage(plan, task, ws, taskIndex);
-        if (this._disposed) {
-            return false;
-        }
-        if (!prepOk) {
-            return false;
+        const prepActive = this._prepActive();
+        if (prepActive) {
+            this._setActivity("preparing", null);
+            this._restingFooterKind = "preparing";
+            this._block.setFooter({ kind: "preparing" });
+            const prepOk = await this._prepStage(plan, task, ws, taskIndex);
+            if (this._disposed) {
+                return false;
+            }
+            if (!prepOk) {
+                return false;
+            }
+            this._restingFooterKind = "working";
+            this._block.setFooter({ kind: "working" });
         }
         let iteration = 0;
         for (;;) {
@@ -312,13 +326,18 @@ class Implement {
                 return false;
             }
             this._setActivity("implementing");
-            const workerOk = await this._workerStage(plan, task, ws, iteration);
+            const workerOk = await this._workerStage(plan, task, ws, iteration, prepActive);
             if (this._disposed) {
                 return false;
             }
             if (!workerOk) {
                 continue;
             }
+            const workerAddResult = await (0, Git_1.addAll)(this._contexts.script, this._contexts.time, this._gitOutputContext(), this._options.projectRoot);
+            if (workerAddResult.code !== 0) {
+                await this._writeErrorLog(ws, `git add -A failed (exit ${workerAddResult.code})\n--- stdout ---\n${workerAddResult.stdout}\n--- stderr ---\n${workerAddResult.stderr}`);
+                continue;
+            }
             this._setActivity("building");
             const buildOk = await this._buildStage(plan, task.line, ws, iteration);
             if (this._disposed) {
@@ -336,35 +355,27 @@ class Implement {
                 continue;
             }
             this._setActivity("reviewing");
-            const reviewOk = await this._reviewerStage(plan, task, ws, iteration);
+            const reviewOk = await this._reviewerStage(plan, task, ws, iteration, prepActive);
             if (this._disposed) {
                 return false;
             }
+            this._block.setFooter({ kind: "working" });
             if (!reviewOk) {
                 continue;
             }
             await plan.markDone(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
-            if (gitActive) {
-                const commitMessage = task.taskNumber ? `${task.taskNumber} ${task.title}` : task.title;
-                const gitOutput = {
-                    write: text => this._buffered.write(text),
-                    writeError: text => this._buffered.writeError(text),
-                    columns: () => this._contexts.output.columns(),
-                    rows: () => this._contexts.output.rows(),
-                    onResize: listener => this._contexts.output.onResize(listener)
-                };
-                const addResult = await (0, Git_1.addAll)(this._contexts.script, this._contexts.time, gitOutput, this._options.projectRoot);
-                if (addResult.code !== 0) {
-                    await this._writeErrorLog(ws, `git add -A failed (exit ${addResult.code})\n--- stdout ---\n${addResult.stdout}\n--- stderr ---\n${addResult.stderr}`);
-                    await plan.markOpen(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
-                    continue;
-                }
-                const commitResult = await (0, Git_1.commit)(this._contexts.script, this._contexts.time, gitOutput, this._options.projectRoot, commitMessage);
-                if (commitResult.code !== 0) {
-                    await this._writeErrorLog(ws, `git commit failed (exit ${commitResult.code})\n--- stdout ---\n${commitResult.stdout}\n--- stderr ---\n${commitResult.stderr}`);
-                    await plan.markOpen(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
-                    continue;
-                }
+            const commitMessage = task.taskNumber ? `${task.taskNumber} ${task.title}` : task.title;
+            const addResult = await (0, Git_1.addAll)(this._contexts.script, this._contexts.time, this._gitOutputContext(), this._options.projectRoot);
+            if (addResult.code !== 0) {
+                await this._writeErrorLog(ws, `git add -A failed (exit ${addResult.code})\n--- stdout ---\n${addResult.stdout}\n--- stderr ---\n${addResult.stderr}`);
+                await plan.markOpen(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+                continue;
+            }
+            const commitResult = await (0, Git_1.commit)(this._contexts.script, this._contexts.time, this._gitOutputContext(), this._options.projectRoot, commitMessage);
+            if (commitResult.code !== 0) {
+                await this._writeErrorLog(ws, `git commit failed (exit ${commitResult.code})\n--- stdout ---\n${commitResult.stdout}\n--- stderr ---\n${commitResult.stderr}`);
+                await plan.markOpen(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+                continue;
             }
             const planTotals = plan.planTotals();
             const snapshot = (0, formatters_1.formatSnapshotBlock)(indexLabel, iteration, task.taskNumber || undefined, task.title, this._taskTokens.it + this._taskTokens.ot, this._activeSeconds(), planTotals.it + planTotals.ot, planTotals.t, this._contexts.output.columns());
@@ -379,9 +390,10 @@ class Implement {
             .split("<TASK_LINE>").join(String(task.line))
             .split("<TASK_TITLE>").join(task.title)
             .split("<CONTRACT_LIST>").join(this._formatPathList(this._contractList))
-            .split("<RULE_LIST>").join(this._formatPathList(this._ruleList));
+            .split("<RULE_LIST>").join(this._formatPathList(this._ruleList))
+            .split("<BEHAVIOR_RULE_LIST>").join(this._formatPathList(this._behaviorRuleList));
         try {
-            const { result, capturedOutput } = await this._runClaude(prompt);
+            const { result, capturedOutput } = await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, prompt);
             this._taskTokens.it += result.inputTokens;
             this._taskTokens.ot += result.outputTokens;
             await this._persistMetrics(plan, task.line);
@@ -405,7 +417,7 @@ class Implement {
             return false;
         }
     }
-    async _workerStage(plan, task, ws, iteration) {
+    async _workerStage(plan, task, ws, iteration, prepActive) {
         let prompt = prompts_1.prompts.worker
             .split("<PLAN_PATH>").join(plan.path)
             .split("<TASK_LINE>").join(String(task.line))
@@ -413,20 +425,23 @@ class Implement {
             .split("<BUILD_SCRIPT_PATH>").join(ws.buildScript)
             .split("<TEST_SCRIPT_PATH>").join(ws.testScript)
             .split("<CONTRACT_LIST>").join(this._formatPathList(this._contractList))
-            .split("<RULE_LIST>").join(this._formatPathList(this._ruleList));
+            .split("<RULE_LIST>").join(this._formatPathList(this._ruleList))
+            .split("<BEHAVIOR_RULE_LIST>").join(this._formatPathList(this._behaviorRuleList));
+        if (iteration === 1 && !prepActive) {
+            prompt = await this._appendLinkedContent(plan, task, prompt);
+        }
         if (iteration > 1) {
             const briefing = prompts_1.prompts.previousIterationBriefing
                 .split("<ITERATION>").join(String(iteration))
                 .split("<ERROR_LOG_PATH>").join(ws.errorLog);
             prompt = `${prompt}\n\n${briefing}`;
         }
-        if (iteration === 1 && this._currentPrepSessionId === null) {
-            throw new Error(`Worker iteration 1 for task at line ${task.line} ("${task.title}") requires a prep session id but none was captured`);
-        }
         try {
             const { result, capturedOutput } = iteration === 1
-                ? await this._runClaude(prompt, null, this._currentPrepSessionId)
-                : await this._runClaude(prompt, this._currentWorkerSessionId);
+                ? prepActive
+                    ? await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, prompt, null, this._currentPrepSessionId)
+                    : await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, prompt)
+                : await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, prompt, this._currentWorkerSessionId);
             if (result.sessionId !== null) {
                 this._currentWorkerSessionId = result.sessionId;
             }
@@ -444,6 +459,25 @@ class Implement {
             return false;
         }
     }
+    async _appendLinkedContent(plan, task, prompt) {
+        const linked = plan.linkedPaths(task);
+        const allPaths = [...linked.contracts, ...linked.rules];
+        if (allPaths.length === 0) {
+            return prompt;
+        }
+        const sections = [];
+        for (const relPath of allPaths) {
+            const absPath = (0, fsUtils_1.joinPath)(this._options.projectRoot, relPath);
+            try {
+                const content = await this._contexts.fs.readFile(absPath);
+                sections.push(`## ${relPath}\n\n${content}`);
+            }
+            catch {
+                sections.push(`## ${relPath}\n\n(file not found)`);
+            }
+        }
+        return `${prompt}\n\n## Linked reference content\n\n${sections.join("\n\n")}`;
+    }
     async _buildStage(plan, taskLine, ws, iteration) {
         if (!(await (0, fsUtils_1.isNonEmptyFile)(this._contexts.fs, ws.buildScript))) {
             return true;
@@ -478,57 +512,114 @@ class Implement {
         }
         return true;
     }
-    async _reviewerStage(plan, task, ws, iteration) {
-        if (this._currentPrepSessionId === null) {
-            throw new Error(`Reviewer for task at line ${task.line} ("${task.title}") requires a prep session id but none was captured`);
+    _setReviewerState(reviewerIdx, state) {
+        if (!this._reviewerStates)
+            return;
+        const entry = this._reviewerStates[reviewerIdx];
+        if (!entry)
+            return;
+        this._reviewerStates[reviewerIdx] = { tool: entry.tool, model: entry.model, effort: entry.effort, state };
+        this._renderReviewingFooter();
+    }
+    _renderReviewingFooter() {
+        if (!this._block || this._block.isFinalized() || !this._reviewerStates)
+            return;
+        this._block.setFooter({ kind: "reviewing", reviewers: this._reviewerStates.slice() });
+    }
+    async _reviewerStage(plan, task, ws, iteration, prepActive) {
+        const reviewers = this._config.reviewers;
+        this._reviewerStates = reviewers.map(r => ({ tool: r.tool, model: r.model, effort: r.effort, state: "running" }));
+        this._renderReviewingFooter();
+        for (let i = 0; i < reviewers.length; i++) {
+            await this._workspace.clearReviewerErrorLog(i + 1);
+        }
+        await this._workspace.clearErrorLog();
+        let failureCaught = null;
+        const launches = reviewers.map((reviewer, idx) => this._runOneReviewerToVerdict(plan, task, ws, iteration, prepActive, reviewer, idx).catch(e => {
+            if (failureCaught === null) {
+                failureCaught = e;
+            }
+        }));
+        await Promise.all(launches);
+        if (this._disposed) {
+            return false;
+        }
+        if (failureCaught !== null) {
+            await this._persistMetrics(plan, task.line);
+            this._updateMetrics(plan);
+            await this._writeErrorLog(ws, `reviewer stage failed: ${this._stringifyError(failureCaught)}`);
+            return false;
         }
-        const prompt = prompts_1.prompts.reviewer
+        const perFile = [];
+        for (let i = 0; i < reviewers.length; i++) {
+            perFile.push(await this._workspace.readReviewerErrorLog(i + 1));
+        }
+        const aggregate = perFile.join("\n").replace(/^\s+|\s+$/g, "");
+        if (aggregate.length === 0) {
+            return true;
+        }
+        await this._workspace.writeErrorLog(aggregate);
+        return false;
+    }
+    async _runOneReviewerToVerdict(plan, task, ws, iteration, prepActive, reviewer, idx) {
+        const reviewerNum = idx + 1;
+        const matchesWorker = this._reviewerMatchesWorker(reviewer);
+        const useBranchA = prepActive && matchesWorker;
+        let prompt = prompts_1.prompts.reviewer
             .split("<PLAN_PATH>").join(plan.path)
             .split("<TASK_LINE>").join(String(task.line))
             .split("<TASK_TITLE>").join(task.title)
             .split("<CONTRACT_LIST>").join(this._formatPathList(this._contractList))
-            .split("<RULE_LIST>").join(this._formatPathList(this._ruleList));
-        try {
-            const { result, capturedOutput } = await this._runClaude(prompt, null, this._currentPrepSessionId);
+            .split("<RULE_LIST>").join(this._formatPathList(this._ruleList))
+            .split("<BEHAVIOR_RULE_LIST>").join(this._formatPathList(this._behaviorRuleList))
+            .split("<ERROR_LOG_PATH>").join(ws.reviewerErrorLog(reviewerNum));
+        if (!useBranchA) {
+            prompt = await this._appendLinkedContent(plan, task, prompt);
+        }
+        const aggregateOutput = [];
+        for (;;) {
+            if (this._disposed) {
+                return;
+            }
+            this._setReviewerState(idx, "running");
+            const callbacks = {
+                onLongWaitStart: () => {
+                    if (this._disposed)
+                        return;
+                    this._setReviewerState(idx, "waiting");
+                },
+                onLongWaitEnd: () => {
+                    if (this._disposed)
+                        return;
+                    this._setReviewerState(idx, "running");
+                },
+                register: (session) => {
+                    this._activeReviewerSessions.add(session);
+                },
+                unregister: (session) => {
+                    this._activeReviewerSessions.delete(session);
+                }
+            };
+            const { result, capturedOutput } = useBranchA
+                ? await this._runAiWith(reviewer.tool, reviewer.model, reviewer.effort, prompt, null, this._currentPrepSessionId, callbacks)
+                : await this._runAiWith(reviewer.tool, reviewer.model, reviewer.effort, prompt, null, null, callbacks);
             this._taskTokens.it += result.inputTokens;
             this._taskTokens.ot += result.outputTokens;
             await this._persistMetrics(plan, task.line);
             this._updateMetrics(plan);
-            const verdict = this._parseReviewVerdict(result.text);
-            await this._writeLog(ws.reviewerLog(iteration), verdict.pass
-                ? `${capturedOutput}\n\nVerdict: PASS`
-                : `${capturedOutput}\n\nVerdict: FAIL ${verdict.reason}`);
-            if (verdict.pass) {
-                return true;
-            }
-            await this._writeErrorLog(ws, `reviewer rejected: ${verdict.reason}`);
-            return false;
-        }
-        catch (e) {
-            await this._persistMetrics(plan, task.line);
-            this._updateMetrics(plan);
-            await this._writeErrorLog(ws, `reviewer stage failed: ${this._stringifyError(e)}`);
-            return false;
-        }
-    }
-    _parseReviewVerdict(text) {
-        const trimmed = text.trim();
-        const lines = trimmed.split(/\r?\n/);
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const line = lines[i].trim();
-            if (!line) {
+            aggregateOutput.push(capturedOutput);
+            if (!await this._workspace.reviewerErrorLogExists(reviewerNum)) {
+                await this._writeLog(ws.reviewerOutputLog(iteration, reviewerNum), aggregateOutput.join("\n---\n"));
                 continue;
             }
-            if (/^pass$/i.test(line)) {
-                return { pass: true, reason: "" };
-            }
-            const failMatch = /^fail\b\s*(.*)$/i.exec(line);
-            if (failMatch) {
-                return { pass: false, reason: failMatch[1].trim() };
-            }
-            break;
+            const trimmed = (await this._workspace.readReviewerErrorLog(reviewerNum)).trim();
+            this._setReviewerState(idx, trimmed.length === 0 ? "ok" : "fail");
+            const verdictLine = trimmed.length === 0
+                ? "Verdict: PASS"
+                : `Verdict: FAIL ${trimmed}`;
+            await this._writeLog(ws.reviewerOutputLog(iteration, reviewerNum), `${aggregateOutput.join("\n---\n")}\n\n${verdictLine}`);
+            return;
         }
-        return { pass: false, reason: `unrecognized reviewer verdict: ${trimmed}` };
     }
     _formatPathList(items) {
         if (items.length === 0) {
@@ -536,7 +627,53 @@ class Implement {
         }
         return items.join("\n");
     }
-    async _runClaude(prompt, initialSessionId, forkFromSessionId) {
+    _getAdapter(tool) {
+        if (tool === "codex") {
+            return new CodexAdapter_1.CodexAdapter({
+                script: this._contexts.script,
+                time: this._contexts.time,
+                random: this._contexts.random
+            });
+        }
+        return new ClaudeAdapter_1.ClaudeAdapter({
+            claude: this._contexts.claude,
+            time: this._contexts.time
+        });
+    }
+    _defaultRunAiCallbacks() {
+        return {
+            onLongWaitStart: (kind, endTimeMs) => {
+                if (this._disposed)
+                    return;
+                if (this._currentTask !== null) {
+                    this._taskRateLimitStartedAt = this._contexts.time.now();
+                }
+                this._block.setFooter({ kind: "waiting", waitKind: kind, endTime: endTimeMs });
+            },
+            onLongWaitEnd: () => {
+                if (this._taskRateLimitStartedAt !== null) {
+                    this._taskRateLimitMs += this._contexts.time.now() - this._taskRateLimitStartedAt;
+                    this._taskRateLimitStartedAt = null;
+                }
+                if (this._disposed)
+                    return;
+                this._block.setFooter({ kind: this._restingFooterKind });
+            },
+            register: (session) => {
+                this._activeSession = { session };
+            },
+            unregister: (session) => {
+                var _a;
+                if (((_a = this._activeSession) === null || _a === void 0 ? void 0 : _a.session) === session) {
+                    this._activeSession = null;
+                }
+            }
+        };
+    }
+    _runAi(tool, model, effort, prompt, initialSessionId, forkFromSessionId) {
+        return this._runAiWith(tool, model, effort, prompt, initialSessionId !== null && initialSessionId !== void 0 ? initialSessionId : null, forkFromSessionId !== null && forkFromSessionId !== void 0 ? forkFromSessionId : null, this._defaultRunAiCallbacks());
+    }
+    async _runAiWith(tool, model, effort, prompt, initialSessionId, forkFromSessionId, callbacks) {
         if (this._disposed) {
             throw new Error("Implement disposed");
         }
@@ -554,44 +691,27 @@ class Implement {
             rows: () => this._contexts.output.rows(),
             onResize: listener => this._contexts.output.onResize(listener)
         };
-        const session = new ClaudeSession_1.ClaudeSession({
+        const adapter = this._getAdapter(tool);
+        const session = new AiSession_1.AiSession({
+            adapter,
             prompt,
-            cwd: this._options.projectRoot,
-            ...(initialSessionId != null ? { initialSessionId } : null),
-            ...(forkFromSessionId != null ? { forkFromSessionId } : null),
-            onLongWaitStart: (kind, endTimeMs) => {
-                if (this._disposed)
-                    return;
-                if (this._currentTask !== null) {
-                    this._taskRateLimitStartedAt = this._contexts.time.now();
-                }
-                this._block.setFooter({ kind: "waiting", waitKind: kind, endTime: endTimeMs });
-            },
-            onLongWaitEnd: () => {
-                if (this._taskRateLimitStartedAt !== null) {
-                    this._taskRateLimitMs += this._contexts.time.now() - this._taskRateLimitStartedAt;
-                    this._taskRateLimitStartedAt = null;
-                }
-                if (this._disposed)
-                    return;
-                this._block.setFooter({ kind: "working" });
-            }
+            model,
+            effort,
+            ...(initialSessionId != null ? { resumeSessionId: initialSessionId } : null),
+            ...(forkFromSessionId != null ? { forkParentSessionId: forkFromSessionId } : null),
+            onLongWaitStart: callbacks.onLongWaitStart,
+            onLongWaitEnd: callbacks.onLongWaitEnd
         }, {
-            claude: this._contexts.claude,
             time: this._contexts.time,
-            output: capturingOutput,
-            ask: this._contexts.ask
+            output: capturingOutput
         });
-        const running = { session };
-        this._activeSession = running;
+        callbacks.register(session);
         try {
             const result = await session.run();
             return { result, capturedOutput };
         }
         finally {
-            if (this._activeSession === running) {
-                this._activeSession = null;
-            }
+            callbacks.unregister(session);
             await session.dispose();
         }
     }
@@ -661,8 +781,10 @@ class Implement {
         this._disposed = true;
         const activeSession = (_a = this._activeSession) === null || _a === void 0 ? void 0 : _a.session;
         const activeScript = (_b = this._activeScript) === null || _b === void 0 ? void 0 : _b.script;
+        const reviewerSessions = [...this._activeReviewerSessions];
         this._activeSession = null;
         this._activeScript = null;
+        this._activeReviewerSessions.clear();
         const closers = [];
         if (activeSession) {
             closers.push(activeSession.dispose());
@@ -670,6 +792,9 @@ class Implement {
         if (activeScript) {
             closers.push(activeScript.dispose());
         }
+        for (const session of reviewerSessions) {
+            closers.push(session.dispose());
+        }
         await Promise.allSettled(closers);
         try {
             await this._runPromise;