flanders 0.7.0 → 0.9.0

package/lib/ai/toolErrorClassification.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRateLimitMessage = isRateLimitMessage;
+exports.isRetryableHttpStatus = isRetryableHttpStatus;
+exports.isRetryableTransport = isRetryableTransport;
+exports.synthesizeRateLimitEvent = synthesizeRateLimitEvent;
+exports.classifyToolFailure = classifyToolFailure;
+const RATE_LIMIT_SUBSTRINGS = [
+    "out of credits",
+    "refill",
+    "usage limit",
+    "rate limit",
+    "rate-limit",
+    "rate_limit",
+    "quota",
+    "too many requests"
+];
+const RATE_LIMIT_429_RE = /\b429\b/;
+const EIGHT_MINUTES_MS = 8 * 60000;
+const TWELVE_MINUTES_MS = 12 * 60000;
+const FIVE_XX_RE = /\b5\d{2}\b/;
+const STATUS_408_RE = /\b408\b/;
+const STATUS_425_RE = /\b425\b/;
+const TRANSPORT_SUBSTRINGS = [
+    "timeout",
+    "timed out",
+    "connection reset",
+    "connection refused",
+    "socket hang up",
+    "temporarily unavailable",
+    "service unavailable",
+    "gateway",
+    "network",
+    "econnreset",
+    "econnrefused",
+    "enotfound",
+    "etimedout",
+    "eai_again"
+];
+function isRateLimitMessage(message) {
+    const lower = message.trim().toLowerCase();
+    for (const sub of RATE_LIMIT_SUBSTRINGS) {
+        if (lower.includes(sub))
+            return true;
+    }
+    return RATE_LIMIT_429_RE.test(message.trim());
+}
+function isRetryableHttpStatus(message) {
+    const trimmed = message.trim();
+    if (FIVE_XX_RE.test(trimmed))
+        return true;
+    if (STATUS_408_RE.test(trimmed))
+        return true;
+    if (STATUS_425_RE.test(trimmed))
+        return true;
+    return false;
+}
+function isRetryableTransport(message) {
+    const lower = message.trim().toLowerCase();
+    for (const sub of TRANSPORT_SUBSTRINGS) {
+        if (lower.includes(sub))
+            return true;
+    }
+    return false;
+}
+function synthesizeRateLimitEvent(time, random) {
+    const r = EIGHT_MINUTES_MS + Math.round(random.random() * (TWELVE_MINUTES_MS - EIGHT_MINUTES_MS));
+    return { type: "rate_limit", waitUntilMs: time.now() + r };
+}
+function classifyToolFailure(message, time, random) {
+    if (isRateLimitMessage(message)) {
+        return synthesizeRateLimitEvent(time, random);
+    }
+    if (isRetryableHttpStatus(message) || isRetryableTransport(message)) {
+        return { type: "error", retryable: true, message };
+    }
+    return { type: "error", retryable: false, message };
+}

package/lib/cli.js

@@ -235,7 +235,7 @@ const ask = (() => {
             const o = q.options[i];
             const marker = pickedLabels.has(o.label) ? "*" : " ";
             const isDefault = q.defaultIndex === i;
-            out.write(`  ${marker} ${i + 1}) ${o.label}${o.description ? ` — ${o.description}` : ""}${isDefault ? " (default — press Enter)" : ""}\n`);
+            out.write(`  ${marker} ${i + 1}) ${o.label}${o.description ? ` — ${o.description}` : ""}${isDefault ? " (configured — press Enter)" : ""}\n`);
         }
         if (existing) {
             const labels = existing.picked.map(p => p.label).join(", ");
@@ -249,7 +249,9 @@ const ask = (() => {
         async askChoices(questions, output) {
             const out = output !== null && output !== void 0 ? output : outputContext;
             const total = questions.length;
-            const answers = new Array(total).fill(undefined);
+            const answers = questions.map(q => q.multiSelect && q.defaultIndexes !== undefined && q.defaultIndexes.length > 0
+                ? { picked: q.defaultIndexes.map(i => q.options[i]) }
+                : undefined);
             let idx = 0;
             while (idx < total) {
                 const q = questions[idx];
@@ -259,8 +261,8 @@ const ask = (() => {
                 hints.push(q.multiSelect
                     ? `[1-${q.options.length}, comma-separated; free-text OK]`
                     : `[1-${q.options.length}; free-text OK]`);
-                if (q.defaultIndex !== undefined) {
-                    hints.push("Enter for default");
+                if (q.defaultIndex !== undefined || (q.multiSelect && existing !== undefined && existing.picked.length > 0)) {
+                    hints.push("Enter for configured");
                 }
                 if (idx > 0) {
                     hints.push("'-' back");
@@ -297,6 +299,10 @@ const ask = (() => {
                     idx++;
                     continue;
                 }
+                if (raw === "" && q.multiSelect && existing !== undefined && existing.picked.length > 0) {
+                    idx++;
+                    continue;
+                }
                 const parsed = parseAnswer(raw, q.options.length, q.multiSelect);
                 if (!parsed) {
                     out.writeError("Invalid input. Pick a valid option number, type free-form text, or use '-' / '+' to navigate.\n");

package/lib/commands/Implement.d.ts

@@ -3,6 +3,7 @@ import type { FlandersConfig } from "../workspace/FlandersConfig";
 import type { Activity } from "../ui/BottomBlock";
 import { PlatformContext } from "../workspace/Workspace";
 export type { Activity };
+export declare function completedPlanPath(planPath: string): string;
 export type ImplementContexts = Readonly<{
     claude: ScriptContext;
     script: ScriptContext;
@@ -27,6 +28,7 @@ export declare class Implement {
     private _block;
     private _buffered;
     private _currentWorkerSessionId;
+    private _workerSessionTokens;
     private _activeSession;
     private _activeScript;
     private _activeReviewerSessions;
@@ -41,6 +43,7 @@ export declare class Implement {
     private _taskRateLimitMs;
     private _taskRateLimitStartedAt;
     private _taskTokens;
+    private _otherTasksSeconds;
     private _runPromise;
     get config(): FlandersConfig | null;
     constructor(rawArgs: readonly string[], _options: ImplementOptions, _contexts: ImplementContexts);

package/lib/commands/Implement.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Implement = void 0;
+exports.completedPlanPath = completedPlanPath;
 const AiSession_1 = require("../ai/AiSession");
 const ClaudeAdapter_1 = require("../ai/ClaudeAdapter");
 const CodexAdapter_1 = require("../ai/CodexAdapter");
@@ -16,6 +17,16 @@ const formatters_1 = require("../ui/formatters");
 const voiceVariants_1 = require("../voiceVariants");
 const Workspace_1 = require("../workspace/Workspace");
 const MAX_ITER = 5;
+const COMPLETED_PLAN_MARKER = "V-";
+function completedPlanPath(planPath) {
+    const slash = Math.max(planPath.lastIndexOf("/"), planPath.lastIndexOf("\\"));
+    const dir = planPath.slice(0, slash + 1);
+    const base = planPath.slice(slash + 1);
+    if (base.startsWith(COMPLETED_PLAN_MARKER)) {
+        return planPath;
+    }
+    return `${dir}${COMPLETED_PLAN_MARKER}${base}`;
+}
 class LineBufferedBlock {
     constructor(_block) {
         this._block = _block;
@@ -62,6 +73,7 @@ class Implement {
         this._workspace = null;
         this._block = null;
         this._currentWorkerSessionId = null;
+        this._workerSessionTokens = { inputTokens: 0, outputTokens: 0 };
         this._activeSession = null;
         this._activeScript = null;
         this._activeReviewerSessions = new Set();
@@ -76,6 +88,7 @@ class Implement {
         this._taskRateLimitMs = 0;
         this._taskRateLimitStartedAt = null;
         this._taskTokens = { it: 0, ot: 0 };
+        this._otherTasksSeconds = 0;
         this._runPromise = this._run(rawArgs);
         this._runPromise.catch(() => { });
     }
@@ -141,13 +154,15 @@ class Implement {
             const planTotals = plan.planTotals();
             if (initialParse.tasks.every(t => t.done)) {
                 this._block.setHeader({ indexLabel: `${totalTasks}/${totalTasks}` });
-                this._block.setMetrics({ plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t } });
+                this._block.setMetrics({ plan: { tokens: planTotals.it + planTotals.ot, baseSeconds: planTotals.t } });
                 this._buffered.write(`${(0, voiceVariants_1.pickVariant)(voiceVariants_1.tasksCompletedPool, this._contexts.random)}\n`);
                 this._finalizeBlock("Done");
                 return 0;
             }
-            this._block.setHeader({ indexLabel: `0/${totalTasks}` });
-            this._block.setMetrics({ plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t } });
+            const completedAtStartup = initialParse.tasks.filter(t => t.done).length;
+            const startupIndexLabel = `${completedAtStartup}/${totalTasks}`;
+            this._block.setHeader({ indexLabel: startupIndexLabel });
+            this._block.setMetrics({ plan: { tokens: planTotals.it + planTotals.ot, baseSeconds: planTotals.t } });
             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) {
@@ -167,6 +182,7 @@ class Implement {
             this._behaviorRuleList = specs.flanders;
             this._workspace = new Workspace_1.Workspace(this._contexts.fs, this._contexts.platform);
             const wsPaths = await this._workspace.setup(this._config.reviewers.length);
+            this._block.setHeader({ indexLabel: startupIndexLabel, phaseMessage: "preparing build and test scripts" });
             await this._detectBuildAndTest(wsPaths);
             if (this._disposed) {
                 this._finalizeBlock("Interrupted");
@@ -241,7 +257,7 @@ class Implement {
             .split("<BUILD_SCRIPT_PATH>").join(ws.buildScript)
             .split("<TEST_SCRIPT_PATH>").join(ws.testScript)
             .split("<RULE_LIST>").join(this._formatPathList(this._ruleList));
-        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, this._config.worker.fast, prompt);
     }
     _setActivity(activity) {
         if (!this._currentTask)
@@ -269,9 +285,10 @@ class Implement {
         if (!this._currentTask || this._taskRateLimitStartedAt !== null)
             return;
         const planTotals = plan.planTotals();
+        const anchorMs = this._taskStartedAt + this._taskRateLimitMs;
         this._block.setMetrics({
-            task: { tokens: this._taskTokens.it + this._taskTokens.ot, seconds: this._activeSeconds() },
-            plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t }
+            task: { tokens: this._taskTokens.it + this._taskTokens.ot, anchorMs, baseSeconds: 0 },
+            plan: { tokens: planTotals.it + planTotals.ot, anchorMs, baseSeconds: this._otherTasksSeconds }
         });
     }
     _gitOutputContext() {
@@ -287,10 +304,12 @@ class Implement {
         this._currentTask = task;
         this._currentIndexLabel = indexLabel;
         this._currentWorkerSessionId = null;
+        this._workerSessionTokens = { inputTokens: 0, outputTokens: 0 };
         this._taskStartedAt = this._contexts.time.now();
         this._taskRateLimitMs = 0;
         this._taskRateLimitStartedAt = null;
         this._taskTokens = { it: 0, ot: 0 };
+        this._otherTasksSeconds = plan.planTotals().t - task.metrics.t;
         this._updateMetrics(plan);
         let iteration = 0;
         for (;;) {
@@ -343,17 +362,32 @@ class Implement {
                 continue;
             }
             await plan.markDone(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+            const originalPlanPath = plan.path;
+            let completionRenamed = false;
+            if (plan.nextOpenTask() === null) {
+                const completedPath = completedPlanPath(originalPlanPath);
+                if (completedPath !== originalPlanPath) {
+                    await plan.rename(completedPath);
+                    completionRenamed = true;
+                }
+            }
+            const revertCompletion = async () => {
+                if (completionRenamed) {
+                    await plan.rename(originalPlanPath);
+                }
+                await plan.markOpen(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+            };
             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() });
+                await revertCompletion();
                 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() });
+                await revertCompletion();
                 continue;
             }
             const planTotals = plan.planTotals();
@@ -394,10 +428,17 @@ class Implement {
                 prompt = `${prompt}\n\n${(0, prompts_1.linkedReferenceDirective)(ws.specFile)}`;
             }
             const { result, capturedOutput } = iteration === 1
-                ? 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) {
+                ? await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, this._config.worker.fast, prompt, null, this._workerSessionTokens)
+                : await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, this._config.worker.fast, prompt, this._currentWorkerSessionId, this._workerSessionTokens);
+            if (result.sessionId !== null && result.sessionId !== this._currentWorkerSessionId) {
                 this._currentWorkerSessionId = result.sessionId;
+                this._workerSessionTokens = { inputTokens: result.inputTokens, outputTokens: result.outputTokens };
+            }
+            else {
+                this._workerSessionTokens = {
+                    inputTokens: this._workerSessionTokens.inputTokens + result.inputTokens,
+                    outputTokens: this._workerSessionTokens.outputTokens + result.outputTokens
+                };
             }
             this._taskTokens.it += result.inputTokens;
             this._taskTokens.ot += result.outputTokens;
@@ -604,7 +645,7 @@ class Implement {
                 };
                 let runResult;
                 try {
-                    runResult = await this._runAiWith(reviewer.tool, reviewer.model, reviewer.effort, prompt, null, callbacks);
+                    runResult = await this._runAiWith(reviewer.tool, reviewer.model, reviewer.effort, reviewer.fast, prompt, null, callbacks);
                 }
                 catch (e) {
                     if (this._cancelledReviewers.has(idx)) {
@@ -652,7 +693,8 @@ class Implement {
         }
         return new ClaudeAdapter_1.ClaudeAdapter({
             claude: this._contexts.claude,
-            time: this._contexts.time
+            time: this._contexts.time,
+            random: this._contexts.random
         });
     }
     _defaultRunAiCallbacks() {
@@ -685,10 +727,10 @@ class Implement {
             }
         };
     }
-    _runAi(tool, model, effort, prompt, initialSessionId) {
-        return this._runAiWith(tool, model, effort, prompt, initialSessionId !== null && initialSessionId !== void 0 ? initialSessionId : null, this._defaultRunAiCallbacks());
+    _runAi(tool, model, effort, fast, prompt, initialSessionId, priorSessionUsage) {
+        return this._runAiWith(tool, model, effort, fast, prompt, initialSessionId !== null && initialSessionId !== void 0 ? initialSessionId : null, this._defaultRunAiCallbacks(), priorSessionUsage);
     }
-    async _runAiWith(tool, model, effort, prompt, initialSessionId, callbacks) {
+    async _runAiWith(tool, model, effort, fast, prompt, initialSessionId, callbacks, priorSessionUsage) {
         if (this._disposed) {
             throw new Error("Implement disposed");
         }
@@ -712,7 +754,9 @@ class Implement {
             prompt,
             model,
             effort,
+            fast,
             ...(initialSessionId != null ? { resumeSessionId: initialSessionId } : null),
+            ...(priorSessionUsage != null ? { priorSessionUsage } : null),
             onLongWaitStart: callbacks.onLongWaitStart,
             onLongWaitEnd: callbacks.onLongWaitEnd
         }, {

package/lib/commands/Install.d.ts

@@ -1,5 +1,6 @@
 import type { AskContext, FsContext, OutputContext, ScriptContext } from "../contexts";
 import type { PlatformContext } from "../workspace/Workspace";
+import type { ToolName } from "../ai/ToolAdapter";
 export type InstallContexts = Readonly<{
     fs: FsContext;
     ask: AskContext;
@@ -11,18 +12,20 @@ export type InstallOptions = Readonly<{
     projectRoot: string;
 }>;
 type ReviewerFlagAnswers = Readonly<{
-    tool?: "claude" | "codex";
+    tool?: ToolName;
     model?: string;
     effort?: string;
 }>;
 export type ResolvedAnswers = Readonly<{
     scope?: "project" | "global";
-    skillsTool?: "claude" | "codex" | "both";
-    workerTool?: "claude" | "codex";
+    skillsTools?: readonly ToolName[];
+    workerTool?: ToolName;
     workerModel?: string;
     workerEffort?: string;
+    workerFast?: boolean;
     reviewers?: readonly ReviewerFlagAnswers[];
     optionalReviewerIndices?: readonly number[];
+    fastReviewerIndices?: readonly number[];
     reviewerMinimum?: number;
 }>;
 export declare function parseInstallFlags(rawArgs: readonly string[]): Readonly<{
@@ -39,9 +42,11 @@ export declare class Install {
     constructor(rawArgs: readonly string[], _options: InstallOptions, _contexts: InstallContexts);
     result(): Promise<number>;
     private _resolveCuratedChoice;
-    private _resolveClaudeModel;
+    private _resolveGroupedModel;
+    private _resolveFreeTextModel;
     private _resolveRoleModel;
     private _resolveRoleEffort;
+    private _resolveRoleFast;
     private _resolveReviewer;
     private _run;
     dispose(): Promise<void>;