@mjasnikovs/pi-task 0.13.22 → 0.13.24

package/dist/task/phases.js

@@ -79,6 +79,16 @@ 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 guards loaded into the TOOLING worker only: block a re-read of any
+ * file already read, and block any byte-identical grep/find/ls repeat, feeding
+ * the model "you already have this, answer now" instead of letting it re-run.
+ * TOOLING reads each file once and never needs an identical search twice in any
+ * healthy recorded run, so neither rule has a 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 +226,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,11 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+/**
+ * Loaded via `-e` into the TOOLING research worker only. Two in-run thrash
+ * blocks, each returning a reason the model receives as an error tool result
+ * (agent-loop: block → createErrorToolResult) so the worker continues instead of
+ * looping:
+ *   - read: blocks any re-read of a file already read this run (path-keyed).
+ *   - grep/find/ls: blocks an identical repeat of the same call (args-keyed).
+ * See single-read-guard.ts for why this is scoped to TOOLING.
+ */
+export default function (pi: ExtensionAPI): void;

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

@@ -0,0 +1,29 @@
+import { resolve } from 'node:path';
+import { RepeatedCallGuard, SingleReadGuard } from './single-read-guard.js';
+/** Read-like tools whose byte-identical repeats are blocked (read is handled separately). */
+const DEDUP_TOOLS = new Set(['grep', 'find', 'ls']);
+/**
+ * Loaded via `-e` into the TOOLING research worker only. Two in-run thrash
+ * blocks, each returning a reason the model receives as an error tool result
+ * (agent-loop: block → createErrorToolResult) so the worker continues instead of
+ * looping:
+ *   - read: blocks any re-read of a file already read this run (path-keyed).
+ *   - grep/find/ls: blocks an identical repeat of the same call (args-keyed).
+ * See single-read-guard.ts for why this is scoped to TOOLING.
+ */
+export default function (pi) {
+    const reads = new SingleReadGuard();
+    const calls = new RepeatedCallGuard();
+    pi.on('tool_call', event => {
+        if (event.toolName === 'read') {
+            const path = event.input.path;
+            if (typeof path !== 'string')
+                return;
+            return reads.check(resolve(process.cwd(), path)) ?? undefined;
+        }
+        if (DEDUP_TOOLS.has(event.toolName)) {
+            return calls.check(event.toolName, event.input) ?? undefined;
+        }
+        return;
+    });
+}

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

@@ -0,0 +1,50 @@
+/**
+ * In-process thrash guards for the TOOLING research worker.
+ *
+ * Two guards, one mechanism — deny a wasteful repeat *inside the run* (the
+ * extension returns the block from a `tool_call` handler, pi feeds `reason` back
+ * as an error tool result, the worker continues). No kill, no restart: detect-
+ * and-kill only re-spawns a model that deterministically re-thrashes.
+ *
+ *   - SingleReadGuard: "read each file once". Validated against every recorded
+ *     mx5 run — a healthy TOOLING worker reads each file exactly once (max
+ *     same-file reads = 1 across 7 tasks). TASK_0017 re-read one file up to 50×.
+ *     Keyed on the resolved path so any re-read is blocked regardless of offset.
+ *
+ *   - RepeatedCallGuard: "no identical search twice", for grep/find/ls. TASK_0017
+ *     also looped on grep({pattern:"^\\s*}",path:".../index.ts"}) ×5 — a path the
+ *     read guard never covered, so the call fell back to the ineffective detect→
+ *     restart path. Keyed on (toolName, stableStringify(args)) — the *same* key
+ *     the LoopDetector uses — so only byte-identical repeats trip; a legitimately
+ *     different grep pattern on the same file still passes.
+ *
+ * Pure logic, no I/O — the extension does path resolution and tool routing.
+ */
+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;
+}
+/** The error text the model receives in place of a repeated grep/find/ls call. */
+export declare function repeatedCallReason(toolName: string): string;
+export declare class RepeatedCallGuard {
+    private readonly seen;
+    /**
+     * Record a `toolName` call with `args`. Returns a ReadBlock the second time
+     * the same (toolName, stable-stringified args) pair is seen (and every time
+     * after), else null on the first. Uses the LoopDetector's stableStringify so
+     * argument key-order never causes a miss; only byte-identical calls collapse.
+     */
+    check(toolName: string, args: unknown): ReadBlock | null;
+}

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

@@ -0,0 +1,68 @@
+/**
+ * In-process thrash guards for the TOOLING research worker.
+ *
+ * Two guards, one mechanism — deny a wasteful repeat *inside the run* (the
+ * extension returns the block from a `tool_call` handler, pi feeds `reason` back
+ * as an error tool result, the worker continues). No kill, no restart: detect-
+ * and-kill only re-spawns a model that deterministically re-thrashes.
+ *
+ *   - SingleReadGuard: "read each file once". Validated against every recorded
+ *     mx5 run — a healthy TOOLING worker reads each file exactly once (max
+ *     same-file reads = 1 across 7 tasks). TASK_0017 re-read one file up to 50×.
+ *     Keyed on the resolved path so any re-read is blocked regardless of offset.
+ *
+ *   - RepeatedCallGuard: "no identical search twice", for grep/find/ls. TASK_0017
+ *     also looped on grep({pattern:"^\\s*}",path:".../index.ts"}) ×5 — a path the
+ *     read guard never covered, so the call fell back to the ineffective detect→
+ *     restart path. Keyed on (toolName, stableStringify(args)) — the *same* key
+ *     the LoopDetector uses — so only byte-identical repeats trip; a legitimately
+ *     different grep pattern on the same file still passes.
+ *
+ * Pure logic, no I/O — the extension does path resolution and tool routing.
+ */
+import { stableStringify } from '../task/loop-detector.js';
+/** 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;
+    }
+}
+/** The error text the model receives in place of a repeated grep/find/ls call. */
+export function repeatedCallReason(toolName) {
+    return (`You already ran this exact ${toolName} call earlier in this run — its result is in your `
+        + `context. Repeating the identical call is blocked. Use what you have already gathered, or `
+        + `try a different angle if you still need more, then write your final answer.`);
+}
+export class RepeatedCallGuard {
+    seen = new Set();
+    /**
+     * Record a `toolName` call with `args`. Returns a ReadBlock the second time
+     * the same (toolName, stable-stringified args) pair is seen (and every time
+     * after), else null on the first. Uses the LoopDetector's stableStringify so
+     * argument key-order never causes a miss; only byte-identical calls collapse.
+     */
+    check(toolName, args) {
+        const key = `${toolName}\x00${stableStringify(args)}`;
+        if (this.seen.has(key)) {
+            return { block: true, reason: repeatedCallReason(toolName) };
+        }
+        this.seen.add(key);
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.13.22",
+    "version": "0.13.24",
     "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",