flanders 0.3.0 → 0.5.0

package/lib/ai/AiRunner.d.ts

@@ -13,7 +13,6 @@ export type RunArgs = Readonly<{
     model: string;
     effort: string;
     resumeSessionId?: string;
-    forkParentSessionId?: string;
     abortSignal: AbortSignal;
     callbacks: RunCallbacks;
     time: TimeContext;

package/lib/ai/AiRunner.js

@@ -18,10 +18,7 @@ async function run(args) {
         const base = { prompt, model, effort, abortSignal, onUsage: callbacks.onUsage };
         let invokeArgs;
         if (firstInvocation) {
-            if (args.forkParentSessionId) {
-                invokeArgs = { ...base, forkParentSessionId: args.forkParentSessionId };
-            }
-            else if (args.resumeSessionId) {
+            if (args.resumeSessionId) {
                 invokeArgs = { ...base, resumeSessionId: args.resumeSessionId };
             }
             else {

package/lib/ai/AiSession.d.ts

@@ -12,7 +12,6 @@ export type AiSessionOptions = Readonly<{
     model: string;
     effort: string;
     resumeSessionId?: string | null;
-    forkParentSessionId?: string | null;
     onLongWaitStart?(kind: "rate-limit", endTimeMs: number): void;
     onLongWaitEnd?(): void;
 }>;

package/lib/ai/AiSession.js

@@ -72,7 +72,6 @@ class AiSession {
                     model: this._options.model,
                     effort: this._options.effort,
                     ...(this._options.resumeSessionId != null ? { resumeSessionId: this._options.resumeSessionId } : null),
-                    ...(this._options.forkParentSessionId != null ? { forkParentSessionId: this._options.forkParentSessionId } : null),
                     abortSignal: controller.signal,
                     callbacks: {
                         onOutput,

package/lib/ai/ClaudeAdapter.js

@@ -167,9 +167,6 @@ class ClaudeAdapterIterator {
         if (this._args.resumeSessionId) {
             argv.push("--resume", this._args.resumeSessionId);
         }
-        else if (this._args.forkParentSessionId) {
-            argv.push("--resume", this._args.forkParentSessionId, "--fork-session");
-        }
         if (this._args.model) {
             argv.push("--model", this._args.model);
         }

package/lib/ai/CodexAdapter.js

@@ -98,15 +98,14 @@ class CodexAdapterIterator {
         this._sawTurnCompleted = false;
         this._receivedAnyEvent = false;
         this._fallbackAttempted = false;
-        this._usedResumeOrFork = false;
+        this._usedResume = false;
         this._start(false);
     }
     _start(useExecFallback) {
         var _a, _b, _c;
         const isResume = !useExecFallback && !!this._args.resumeSessionId;
-        const isFork = !useExecFallback && !!this._args.forkParentSessionId;
-        this._usedResumeOrFork = isResume || isFork;
-        const argv = this._buildArgv(isResume, isFork);
+        this._usedResume = isResume;
+        const argv = this._buildArgv(isResume);
         const spawnOptions = { stdio: "pipe" };
         const proc = this._contexts.script.spawn("codex", argv, spawnOptions);
         this._proc = proc;
@@ -149,18 +148,18 @@ class CodexAdapterIterator {
                 exitResolve === null || exitResolve === void 0 ? void 0 : exitResolve();
                 return;
             }
-            if (this._usedResumeOrFork && !this._receivedAnyEvent && !this._fallbackAttempted) {
+            if (this._usedResume && !this._receivedAnyEvent && !this._fallbackAttempted) {
                 this._fallbackAttempted = true;
                 this._queue.push({
                     type: "output",
                     title: "Continuity lost",
                     subtitle: "",
-                    details: "codex resume/fork unavailable in installed CLI"
+                    details: "codex resume unavailable in installed CLI"
                 });
                 this._cleanup();
                 this._sawTurnCompleted = false;
                 this._receivedAnyEvent = false;
-                this._usedResumeOrFork = false;
+                this._usedResume = false;
                 exitResolve === null || exitResolve === void 0 ? void 0 : exitResolve();
                 this._start(true);
                 this._wake();
@@ -201,14 +200,11 @@ class CodexAdapterIterator {
             this._args.abortSignal.addEventListener("abort", this._abortListener, { once: true });
         }
     }
-    _buildArgv(isResume, isFork) {
+    _buildArgv(isResume) {
         const argv = [];
         if (isResume) {
             argv.push("resume", this._args.resumeSessionId);
         }
-        else if (isFork) {
-            argv.push("fork", this._args.forkParentSessionId);
-        }
         else {
             argv.push("exec");
         }

package/lib/ai/ToolAdapter.d.ts

@@ -34,17 +34,11 @@ type ToolAdapterInvokeArgsBase = Readonly<{
 }>;
 export type ToolAdapterInvokeArgsFresh = ToolAdapterInvokeArgsBase & Readonly<{
     resumeSessionId?: undefined;
-    forkParentSessionId?: undefined;
 }>;
 export type ToolAdapterInvokeArgsResume = ToolAdapterInvokeArgsBase & Readonly<{
     resumeSessionId: string;
-    forkParentSessionId?: undefined;
 }>;
-export type ToolAdapterInvokeArgsFork = ToolAdapterInvokeArgsBase & Readonly<{
-    resumeSessionId?: undefined;
-    forkParentSessionId: string;
-}>;
-export type ToolAdapterInvokeArgs = ToolAdapterInvokeArgsFresh | ToolAdapterInvokeArgsResume | ToolAdapterInvokeArgsFork;
+export type ToolAdapterInvokeArgs = ToolAdapterInvokeArgsFresh | ToolAdapterInvokeArgsResume;
 export interface ToolAdapter {
     invoke(args: ToolAdapterInvokeArgs): AsyncIterable<ToolEvent>;
 }

package/lib/commands/Implement.d.ts

@@ -27,11 +27,13 @@ export declare class Implement {
     private _block;
     private _buffered;
     private _currentWorkerSessionId;
-    private _currentPrepSessionId;
     private _activeSession;
     private _activeScript;
     private _activeReviewerSessions;
     private _reviewerStates;
+    private _reviewerLogicalStatuses;
+    private _reviewerAbortControllers;
+    private _cancelledReviewers;
     private _currentIndexLabel;
     private _currentIteration;
     private _currentTask;
@@ -39,7 +41,6 @@ export declare class Implement {
     private _taskRateLimitMs;
     private _taskRateLimitStartedAt;
     private _taskTokens;
-    private _restingFooterKind;
     private _runPromise;
     get config(): FlandersConfig | null;
     constructor(rawArgs: readonly string[], _options: ImplementOptions, _contexts: ImplementContexts);
@@ -51,17 +52,16 @@ export declare class Implement {
     private _activeSeconds;
     private _persistMetrics;
     private _updateMetrics;
-    private _reviewerMatchesWorker;
-    private _prepActive;
     private _gitOutputContext;
     private _runTask;
-    private _prepStage;
     private _workerStage;
     private _appendLinkedContent;
     private _buildStage;
     private _testStage;
     private _setReviewerState;
     private _renderReviewingFooter;
+    private _setReviewerLogicalStatus;
+    private _evaluateReviewRoundCompletion;
     private _reviewerStage;
     private _runOneReviewerToVerdict;
     private _formatPathList;

package/lib/commands/Implement.js

@@ -61,11 +61,13 @@ class Implement {
         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._reviewerLogicalStatuses = [];
+        this._reviewerAbortControllers = new Map();
+        this._cancelledReviewers = new Set();
         this._currentIndexLabel = "";
         this._currentIteration = 0;
         this._currentTask = null;
@@ -73,7 +75,6 @@ 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(() => { });
     }
@@ -182,7 +183,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);
+                const taskOk = await this._runTask(plan, open, wsPaths, indexLabel);
                 if (this._disposed) {
                     this._finalizeBlock("Interrupted");
                     return 1;
@@ -241,12 +242,12 @@ class Implement {
             .split("<RULE_LIST>").join(this._formatPathList(this._ruleList));
         await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, prompt);
     }
-    _setActivity(activity, iteration) {
+    _setActivity(activity) {
         if (!this._currentTask)
             return;
         this._block.setHeader({
             indexLabel: this._currentIndexLabel,
-            iteration: iteration === undefined ? this._currentIteration : iteration,
+            iteration: this._currentIteration,
             activity,
             taskNumber: this._currentTask.taskNumber || undefined,
             title: this._currentTask.title
@@ -272,13 +273,6 @@ class Implement {
             plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t }
         });
     }
-    _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),
@@ -288,31 +282,15 @@ class Implement {
             onResize: listener => this._contexts.output.onResize(listener)
         };
     }
-    async _runTask(plan, task, ws, indexLabel, taskIndex) {
+    async _runTask(plan, task, ws, indexLabel) {
         this._currentTask = task;
         this._currentIndexLabel = indexLabel;
         this._currentWorkerSessionId = null;
-        this._currentPrepSessionId = null;
         this._taskStartedAt = this._contexts.time.now();
         this._taskRateLimitMs = 0;
         this._taskRateLimitStartedAt = null;
         this._taskTokens = { it: 0, ot: 0 };
         this._updateMetrics(plan);
-        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 (;;) {
             iteration++;
@@ -326,7 +304,7 @@ class Implement {
                 return false;
             }
             this._setActivity("implementing");
-            const workerOk = await this._workerStage(plan, task, ws, iteration, prepActive);
+            const workerOk = await this._workerStage(plan, task, ws, iteration);
             if (this._disposed) {
                 return false;
             }
@@ -355,7 +333,7 @@ class Implement {
                 continue;
             }
             this._setActivity("reviewing");
-            const reviewOk = await this._reviewerStage(plan, task, ws, iteration, prepActive);
+            const reviewOk = await this._reviewerStage(plan, task, ws, iteration);
             if (this._disposed) {
                 return false;
             }
@@ -384,52 +362,25 @@ class Implement {
             return true;
         }
     }
-    async _prepStage(plan, task, ws, taskIndex) {
-        const prompt = prompts_1.prompts.prep
-            .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))
-            .split("<BEHAVIOR_RULE_LIST>").join(this._formatPathList(this._behaviorRuleList));
-        try {
-            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);
-            this._updateMetrics(plan);
-            await this._writeLog(ws.prepLog(taskIndex), capturedOutput);
-            if (result.sessionId === null) {
-                this._workspace.preserveOnDispose();
-                await this._writeErrorLog(ws, `prep returned no session id for task at line ${task.line} ("${task.title}")`);
-                this._buffered.writeError(`Hard stop: prep for task at line ${task.line} ("${task.title}") returned no session id. Inspect logs at ${ws.root}.\n`);
-                return false;
-            }
-            this._currentPrepSessionId = result.sessionId;
-            return true;
+    async _workerStage(plan, task, ws, iteration) {
+        let taskText;
+        if (iteration === 1) {
+            taskText = plan.fullTaskText(task);
         }
-        catch (e) {
-            await this._persistMetrics(plan, task.line);
-            this._updateMetrics(plan);
-            this._workspace.preserveOnDispose();
-            await this._writeErrorLog(ws, `prep stage failed: ${this._stringifyError(e)}`);
-            this._buffered.writeError(`Hard stop: prep for task at line ${task.line} ("${task.title}") failed. Inspect logs at ${ws.root}.\n`);
-            return false;
+        else if (this._currentWorkerSessionId !== null) {
+            taskText = "(The full task text and the contracts and rules it references were provided when this session began and remain available to you through session continuity; they are not repeated here.)";
+        }
+        else {
+            taskText = `(Your previous session for this task could not be resumed, so this is a fresh invocation. You are continuing work on the task at line ${task.line} of the plan file, titled "${task.title}". Re-read that task and the contracts and rules it references directly from the files on disk — they are not re-injected here — and address the previous-iteration briefing below.)`;
         }
-    }
-    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))
-            .split("<TASK_TITLE>").join(task.title)
+            .split("<TASK_TEXT>").join(taskText)
             .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("<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))
@@ -437,10 +388,11 @@ class Implement {
             prompt = `${prompt}\n\n${briefing}`;
         }
         try {
+            if (iteration === 1) {
+                prompt = await this._appendLinkedContent(plan, task, prompt);
+            }
             const { result, capturedOutput } = iteration === 1
-                ? 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)
                 : 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;
@@ -468,15 +420,10 @@ class Implement {
         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)`);
-            }
+            const content = await this._contexts.fs.readFile(absPath);
+            sections.push(`## ${relPath}\n\n${content}`);
         }
-        return `${prompt}\n\n## Linked reference content\n\n${sections.join("\n\n")}`;
+        return `${prompt}\n\n## Linked reference content\n\nThe full content of every contract and rule this task references is included below, so you do not need to open these files for this iteration:\n\n${sections.join("\n\n")}`;
     }
     async _buildStage(plan, taskLine, ws, iteration) {
         if (!(await (0, fsUtils_1.isNonEmptyFile)(this._contexts.fs, ws.buildScript))) {
@@ -526,16 +473,49 @@ class Implement {
             return;
         this._block.setFooter({ kind: "reviewing", reviewers: this._reviewerStates.slice() });
     }
-    async _reviewerStage(plan, task, ws, iteration, prepActive) {
+    _setReviewerLogicalStatus(idx, status) {
+        this._reviewerLogicalStatuses[idx] = status;
+        if (status !== "running") {
+            this._evaluateReviewRoundCompletion();
+        }
+    }
+    _evaluateReviewRoundCompletion() {
+        const statuses = this._reviewerLogicalStatuses;
+        const reviewers = this._config.reviewers;
+        if (statuses.some(s => s === "running")) {
+            return;
+        }
+        for (let i = 0; i < reviewers.length; i++) {
+            if (!reviewers[i].optional && statuses[i] !== "done") {
+                return;
+            }
+        }
+        const doneCount = statuses.filter(s => s === "done").length;
+        if (doneCount < this._config.minimumReviews) {
+            return;
+        }
+        for (let i = 0; i < statuses.length; i++) {
+            if (statuses[i] === "waiting") {
+                this._cancelledReviewers.add(i);
+                this._reviewerAbortControllers.get(i).abort();
+            }
+        }
+    }
+    async _reviewerStage(plan, task, ws, iteration) {
         const reviewers = this._config.reviewers;
         this._reviewerStates = reviewers.map(r => ({ tool: r.tool, model: r.model, effort: r.effort, state: "running" }));
+        this._reviewerLogicalStatuses = reviewers.map(() => "running");
+        this._cancelledReviewers = new Set();
         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 => {
+        const outcomes = reviewers.map(() => "cancelled");
+        const launches = reviewers.map((reviewer, idx) => this._runOneReviewerToVerdict(plan, task, ws, iteration, reviewer, idx)
+            .then(outcome => { outcomes[idx] = outcome; })
+            .catch(e => {
             if (failureCaught === null) {
                 failureCaught = e;
             }
@@ -552,7 +532,9 @@ class Implement {
         }
         const perFile = [];
         for (let i = 0; i < reviewers.length; i++) {
-            perFile.push(await this._workspace.readReviewerErrorLog(i + 1));
+            if (outcomes[i] === "verdict") {
+                perFile.push(await this._workspace.readReviewerErrorLog(i + 1));
+            }
         }
         const aggregate = perFile.join("\n").replace(/^\s+|\s+$/g, "");
         if (aggregate.length === 0) {
@@ -561,64 +543,88 @@ class Implement {
         await this._workspace.writeErrorLog(aggregate);
         return false;
     }
-    async _runOneReviewerToVerdict(plan, task, ws, iteration, prepActive, reviewer, idx) {
+    async _runOneReviewerToVerdict(plan, task, ws, iteration, 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("<TASK_TEXT>").join(plan.fullTaskText(task))
             .split("<CONTRACT_LIST>").join(this._formatPathList(this._contractList))
             .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)
+        prompt = await this._appendLinkedContent(plan, task, prompt);
+        const controller = new AbortController();
+        this._reviewerAbortControllers.set(idx, controller);
+        try {
+            const aggregateOutput = [];
+            for (;;) {
+                if (this._disposed) {
+                    return "cancelled";
+                }
+                this._setReviewerState(idx, "running");
+                this._setReviewerLogicalStatus(idx, "running");
+                let currentSession = null;
+                const onAbort = () => {
+                    if (!currentSession)
                         return;
-                    this._setReviewerState(idx, "running");
-                },
-                register: (session) => {
-                    this._activeReviewerSessions.add(session);
-                },
-                unregister: (session) => {
-                    this._activeReviewerSessions.delete(session);
+                    void currentSession.dispose();
+                };
+                const callbacks = {
+                    onLongWaitStart: () => {
+                        if (this._disposed)
+                            return;
+                        this._setReviewerState(idx, "waiting");
+                        this._setReviewerLogicalStatus(idx, "waiting");
+                    },
+                    onLongWaitEnd: () => {
+                        if (this._disposed)
+                            return;
+                        this._setReviewerState(idx, "running");
+                        this._setReviewerLogicalStatus(idx, "running");
+                    },
+                    register: (session) => {
+                        currentSession = session;
+                        this._activeReviewerSessions.add(session);
+                        controller.signal.addEventListener("abort", onAbort);
+                    },
+                    unregister: (session) => {
+                        this._activeReviewerSessions.delete(session);
+                        controller.signal.removeEventListener("abort", onAbort);
+                        currentSession = null;
+                    }
+                };
+                let runResult;
+                try {
+                    runResult = await this._runAiWith(reviewer.tool, reviewer.model, reviewer.effort, prompt, null, callbacks);
                 }
-            };
-            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);
-            aggregateOutput.push(capturedOutput);
-            if (!await this._workspace.reviewerErrorLogExists(reviewerNum)) {
-                await this._writeLog(ws.reviewerOutputLog(iteration, reviewerNum), aggregateOutput.join("\n---\n"));
-                continue;
+                catch (e) {
+                    if (this._cancelledReviewers.has(idx)) {
+                        return "cancelled";
+                    }
+                    throw e;
+                }
+                const { result, capturedOutput } = runResult;
+                this._taskTokens.it += result.inputTokens;
+                this._taskTokens.ot += result.outputTokens;
+                await this._persistMetrics(plan, task.line);
+                this._updateMetrics(plan);
+                aggregateOutput.push(capturedOutput);
+                if (!await this._workspace.reviewerErrorLogExists(reviewerNum)) {
+                    await this._writeLog(ws.reviewerOutputLog(iteration, reviewerNum), aggregateOutput.join("\n---\n"));
+                    continue;
+                }
+                const trimmed = (await this._workspace.readReviewerErrorLog(reviewerNum)).trim();
+                this._setReviewerState(idx, trimmed.length === 0 ? "ok" : "fail");
+                this._setReviewerLogicalStatus(idx, "done");
+                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 "verdict";
             }
-            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;
+        }
+        finally {
+            this._reviewerAbortControllers.delete(idx);
         }
     }
     _formatPathList(items) {
@@ -657,7 +663,7 @@ class Implement {
                 }
                 if (this._disposed)
                     return;
-                this._block.setFooter({ kind: this._restingFooterKind });
+                this._block.setFooter({ kind: "working" });
             },
             register: (session) => {
                 this._activeSession = { session };
@@ -670,10 +676,10 @@ class Implement {
             }
         };
     }
-    _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());
+    _runAi(tool, model, effort, prompt, initialSessionId) {
+        return this._runAiWith(tool, model, effort, prompt, initialSessionId !== null && initialSessionId !== void 0 ? initialSessionId : null, this._defaultRunAiCallbacks());
     }
-    async _runAiWith(tool, model, effort, prompt, initialSessionId, forkFromSessionId, callbacks) {
+    async _runAiWith(tool, model, effort, prompt, initialSessionId, callbacks) {
         if (this._disposed) {
             throw new Error("Implement disposed");
         }
@@ -698,7 +704,6 @@ class Implement {
             model,
             effort,
             ...(initialSessionId != null ? { resumeSessionId: initialSessionId } : null),
-            ...(forkFromSessionId != null ? { forkParentSessionId: forkFromSessionId } : null),
             onLongWaitStart: callbacks.onLongWaitStart,
             onLongWaitEnd: callbacks.onLongWaitEnd
         }, {
@@ -779,6 +784,10 @@ class Implement {
             return;
         }
         this._disposed = true;
+        for (const controller of this._reviewerAbortControllers.values()) {
+            controller.abort();
+        }
+        this._reviewerAbortControllers.clear();
         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];

package/lib/commands/Install.d.ts

@@ -23,6 +23,8 @@ export type ResolvedAnswers = Readonly<{
     workerModel?: string;
     workerEffort?: string;
     reviewers?: readonly ReviewerFlagAnswers[];
+    optionalReviewerIndices?: readonly number[];
+    reviewerMinimum?: number;
 }>;
 export declare function parseInstallFlags(rawArgs: readonly string[]): Readonly<{
     ok: true;