@mjasnikovs/pi-task 0.13.23 → 0.13.24

package/dist/task/phases.js

@@ -80,11 +80,12 @@ export async function phaseVerifyTooling(deps, research) {
 }
 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.
+ * 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;

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

@@ -1,9 +1,11 @@
 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.
+ * 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

@@ -1,20 +1,29 @@
 import { resolve } from 'node:path';
-import { SingleReadGuard } from './single-read-guard.js';
+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. 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.
+ * 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 guard = new SingleReadGuard();
+    const reads = new SingleReadGuard();
+    const calls = new RepeatedCallGuard();
     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;
+        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

@@ -1,16 +1,24 @@
 /**
- * In-process "read each file once" guard for the TOOLING research worker.
+ * In-process thrash guards 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.
+ * 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.
  *
- * 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.
+ *   - 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;
@@ -28,3 +36,15 @@ export declare class SingleReadGuard {
      */
     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

@@ -1,17 +1,26 @@
 /**
- * In-process "read each file once" guard for the TOOLING research worker.
+ * In-process thrash guards 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.
+ * 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.
  *
- * 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.
+ *   - 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. `
@@ -34,3 +43,26 @@ export class SingleReadGuard {
         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.23",
+    "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",