flanders 0.11.0 → 0.12.0

package/README.md

@@ -254,10 +254,10 @@ If you really want the font to be kept at that size, just save the spec, and no
 
 ## Hard stop
 
-Even the most neighborly run can run out of road. When Flanders can't get a single task past the build, test, and review gates within its five attempts, it doesn't keep flailing away — it calls a **hard stop**: the whole `implement` run ends right there and exits with a non-zero status.
+Even the most neighborly run can run out of road. When Flanders can't get a single task built, tested, reviewed, and committed within its five attempts, it doesn't keep flailing away — it calls a **hard stop**: the whole `implement` run ends right there and exits with a non-zero status.
 
 It won't leave you guessing, though. Flanders prints an error that names the task that got stuck — its line number in the plan and its title — and points you at that run's temporary folder. Every other time Flanders exits it tidies that folder away, but on a hard stop it leaves it right where it is, on purpose, so you can have a look.
 
-Inside you'll find the sessions from every attempt on the task: the worker's output, the build and test output, each reviewer's output, and the `error.log` that briefed the final iteration. It's the whole story of what was tried and where each go-round fell short.
+Inside you'll find the sessions from every attempt on the task — the worker's output, the build and test output, and each reviewer's output. Alongside them, each iteration that fell short leaves its error set down by the stage that tripped it: a build, test, or commit log for the iteration whose build, test, or commit stage failed, and — when it was the review that failed — one log per reviewer that recorded a violation. So the folder spells out plainly which stage failed in each iteration: it's the whole story of what was tried and where each go-round fell short.
 
 And here's the neighborly part — you don't have to untangle it all yourself. Invoke **`/flanders-hard-stop-review`** in your AI coding tool and hand it that folder's path, and it reads back through the sessions, tells you why the run failed, and recommends how to relaunch `implement` so the stuck task finishes this time — mending the spec or the plan, or simply running it again.

package/lib/commands/Implement.d.ts

@@ -38,6 +38,7 @@ export declare class Implement {
     private _cancelledReviewers;
     private _currentIndexLabel;
     private _currentIteration;
+    private _retainedMaterializations;
     private _currentTask;
     private _taskStartedAt;
     private _taskExcludedMs;
@@ -80,6 +81,7 @@ export declare class Implement {
     private _runScript;
     private _writeLog;
     private _writeErrorLog;
+    private _materializeHardStopErrorLogs;
     private _stringifyError;
     private _finalizeBlock;
     dispose(): Promise<void>;

package/lib/commands/Implement.js

@@ -83,6 +83,7 @@ class Implement {
         this._cancelledReviewers = new Set();
         this._currentIndexLabel = "";
         this._currentIteration = 0;
+        this._retainedMaterializations = [];
         this._currentTask = null;
         this._taskStartedAt = 0;
         this._taskExcludedMs = 0;
@@ -311,6 +312,7 @@ class Implement {
         this._taskRateLimitStartedAt = null;
         this._reviewPauseStartedAt = null;
         this._taskTokens = { it: 0, ot: 0 };
+        this._retainedMaterializations = [];
         this._otherTasksSeconds = plan.planTotals().t - task.metrics.t;
         this._updateMetrics(plan);
         let iteration = 0;
@@ -318,7 +320,15 @@ class Implement {
             iteration++;
             this._currentIteration = iteration;
             if (iteration > MAX_ITER) {
-                this._workspace.preserveOnDispose();
+                try {
+                    await this._materializeHardStopErrorLogs();
+                }
+                catch (e) {
+                    this._buffered.writeError(`Hard stop: could not materialize per-iteration error logs: ${this._stringifyError(e)}\n`);
+                }
+                finally {
+                    this._workspace.preserveOnDispose();
+                }
                 this._buffered.writeError(`Hard stop: task at line ${task.line} ("${task.title}") exceeded ${MAX_ITER} iterations. Inspect logs at ${ws.root}.\n`);
                 return false;
             }
@@ -382,13 +392,17 @@ class Implement {
             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}`);
+                const briefing = `git add -A failed (exit ${addResult.code})\n--- stdout ---\n${addResult.stdout}\n--- stderr ---\n${addResult.stderr}`;
+                this._retainedMaterializations.push({ path: ws.commitErrorLog(iteration), content: briefing });
+                await this._writeErrorLog(ws, briefing);
                 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}`);
+                const briefing = `git commit failed (exit ${commitResult.code})\n--- stdout ---\n${commitResult.stdout}\n--- stderr ---\n${commitResult.stderr}`;
+                this._retainedMaterializations.push({ path: ws.commitErrorLog(iteration), content: briefing });
+                await this._writeErrorLog(ws, briefing);
                 await revertCompletion();
                 continue;
             }
@@ -478,7 +492,9 @@ class Implement {
         this._updateMetrics(plan);
         await this._writeLog(ws.buildLog(iteration), `--- stdout ---\n${result.stdout}\n--- stderr ---\n${result.stderr}`);
         if (result.code !== 0) {
-            await this._writeErrorLog(ws, `build stage failed (exit ${result.code})\n--- stdout ---\n${result.stdout}\n--- stderr ---\n${result.stderr}`);
+            const briefing = `build stage failed (exit ${result.code})\n--- stdout ---\n${result.stdout}\n--- stderr ---\n${result.stderr}`;
+            this._retainedMaterializations.push({ path: ws.buildErrorLog(iteration), content: briefing });
+            await this._writeErrorLog(ws, briefing);
             return false;
         }
         return true;
@@ -495,7 +511,9 @@ class Implement {
         this._updateMetrics(plan);
         await this._writeLog(ws.testLog(iteration), `--- stdout ---\n${result.stdout}\n--- stderr ---\n${result.stderr}`);
         if (result.code !== 0) {
-            await this._writeErrorLog(ws, `test stage failed (exit ${result.code})\n--- stdout ---\n${result.stdout}\n--- stderr ---\n${result.stderr}`);
+            const briefing = `test stage failed (exit ${result.code})\n--- stdout ---\n${result.stdout}\n--- stderr ---\n${result.stderr}`;
+            this._retainedMaterializations.push({ path: ws.testErrorLog(iteration), content: briefing });
+            await this._writeErrorLog(ws, briefing);
             return false;
         }
         return true;
@@ -591,18 +609,22 @@ class Implement {
         if (this._disposed) {
             return false;
         }
+        const perFile = [];
+        for (let i = 0; i < reviewers.length; i++) {
+            if (outcomes[i] === "verdict") {
+                const content = await this._workspace.readReviewerErrorLog(i + 1);
+                perFile.push(content);
+                if (content.trim().length > 0) {
+                    this._retainedMaterializations.push({ path: ws.reviewerErrorLogFor(iteration, i + 1), content });
+                }
+            }
+        }
         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 perFile = [];
-        for (let i = 0; i < reviewers.length; i++) {
-            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) {
             return true;
@@ -831,6 +853,12 @@ class Implement {
     async _writeErrorLog(ws, content) {
         await this._writeLog(ws.errorLog, content);
     }
+    async _materializeHardStopErrorLogs() {
+        for (const { path, content } of this._retainedMaterializations) {
+            await this._contexts.fs.writeFile(path, content);
+        }
+        await this._workspace.clearErrorLog();
+    }
     _stringifyError(e) {
         var _a;
         if (e instanceof Error) {

package/lib/prompts/skills.js

@@ -516,7 +516,7 @@ The user invokes you as: /flanders-hard-stop-review [<data>]
 
 Your work is read-only, drawing only on the preserved hard-stop temporary folder, the plan file, and the project's spec corpus — not the AI tools' own session transcripts.
 
-1. **Read the preserved evidence.** Read the preserved hard-stop temporary folder: its per-iteration worker, build, test, and reviewer output logs, its briefing \`error.log\`, and its consolidated \`spec.md\`, together with each per-reviewer folder's \`error.log\`. From that evidence identify the task that hard-stopped — its plan-file line number and title — and the plan file the run was implementing.
+1. **Read the preserved evidence.** Read the preserved folder's per-iteration worker, build, test, and reviewer output logs; the per-stage error logs the hard stop materializes — \`build.<iteration>.error.log\`, \`test.<iteration>.error.log\`, \`reviewer.<iteration>.<position>.error.log\`, and \`commit.<iteration>.error.log\` — making explicit which stage failed in each iteration and by which reviewer (the single briefing \`error.log\` has been removed at the hard stop); its consolidated \`spec.md\`; and each per-reviewer folder's \`error.log\`. From that evidence identify the task that hard-stopped — its plan-file line number and title — and the plan file the run was implementing.
 
 2. **Ground the analysis in the project's specs.** Read the identified plan file and the contracts and rules the hard-stopped task references, consulting the wider spec corpus as far as the diagnosis needs.
 
@@ -540,9 +540,9 @@ After presenting the diagnosis, ask the user which skill to launch to carry out
 
 You create, modify, delete, and rename no file of your own: not code, not a plan file, and no file inside any \`.spec/contracts\`, \`.spec/rules\`, or \`.spec/flanders\` folder. Every file change happens only through a skill you launch, under that skill's own write authority.
 
-## Interaction language
+## Interaction and reasoning language
 
-Every message you address to the user during the run is written in the natural language of the user's most recent message in the conversation. When the user switches the language they write in partway through the interaction, every subsequent message you address to the user follows the language of their latest message.
+Use one resolved language for both your reasoning and every message you address to the user, throughout the run. Resolve it, in order, from the natural language of the user's most recent message when that message carries a determinable natural language; otherwise from the plan file you identify, then the spec corpus you consult; otherwise the general most-recent-message resolution. Follow any mid-conversation language switch the user makes.
 
 ${(0, prompts_1.buildFlandersVoiceSection)({
     subject: "the messages you address to the user",

package/lib/workspace/Workspace.d.ts

@@ -13,6 +13,10 @@ export type WorkspacePaths = Readonly<{
     reviewerOutputLog(iter: number, reviewerIndex: number): string;
     reviewerErrorLog(reviewerIndex: number): string;
     reviewerSpecFile(reviewerIndex: number): string;
+    buildErrorLog(iter: number): string;
+    testErrorLog(iter: number): string;
+    commitErrorLog(iter: number): string;
+    reviewerErrorLogFor(iter: number, position: number): string;
 }>;
 export interface PlatformContext {
     isWindows(): boolean;

package/lib/workspace/Workspace.js

@@ -52,7 +52,11 @@ class Workspace {
             reviewerLog(iter) { return (0, fsUtils_1.joinPath)(root, `reviewer.${iter}.log`); },
             reviewerOutputLog(iter, reviewerIndex) { return (0, fsUtils_1.joinPath)(root, `reviewer.${iter}.${reviewerIndex}.log`); },
             reviewerErrorLog(reviewerIndex) { return (0, fsUtils_1.joinPath)(reviewerRoots[reviewerIndex - 1], "error.log"); },
-            reviewerSpecFile(reviewerIndex) { return (0, fsUtils_1.joinPath)(reviewerRoots[reviewerIndex - 1], "spec.md"); }
+            reviewerSpecFile(reviewerIndex) { return (0, fsUtils_1.joinPath)(reviewerRoots[reviewerIndex - 1], "spec.md"); },
+            buildErrorLog(iter) { return (0, fsUtils_1.joinPath)(root, `build.${iter}.error.log`); },
+            testErrorLog(iter) { return (0, fsUtils_1.joinPath)(root, `test.${iter}.error.log`); },
+            commitErrorLog(iter) { return (0, fsUtils_1.joinPath)(root, `commit.${iter}.error.log`); },
+            reviewerErrorLogFor(iter, position) { return (0, fsUtils_1.joinPath)(root, `reviewer.${iter}.${position}.error.log`); }
         };
     }
     async errorLogExists() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flanders",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Flanders never breaks a rule",
   "main": "lib/",
   "types": "lib/types",