Trigger the ripgrep timeout test deterministically

The test raced a real spawned ripgrep process against a 1ms timeout,
so it depended on the process being slower than the clock rather than
on the timeout path itself. Thread the same stalled-child fake already
used at the runRg level through ripgrepPlugin so the timeout is the
only path to settlement.

Author: TheGreatAxios

src/plugins/ripgrep-plugin.ts

@@ -8,7 +8,7 @@ import {
   type BoundedGrepArgs,
 } from "./bounded-grep-fallback.js";
 import { createRgCollector } from "./rg-output.js";
-import { MAX_OUTPUT_BYTES, runRg, type RgLimits } from "./rg-run.js";
+import { MAX_OUTPUT_BYTES, runRg, type RgLimits, type SpawnRg } from "./rg-run.js";
 
 // A grep over a large tree with the pure-TypeScript walker enumerates the whole
 // directory (node_modules, build output, the lot) before searching, which stalls
@@ -66,7 +66,7 @@ function searchLocation(path: string, fallbackCwd: string): { cwd: string; targe
   }
 }
 
-export function ripgrepPlugin(cwd: string, limits: RgLimits = {}): ToolPlugin {
+export function ripgrepPlugin(cwd: string, limits: RgLimits = {}, spawnChild?: SpawnRg): ToolPlugin {
   const maxBytes = limits.maxOutputBytes ?? MAX_OUTPUT_BYTES;
   return {
     middleware: (next) => async (call, signal) => {
@@ -86,7 +86,7 @@ export function ripgrepPlugin(cwd: string, limits: RgLimits = {}): ToolPlugin {
         if (glob !== undefined) rgArgs.push("-g", glob);
         rgArgs.push("--regexp", pattern, target);
 
-        const result = await runRg(rgArgs, rgCwd, signal, limits);
+        const result = await runRg(rgArgs, rgCwd, signal, limits, spawnChild);
         if (result.kind === "unavailable") {
           try {
             const boundedArgs: BoundedGrepArgs = {

tests/unit/ripgrep-plugin.test.ts

@@ -5,6 +5,7 @@ import { tmpdir } from "node:os";
 import type { ToolCall, ToolResult } from "@intx/types/runtime";
 
 import { ripgrepPlugin } from "../../src/plugins/ripgrep-plugin.js";
+import type { RgChild, SpawnRg } from "../../src/plugins/rg-run.js";
 
 // Repo root derived from this file, not process.cwd(): these cases search real
 // repo paths, so they must not depend on where the runner was invoked from.
@@ -14,11 +15,23 @@ const fallback = async (): Promise<ToolResult> => ({ callId: "c", content: "FALL
 function run(
   call: ToolCall,
   limits: { timeoutMs?: number; maxOutputBytes?: number } = {},
+  spawnChild?: SpawnRg,
 ): Promise<ToolResult> {
-  const handler = ripgrepPlugin(cwd, limits).middleware!(fallback);
+  const handler = ripgrepPlugin(cwd, limits, spawnChild).middleware!(fallback);
   return handler(call, new AbortController().signal);
 }
 
+// A child that never emits data or closes, so the timeout is the only path
+// to settlement — the trigger the timeout test needs, not a race against how
+// fast a real ripgrep process happens to run.
+const stalledSpawn: SpawnRg = (): RgChild => ({
+  pid: undefined,
+  stdout: { on: () => undefined },
+  stderr: { on: () => undefined },
+  on: (() => undefined) as RgChild["on"],
+  kill: () => undefined,
+});
+
 async function withTempDir(run: (dir: string) => Promise<void>): Promise<void> {
   const dir = await mkdtemp(join(tmpdir(), "ripgrep-plugin-"));
   try {
@@ -114,6 +127,7 @@ test("grep returns partial matches when the timeout fires", async () => {
   const result = await run(
     { id: "c", name: "grep", arguments: { pattern: "e", path: "src" } },
     { timeoutMs: 1 },
+    stalledSpawn,
   );
   expect(result.isError).toBeUndefined();
   expect(result.content).toContain("timed out");