@asterxsk/kiln 0.1.0 → 0.2.0

package/agent/extensions/file-search/index.spec.ts

@@ -1,443 +1,443 @@
-import * as NodeServices from "@effect/platform-node/NodeServices";
-import { assert, it } from "@effect/vitest";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { Effect, FileSystem } from "effect";
-import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
-import {
-  buildFdArgs,
-  buildRgArgs,
-  FD_DEFAULT_LIMIT,
-  normalizeSearchPath,
-} from "./src/args.ts";
-import {
-  FD_INTEL_DARWIN_VERSION,
-  InstallError,
-  readBoundedResponse,
-  releaseAsset,
-  resolveBinary,
-  TOOL_SPECS,
-  UnsupportedPlatformError,
-  type BinaryEnv,
-  type ReleaseAsset,
-  type ResolvedBinary,
-} from "./src/binaries.ts";
-import { formatCapturedOutput, formatOutput } from "./src/output.ts";
-import { executeSearchProcess } from "./src/process.ts";
-import { installNotifications, makeBinaryInitializers } from "./index.ts";
-
-// --- argument construction -------------------------------------------------
-
-it("fd args: defaults list everything with the default limit", () => {
-  assert.deepEqual(buildFdArgs({}), [
-    "--color=never",
-    "--max-results",
-    String(FD_DEFAULT_LIMIT),
-    "--",
-    "",
-  ]);
-});
-
-it("fd args: all options are translated and pattern stays behind --", () => {
-  const args = buildFdArgs({
-    pattern: "-rf",
-    path: "@src",
-    type: "file",
-    extension: ".ts",
-    glob: true,
-    hidden: true,
-    max_depth: 3,
-    limit: 50,
-  });
-  assert.deepEqual(args, [
-    "--color=never",
-    "--hidden",
-    "--glob",
-    "--type",
-    "f",
-    "--extension",
-    "ts",
-    "--max-depth",
-    "3",
-    "--max-results",
-    "50",
-    "--",
-    "-rf",
-    "src",
-  ]);
-});
-
-it("fd args: out-of-range values are clamped", () => {
-  const args = buildFdArgs({ max_depth: 500, limit: 1_000_000 });
-  assert.deepEqual(args, [
-    "--color=never",
-    "--max-depth",
-    "64",
-    "--max-results",
-    "10000",
-    "--",
-    "",
-  ]);
-});
-
-it("rg args: defaults use smart-case and safe separators", () => {
-  assert.deepEqual(buildRgArgs({ pattern: "--help" }), [
-    "--line-number",
-    "--color=never",
-    "--no-heading",
-    "--with-filename",
-    "--smart-case",
-    "--max-count",
-    "100",
-    "--",
-    "--help",
-  ]);
-});
-
-it("rg args: all options are translated", () => {
-  const args = buildRgArgs({
-    pattern: "TODO",
-    path: "@lib",
-    glob: "*.ts",
-    file_type: "ts",
-    case_sensitive: true,
-    fixed_strings: true,
-    hidden: true,
-    context: 2,
-    limit: 10,
-  });
-  assert.deepEqual(args, [
-    "--line-number",
-    "--color=never",
-    "--no-heading",
-    "--with-filename",
-    "--case-sensitive",
-    "--fixed-strings",
-    "--hidden",
-    "--context",
-    "2",
-    "--glob",
-    "*.ts",
-    "--type",
-    "ts",
-    "--max-count",
-    "10",
-    "--",
-    "TODO",
-    "lib",
-  ]);
-});
-
-it("rg args: case_sensitive false forces ignore-case", () => {
-  const args = buildRgArgs({ pattern: "x", case_sensitive: false });
-  assert.isTrue(args.includes("--ignore-case"));
-  assert.isFalse(args.includes("--smart-case"));
-});
-
-it("path normalization strips leading @ and expands ~", () => {
-  assert.equal(normalizeSearchPath("@src/lib"), "src/lib");
-  assert.equal(normalizeSearchPath("~"), homedir());
-  assert.equal(normalizeSearchPath("~/projects"), join(homedir(), "projects"));
-  assert.equal(normalizeSearchPath(" plain "), "plain");
-});
-
-// --- binary resolution -----------------------------------------------------
-
-function makeEnv(options: {
-  available?: string[];
-  installShouldFail?: boolean;
-}): BinaryEnv & { installs: ReleaseAsset[]; probes: string[] } {
-  const installs: ReleaseAsset[] = [];
-  const probes: string[] = [];
-  const installed = new Set<string>();
-  return {
-    installs,
-    probes,
-    probe: (command) =>
-      Effect.sync(() => {
-        probes.push(command);
-        return (
-          (options.available ?? []).includes(command) || installed.has(command)
-        );
-      }),
-    install: (asset, destination) => {
-      if (options.installShouldFail) {
-        return Effect.fail(new InstallError({ message: "network down" }));
-      }
-      return Effect.sync(() => {
-        installs.push(asset);
-        installed.add(destination);
-      });
-    },
-  };
-}
-
-const darwinArm = { os: "darwin", arch: "arm64" } as const;
-
-it.effect("binary resolution: system fd wins and nothing is installed", () =>
-  Effect.gen(function* () {
-    const env = makeEnv({ available: ["fd"] });
-    const resolved = yield* resolveBinary(
-      TOOL_SPECS.fd,
-      "/repo/bin",
-      darwinArm,
-      env,
-    );
-
-    assert.deepEqual(resolved, {
-      tool: "fd",
-      command: "fd",
-      source: "system",
-    });
-    assert.equal(env.installs.length, 0);
-  }),
-);
-
-it.effect("binary resolution: fdfind is accepted as a system fd", () =>
-  Effect.gen(function* () {
-    const env = makeEnv({ available: ["fdfind"] });
-    const resolved = yield* resolveBinary(
-      TOOL_SPECS.fd,
-      "/repo/bin",
-      darwinArm,
-      env,
-    );
-
-    assert.deepEqual(resolved, {
-      tool: "fd",
-      command: "fdfind",
-      source: "system",
-    });
-    assert.equal(env.installs.length, 0);
-  }),
-);
-
-it.effect("binary resolution: existing bin fallback is used silently", () =>
-  Effect.gen(function* () {
-    const env = makeEnv({ available: ["/repo/bin/rg"] });
-    const resolved = yield* resolveBinary(
-      TOOL_SPECS.rg,
-      "/repo/bin",
-      darwinArm,
-      env,
-    );
-
-    assert.deepEqual(resolved, {
-      tool: "rg",
-      command: "/repo/bin/rg",
-      source: "bundled",
-    });
-    assert.equal(env.installs.length, 0);
-  }),
-);
-
-it.effect(
-  "binary resolution: missing everywhere triggers exactly one install",
-  () =>
-    Effect.gen(function* () {
-      const env = makeEnv({ available: [] });
-      const resolved = yield* resolveBinary(
-        TOOL_SPECS.rg,
-        "/repo/bin",
-        darwinArm,
-        env,
-      );
-
-      assert.equal(resolved.source, "installed");
-      assert.equal(resolved.command, "/repo/bin/rg");
-      assert.equal(env.installs.length, 1);
-      assert.match(
-        env.installs[0].url,
-        /^https:\/\/github\.com\/BurntSushi\/ripgrep\//,
-      );
-    }),
-);
-
-it.effect("binary resolution: install failure surfaces a typed error", () =>
-  Effect.gen(function* () {
-    const env = makeEnv({ available: [], installShouldFail: true });
-    const error = yield* Effect.flip(
-      resolveBinary(TOOL_SPECS.fd, "/repo/bin", darwinArm, env),
-    );
-
-    assert.instanceOf(error, InstallError);
-    assert.equal(error.message, "network down");
-  }),
-);
-
-it.effect(
-  "binary resolution: unsupported platform fails without installing",
-  () =>
-    Effect.gen(function* () {
-      const env = makeEnv({ available: [] });
-      const error = yield* Effect.flip(
-        resolveBinary(
-          TOOL_SPECS.fd,
-          "/repo/bin",
-          { os: "linux", arch: "s390x" },
-          env,
-        ),
-      );
-
-      assert.instanceOf(error, UnsupportedPlatformError);
-      assert.equal(env.installs.length, 0);
-    }),
-);
-
-it.effect("binary resolution: one failed tool does not disable the other", () =>
-  Effect.gen(function* () {
-    const env = makeEnv({
-      available: ["rg"],
-      installShouldFail: true,
-    });
-    const initializers = makeBinaryInitializers("/repo/bin", darwinArm, env);
-
-    const fdError = yield* Effect.flip(initializers.fd);
-    const rg = yield* initializers.rg;
-
-    assert.instanceOf(fdError, InstallError);
-    assert.deepEqual(rg, { tool: "rg", command: "rg", source: "system" });
-  }),
-);
-
-it("release assets cover macOS and Linux on arm64 and x64 over HTTPS", () => {
-  for (const os of ["darwin", "linux"] as const) {
-    for (const arch of ["arm64", "x64"] as const) {
-      for (const tool of ["fd", "rg"] as const) {
-        const asset = releaseAsset(tool, { os, arch });
-        assert.isDefined(asset, `${tool} ${os}/${arch}`);
-        assert.match(asset.url, /^https:\/\//);
-        assert.isTrue(asset.url.endsWith(asset.fileName));
-        assert.match(asset.sha256, /^[a-f0-9]{64}$/);
-      }
-    }
-  }
-});
-
-it("linux assets use statically linked musl builds", () => {
-  const asset = releaseAsset("fd", { os: "linux", arch: "x64" });
-  assert.isTrue(asset?.url.includes("unknown-linux-musl"));
-});
-
-it("Intel macOS uses the latest fd release that publishes that target", () => {
-  const asset = releaseAsset("fd", { os: "darwin", arch: "x64" });
-  assert.equal(asset?.version, FD_INTEL_DARWIN_VERSION);
-});
-
-it.effect(
-  "bounded downloads reject oversized declared and streamed bodies",
-  () =>
-    Effect.gen(function* () {
-      const request = HttpClientRequest.get(
-        "https://example.com/archive.tar.gz",
-      );
-      const declared = HttpClientResponse.fromWeb(
-        request,
-        new Response("small", {
-          headers: { "content-length": "100" },
-        }),
-      );
-      const declaredError = yield* Effect.flip(
-        readBoundedResponse(declared, 10),
-      );
-      assert.match(declaredError.message, /size limit/);
-
-      const streamed = HttpClientResponse.fromWeb(
-        request,
-        new Response("this body is too large"),
-      );
-      const streamedError = yield* Effect.flip(
-        readBoundedResponse(streamed, 5),
-      );
-      assert.match(streamedError.message, /size limit/);
-    }),
-);
-
-// --- notification policy ----------------------------------------------------
-
-it("notifications: only fresh installs notify", () => {
-  const system: ResolvedBinary = {
-    tool: "fd",
-    command: "fd",
-    source: "system",
-  };
-  const bundled: ResolvedBinary = {
-    tool: "rg",
-    command: "/repo/bin/rg",
-    source: "bundled",
-  };
-  const installed: ResolvedBinary = {
-    tool: "rg",
-    command: "/repo/bin/rg",
-    source: "installed",
-    version: "15.2.0",
-  };
-
-  assert.deepEqual(installNotifications([system, bundled]), []);
-  const messages = installNotifications([system, installed]);
-  assert.equal(messages.length, 1);
-  assert.match(messages[0], /downloaded rg 15\.2\.0/);
-});
-
-// --- output truncation -------------------------------------------------------
-
-it.effect("process output is streamed to a complete spill file", () =>
-  Effect.gen(function* () {
-    const result = yield* executeSearchProcess({
-      command: process.execPath,
-      args: ["-e", 'process.stdout.write("line\\n".repeat(3000))'],
-      cwd: process.cwd(),
-      tempPrefix: "pi-search-test-",
-    });
-    const formatted = formatCapturedOutput(result.output);
-
-    assert.equal(result.code, 0);
-    assert.isTrue(formatted.truncated);
-    assert.equal(formatted.lineCount, 3000);
-    assert.match(formatted.text, /2000 of 3000 lines/);
-    assert.isDefined(formatted.fullOutputPath);
-
-    const fs = yield* FileSystem.FileSystem;
-    const fullOutput = yield* fs.readFileString(formatted.fullOutputPath);
-    assert.equal(fullOutput, "line\n".repeat(3000));
-    yield* fs.remove(dirname(formatted.fullOutputPath), {
-      recursive: true,
-      force: true,
-    });
-  }).pipe(Effect.provide(NodeServices.layer)),
-);
-
-it("output: small results pass through untouched", async () => {
-  const formatted = await formatOutput("a.ts\nb.ts\n", {
-    tempPrefix: "pi-fd-",
-    persistFullOutput: () => Promise.reject(new Error("should not persist")),
-  });
-  assert.equal(formatted.text, "a.ts\nb.ts");
-  assert.equal(formatted.lineCount, 2);
-  assert.isFalse(formatted.truncated);
-  assert.isUndefined(formatted.fullOutputPath);
-});
-
-it("output: oversized results are truncated and persisted", async () => {
-  const bigOutput = Array.from({ length: 3000 }, (_, i) => `file-${i}.ts`).join(
-    "\n",
-  );
-  let persisted: string | undefined;
-  const formatted = await formatOutput(bigOutput, {
-    tempPrefix: "pi-fd-",
-    persistFullOutput: async (full) => {
-      persisted = full;
-      return "/tmp/fake/output.txt";
-    },
-  });
-  assert.isTrue(formatted.truncated);
-  assert.equal(formatted.fullOutputPath, "/tmp/fake/output.txt");
-  assert.equal(persisted, bigOutput);
-  assert.match(formatted.text, /\[Output truncated: 2000 of 3000 lines/);
-  assert.match(
-    formatted.text,
-    /Full output saved to: \/tmp\/fake\/output\.txt\]/,
-  );
-  const shownLines = formatted.text.split("\n");
-  assert.equal(shownLines[0], "file-0.ts");
-});
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, it } from "@effect/vitest";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { Effect, FileSystem } from "effect";
+import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import {
+  buildFdArgs,
+  buildRgArgs,
+  FD_DEFAULT_LIMIT,
+  normalizeSearchPath,
+} from "./src/args.ts";
+import {
+  FD_INTEL_DARWIN_VERSION,
+  InstallError,
+  readBoundedResponse,
+  releaseAsset,
+  resolveBinary,
+  TOOL_SPECS,
+  UnsupportedPlatformError,
+  type BinaryEnv,
+  type ReleaseAsset,
+  type ResolvedBinary,
+} from "./src/binaries.ts";
+import { formatCapturedOutput, formatOutput } from "./src/output.ts";
+import { executeSearchProcess } from "./src/process.ts";
+import { installNotifications, makeBinaryInitializers } from "./index.ts";
+
+// --- argument construction -------------------------------------------------
+
+it("fd args: defaults list everything with the default limit", () => {
+  assert.deepEqual(buildFdArgs({}), [
+    "--color=never",
+    "--max-results",
+    String(FD_DEFAULT_LIMIT),
+    "--",
+    "",
+  ]);
+});
+
+it("fd args: all options are translated and pattern stays behind --", () => {
+  const args = buildFdArgs({
+    pattern: "-rf",
+    path: "@src",
+    type: "file",
+    extension: ".ts",
+    glob: true,
+    hidden: true,
+    max_depth: 3,
+    limit: 50,
+  });
+  assert.deepEqual(args, [
+    "--color=never",
+    "--hidden",
+    "--glob",
+    "--type",
+    "f",
+    "--extension",
+    "ts",
+    "--max-depth",
+    "3",
+    "--max-results",
+    "50",
+    "--",
+    "-rf",
+    "src",
+  ]);
+});
+
+it("fd args: out-of-range values are clamped", () => {
+  const args = buildFdArgs({ max_depth: 500, limit: 1_000_000 });
+  assert.deepEqual(args, [
+    "--color=never",
+    "--max-depth",
+    "64",
+    "--max-results",
+    "10000",
+    "--",
+    "",
+  ]);
+});
+
+it("rg args: defaults use smart-case and safe separators", () => {
+  assert.deepEqual(buildRgArgs({ pattern: "--help" }), [
+    "--line-number",
+    "--color=never",
+    "--no-heading",
+    "--with-filename",
+    "--smart-case",
+    "--max-count",
+    "100",
+    "--",
+    "--help",
+  ]);
+});
+
+it("rg args: all options are translated", () => {
+  const args = buildRgArgs({
+    pattern: "TODO",
+    path: "@lib",
+    glob: "*.ts",
+    file_type: "ts",
+    case_sensitive: true,
+    fixed_strings: true,
+    hidden: true,
+    context: 2,
+    limit: 10,
+  });
+  assert.deepEqual(args, [
+    "--line-number",
+    "--color=never",
+    "--no-heading",
+    "--with-filename",
+    "--case-sensitive",
+    "--fixed-strings",
+    "--hidden",
+    "--context",
+    "2",
+    "--glob",
+    "*.ts",
+    "--type",
+    "ts",
+    "--max-count",
+    "10",
+    "--",
+    "TODO",
+    "lib",
+  ]);
+});
+
+it("rg args: case_sensitive false forces ignore-case", () => {
+  const args = buildRgArgs({ pattern: "x", case_sensitive: false });
+  assert.isTrue(args.includes("--ignore-case"));
+  assert.isFalse(args.includes("--smart-case"));
+});
+
+it("path normalization strips leading @ and expands ~", () => {
+  assert.equal(normalizeSearchPath("@src/lib"), "src/lib");
+  assert.equal(normalizeSearchPath("~"), homedir());
+  assert.equal(normalizeSearchPath("~/projects"), join(homedir(), "projects"));
+  assert.equal(normalizeSearchPath(" plain "), "plain");
+});
+
+// --- binary resolution -----------------------------------------------------
+
+function makeEnv(options: {
+  available?: string[];
+  installShouldFail?: boolean;
+}): BinaryEnv & { installs: ReleaseAsset[]; probes: string[] } {
+  const installs: ReleaseAsset[] = [];
+  const probes: string[] = [];
+  const installed = new Set<string>();
+  return {
+    installs,
+    probes,
+    probe: (command) =>
+      Effect.sync(() => {
+        probes.push(command);
+        return (
+          (options.available ?? []).includes(command) || installed.has(command)
+        );
+      }),
+    install: (asset, destination) => {
+      if (options.installShouldFail) {
+        return Effect.fail(new InstallError({ message: "network down" }));
+      }
+      return Effect.sync(() => {
+        installs.push(asset);
+        installed.add(destination);
+      });
+    },
+  };
+}
+
+const darwinArm = { os: "darwin", arch: "arm64" } as const;
+
+it.effect("binary resolution: system fd wins and nothing is installed", () =>
+  Effect.gen(function* () {
+    const env = makeEnv({ available: ["fd"] });
+    const resolved = yield* resolveBinary(
+      TOOL_SPECS.fd,
+      "/repo/bin",
+      darwinArm,
+      env,
+    );
+
+    assert.deepEqual(resolved, {
+      tool: "fd",
+      command: "fd",
+      source: "system",
+    });
+    assert.equal(env.installs.length, 0);
+  }),
+);
+
+it.effect("binary resolution: fdfind is accepted as a system fd", () =>
+  Effect.gen(function* () {
+    const env = makeEnv({ available: ["fdfind"] });
+    const resolved = yield* resolveBinary(
+      TOOL_SPECS.fd,
+      "/repo/bin",
+      darwinArm,
+      env,
+    );
+
+    assert.deepEqual(resolved, {
+      tool: "fd",
+      command: "fdfind",
+      source: "system",
+    });
+    assert.equal(env.installs.length, 0);
+  }),
+);
+
+it.effect("binary resolution: existing bin fallback is used silently", () =>
+  Effect.gen(function* () {
+    const env = makeEnv({ available: ["/repo/bin/rg"] });
+    const resolved = yield* resolveBinary(
+      TOOL_SPECS.rg,
+      "/repo/bin",
+      darwinArm,
+      env,
+    );
+
+    assert.deepEqual(resolved, {
+      tool: "rg",
+      command: "/repo/bin/rg",
+      source: "bundled",
+    });
+    assert.equal(env.installs.length, 0);
+  }),
+);
+
+it.effect(
+  "binary resolution: missing everywhere triggers exactly one install",
+  () =>
+    Effect.gen(function* () {
+      const env = makeEnv({ available: [] });
+      const resolved = yield* resolveBinary(
+        TOOL_SPECS.rg,
+        "/repo/bin",
+        darwinArm,
+        env,
+      );
+
+      assert.equal(resolved.source, "installed");
+      assert.equal(resolved.command, "/repo/bin/rg");
+      assert.equal(env.installs.length, 1);
+      assert.match(
+        env.installs[0].url,
+        /^https:\/\/github\.com\/BurntSushi\/ripgrep\//,
+      );
+    }),
+);
+
+it.effect("binary resolution: install failure surfaces a typed error", () =>
+  Effect.gen(function* () {
+    const env = makeEnv({ available: [], installShouldFail: true });
+    const error = yield* Effect.flip(
+      resolveBinary(TOOL_SPECS.fd, "/repo/bin", darwinArm, env),
+    );
+
+    assert.instanceOf(error, InstallError);
+    assert.equal(error.message, "network down");
+  }),
+);
+
+it.effect(
+  "binary resolution: unsupported platform fails without installing",
+  () =>
+    Effect.gen(function* () {
+      const env = makeEnv({ available: [] });
+      const error = yield* Effect.flip(
+        resolveBinary(
+          TOOL_SPECS.fd,
+          "/repo/bin",
+          { os: "linux", arch: "s390x" },
+          env,
+        ),
+      );
+
+      assert.instanceOf(error, UnsupportedPlatformError);
+      assert.equal(env.installs.length, 0);
+    }),
+);
+
+it.effect("binary resolution: one failed tool does not disable the other", () =>
+  Effect.gen(function* () {
+    const env = makeEnv({
+      available: ["rg"],
+      installShouldFail: true,
+    });
+    const initializers = makeBinaryInitializers("/repo/bin", darwinArm, env);
+
+    const fdError = yield* Effect.flip(initializers.fd);
+    const rg = yield* initializers.rg;
+
+    assert.instanceOf(fdError, InstallError);
+    assert.deepEqual(rg, { tool: "rg", command: "rg", source: "system" });
+  }),
+);
+
+it("release assets cover macOS and Linux on arm64 and x64 over HTTPS", () => {
+  for (const os of ["darwin", "linux"] as const) {
+    for (const arch of ["arm64", "x64"] as const) {
+      for (const tool of ["fd", "rg"] as const) {
+        const asset = releaseAsset(tool, { os, arch });
+        assert.isDefined(asset, `${tool} ${os}/${arch}`);
+        assert.match(asset.url, /^https:\/\//);
+        assert.isTrue(asset.url.endsWith(asset.fileName));
+        assert.match(asset.sha256, /^[a-f0-9]{64}$/);
+      }
+    }
+  }
+});
+
+it("linux assets use statically linked musl builds", () => {
+  const asset = releaseAsset("fd", { os: "linux", arch: "x64" });
+  assert.isTrue(asset?.url.includes("unknown-linux-musl"));
+});
+
+it("Intel macOS uses the latest fd release that publishes that target", () => {
+  const asset = releaseAsset("fd", { os: "darwin", arch: "x64" });
+  assert.equal(asset?.version, FD_INTEL_DARWIN_VERSION);
+});
+
+it.effect(
+  "bounded downloads reject oversized declared and streamed bodies",
+  () =>
+    Effect.gen(function* () {
+      const request = HttpClientRequest.get(
+        "https://example.com/archive.tar.gz",
+      );
+      const declared = HttpClientResponse.fromWeb(
+        request,
+        new Response("small", {
+          headers: { "content-length": "100" },
+        }),
+      );
+      const declaredError = yield* Effect.flip(
+        readBoundedResponse(declared, 10),
+      );
+      assert.match(declaredError.message, /size limit/);
+
+      const streamed = HttpClientResponse.fromWeb(
+        request,
+        new Response("this body is too large"),
+      );
+      const streamedError = yield* Effect.flip(
+        readBoundedResponse(streamed, 5),
+      );
+      assert.match(streamedError.message, /size limit/);
+    }),
+);
+
+// --- notification policy ----------------------------------------------------
+
+it("notifications: only fresh installs notify", () => {
+  const system: ResolvedBinary = {
+    tool: "fd",
+    command: "fd",
+    source: "system",
+  };
+  const bundled: ResolvedBinary = {
+    tool: "rg",
+    command: "/repo/bin/rg",
+    source: "bundled",
+  };
+  const installed: ResolvedBinary = {
+    tool: "rg",
+    command: "/repo/bin/rg",
+    source: "installed",
+    version: "15.2.0",
+  };
+
+  assert.deepEqual(installNotifications([system, bundled]), []);
+  const messages = installNotifications([system, installed]);
+  assert.equal(messages.length, 1);
+  assert.match(messages[0], /downloaded rg 15\.2\.0/);
+});
+
+// --- output truncation -------------------------------------------------------
+
+it.effect("process output is streamed to a complete spill file", () =>
+  Effect.gen(function* () {
+    const result = yield* executeSearchProcess({
+      command: process.execPath,
+      args: ["-e", 'process.stdout.write("line\\n".repeat(3000))'],
+      cwd: process.cwd(),
+      tempPrefix: "pi-search-test-",
+    });
+    const formatted = formatCapturedOutput(result.output);
+
+    assert.equal(result.code, 0);
+    assert.isTrue(formatted.truncated);
+    assert.equal(formatted.lineCount, 3000);
+    assert.match(formatted.text, /2000 of 3000 lines/);
+    assert.isDefined(formatted.fullOutputPath);
+
+    const fs = yield* FileSystem.FileSystem;
+    const fullOutput = yield* fs.readFileString(formatted.fullOutputPath);
+    assert.equal(fullOutput, "line\n".repeat(3000));
+    yield* fs.remove(dirname(formatted.fullOutputPath), {
+      recursive: true,
+      force: true,
+    });
+  }).pipe(Effect.provide(NodeServices.layer)),
+);
+
+it("output: small results pass through untouched", async () => {
+  const formatted = await formatOutput("a.ts\nb.ts\n", {
+    tempPrefix: "pi-fd-",
+    persistFullOutput: () => Promise.reject(new Error("should not persist")),
+  });
+  assert.equal(formatted.text, "a.ts\nb.ts");
+  assert.equal(formatted.lineCount, 2);
+  assert.isFalse(formatted.truncated);
+  assert.isUndefined(formatted.fullOutputPath);
+});
+
+it("output: oversized results are truncated and persisted", async () => {
+  const bigOutput = Array.from({ length: 3000 }, (_, i) => `file-${i}.ts`).join(
+    "\n",
+  );
+  let persisted: string | undefined;
+  const formatted = await formatOutput(bigOutput, {
+    tempPrefix: "pi-fd-",
+    persistFullOutput: async (full) => {
+      persisted = full;
+      return "/tmp/fake/output.txt";
+    },
+  });
+  assert.isTrue(formatted.truncated);
+  assert.equal(formatted.fullOutputPath, "/tmp/fake/output.txt");
+  assert.equal(persisted, bigOutput);
+  assert.match(formatted.text, /\[Output truncated: 2000 of 3000 lines/);
+  assert.match(
+    formatted.text,
+    /Full output saved to: \/tmp\/fake\/output\.txt\]/,
+  );
+  const shownLines = formatted.text.split("\n");
+  assert.equal(shownLines[0], "file-0.ts");
+});