@mjasnikovs/pi-task 0.13.22 → 0.13.23

package/dist/task/phases.js

@@ -79,6 +79,15 @@ export async function phaseVerifyTooling(deps, research) {
     return replaceToolingWithVerified(research, parsed.verified);
 }
 const DOCS_EXTENSION_PATH = new URL('../workers/docs-extension.js', import.meta.url).pathname;
+/**
+ * In-process guard loaded into the TOOLING worker only: blocks a second read of
+ * any file it already read, feeding the model "you already read this, answer
+ * now" instead of letting it re-read. TOOLING reads each file exactly once in
+ * every healthy recorded run; re-reading is purely the thrash signature, so a
+ * read-once rule has no legitimate false positive here. See single-read-guard.ts.
+ */
+const SINGLE_READ_EXTENSION_PATH = new URL('../workers/single-read-extension.js', import.meta.url)
+    .pathname;
 /**
  * Task-file heading under which a research worker's validated output is cached.
  * A resumed research phase reads these to skip workers that already succeeded,
@@ -216,7 +225,10 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
             label: 'worker:tooling',
             // Scope to the goal prose only — not the per-file edit checklist that
             // makes a weak model spelunk source and loop. See scopedToolingGoal.
-            prompt: appendNoThink(promptHeader + RESEARCH_TOOLING_PROMPT(scopedToolingGoal(refined)))
+            prompt: appendNoThink(promptHeader + RESEARCH_TOOLING_PROMPT(scopedToolingGoal(refined))),
+            // Block re-reads in-process so a weak model that wants to re-read the
+            // same file is told to answer from what it has instead of looping.
+            extensions: [SINGLE_READ_EXTENSION_PATH]
         }
     ];
     // Run workers one at a time, persisting each worker's validated output the

package/dist/workers/single-read-extension.d.ts

@@ -0,0 +1,9 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+/**
+ * Loaded via `-e` into the TOOLING research worker only. Blocks a second read of
+ * any file the worker has already read this run, returning a reason the model
+ * receives as an error tool result (agent-loop: block → createErrorToolResult).
+ * The worker then continues from what it has instead of re-reading. See
+ * SingleReadGuard for why this is scoped to TOOLING.
+ */
+export default function (pi: ExtensionAPI): void;

package/dist/workers/single-read-extension.js

@@ -0,0 +1,20 @@
+import { resolve } from 'node:path';
+import { SingleReadGuard } from './single-read-guard.js';
+/**
+ * Loaded via `-e` into the TOOLING research worker only. Blocks a second read of
+ * any file the worker has already read this run, returning a reason the model
+ * receives as an error tool result (agent-loop: block → createErrorToolResult).
+ * The worker then continues from what it has instead of re-reading. See
+ * SingleReadGuard for why this is scoped to TOOLING.
+ */
+export default function (pi) {
+    const guard = new SingleReadGuard();
+    pi.on('tool_call', event => {
+        if (event.toolName !== 'read')
+            return;
+        const path = event.input.path;
+        if (typeof path !== 'string')
+            return;
+        return guard.check(resolve(process.cwd(), path)) ?? undefined;
+    });
+}

package/dist/workers/single-read-guard.d.ts

@@ -0,0 +1,30 @@
+/**
+ * In-process "read each file once" guard for the TOOLING research worker.
+ *
+ * Validated against every recorded mx5 run: a healthy TOOLING worker reads each
+ * file exactly once (max same-file reads = 1 across 7 tasks). The failure case
+ * (TASK_0017) re-read the same file up to 50× — the model already had the answer
+ * (package.json) but kept oscillating read→write-fragment→read until it looped.
+ *
+ * Rather than detect-and-kill (which only restarts a model that re-thrashes), we
+ * deny the re-read *inside the run*: the extension wiring returns this guard's
+ * block result from a `tool_call` handler, so pi feeds `reason` back to the model
+ * as an error tool result and the worker continues without the re-read. No kill,
+ * no restart. Pure logic, no I/O — the extension does path resolution.
+ */
+export interface ReadBlock {
+    block: true;
+    reason: string;
+}
+/** The error text the model receives in place of the re-read's contents. */
+export declare function singleReadReason(path: string): string;
+export declare class SingleReadGuard {
+    private readonly seen;
+    /**
+     * Record a read of `resolvedPath`. Returns a ReadBlock the first time a path
+     * is seen a second time (and every time after), else null on the first read.
+     * Callers pass an already-resolved/normalized path so `a.ts` and `./a.ts`
+     * dedupe to one entry.
+     */
+    check(resolvedPath: string): ReadBlock | null;
+}

package/dist/workers/single-read-guard.js

@@ -0,0 +1,36 @@
+/**
+ * In-process "read each file once" guard for the TOOLING research worker.
+ *
+ * Validated against every recorded mx5 run: a healthy TOOLING worker reads each
+ * file exactly once (max same-file reads = 1 across 7 tasks). The failure case
+ * (TASK_0017) re-read the same file up to 50× — the model already had the answer
+ * (package.json) but kept oscillating read→write-fragment→read until it looped.
+ *
+ * Rather than detect-and-kill (which only restarts a model that re-thrashes), we
+ * deny the re-read *inside the run*: the extension wiring returns this guard's
+ * block result from a `tool_call` handler, so pi feeds `reason` back to the model
+ * as an error tool result and the worker continues without the re-read. No kill,
+ * no restart. Pure logic, no I/O — the extension does path resolution.
+ */
+/** The error text the model receives in place of the re-read's contents. */
+export function singleReadReason(path) {
+    return (`You already read ${path} earlier in this run — its contents are in your context. `
+        + `Re-reading the same file is blocked. Do not read it again: use what you have already `
+        + `gathered and write your final answer now.`);
+}
+export class SingleReadGuard {
+    seen = new Set();
+    /**
+     * Record a read of `resolvedPath`. Returns a ReadBlock the first time a path
+     * is seen a second time (and every time after), else null on the first read.
+     * Callers pass an already-resolved/normalized path so `a.ts` and `./a.ts`
+     * dedupe to one entry.
+     */
+    check(resolvedPath) {
+        if (this.seen.has(resolvedPath)) {
+            return { block: true, reason: singleReadReason(resolvedPath) };
+        }
+        this.seen.add(resolvedPath);
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.13.22",
+    "version": "0.13.23",
     "description": "Deterministic spec-orchestration for local models, with a bundled real-time remote web view and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",