@zenodinh/pi-render 0.1.0 → 0.1.3

package/src/renderers/tool/specs/read.test.ts

@@ -1,340 +0,0 @@
-/**
- * read.test.ts — the read spec at its seam: buildCall, build and project, with the marker paint double.
- *
- * Spec basis (from the captured host payloads below, not from the implementation):
- *   buildCall(incomplete args)      -> { title: "read" } — the tool name only.
- *   build(complete text read)       -> a file model: the cwd-relative label, the 1-indexed offset, the
- *                                      content's lines without the trailing terminator, no notice.
- *   build(offset/limit read)        -> the same, with the host's own continuation notice kept apart
- *                                      from the lines, and the numbering starting at the offset.
- *   build(details.truncation)       -> the body comes from the cut body in details, not from the text.
- *   build(no text block)            -> "unknown" (the runtime draws its raw row).
- *   build(isError)                  -> the compacted failure body, labelled with the path.
- *   project(model, {expanded: false}) -> one summary line: header, range, count, expand hint.
- *   project(model, {expanded: true})  -> the header, the numbered lines, then the notice when one exists.
- */
-
-import { readFileSync } from "node:fs";
-import { describe, expect, it } from "vitest";
-import { assertNoRealEscapes, markerPaint, testRenderContext } from "../../../../test/fakes/index.ts";
-import type { RenderContext, RowSpec, RowView, ToolResult } from "../../../core/types.ts";
-import { readRow, readSpec } from "./read.ts";
-
-const PAINT = markerPaint();
-const COLLAPSED: RowView = { expanded: false, isError: false, isPartial: false };
-const EXPANDED: RowView = { expanded: true, isError: false, isPartial: false };
-
-/** The results below are captured read-tool payloads; only the harness varies between tests. */
-const ctxOf = (args: Record<string, unknown>): RenderContext =>
-	testRenderContext({ args, cwd: "/work", argsComplete: true });
-
-/** The spec's parse for one result, with "unknown" ruled out by the caller's fixture choice. */
-function modelOf(result: ToolResult, ctx: RenderContext) {
-	const model = readSpec.build(result, ctx);
-	if (model === "unknown") throw new Error("fixture parsed as unknown");
-	return model;
-}
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-/**
- * recorded-from: executed @earendil-works/pi-coding-agent@1.0.4 `createReadTool(tmp).execute(…)` 2026-10-06 —
- * a complete text read returns `{ content: [{ type: "text", text }] }` with no `details` key at all, and the
- * text carries the file's trailing newline verbatim. The five file lines are the probe's own fixture file.
- */
-const FILE_RESULT: ToolResult = {
-	content: [{ type: "text", text: "const a = 1;\nlet b = 2;\nfunction f(): number {\n\treturn a + b;\n}\n" }],
-};
-
-/**
- * recorded-from: same probe, `{ path, offset: 3, limit: 2 }` — the host stops at the caller's limit and appends
- * its own notice after a blank line, with NO details block (read.js:132-137). Only the path is replaced.
- */
-const LIMIT_RESULT: ToolResult = {
-	content: [
-		{
-			type: "text",
-			text: "function f(): number {\n\treturn a + b;\n\n[2 more lines in file. Use offset=5 to continue.]",
-		},
-	],
-};
-
-/**
- * recorded-from: same probe, a 4200-line file read from line 1 — the host cut it at the line limit and reported
- * the cut in `details.truncation`, whose `content` is the body WITHOUT the notice. Body and the notice's range
- * are scaled down (2000 -> 2 lines) so the fixture stays readable; totals, limits, flags and the notice wording
- * are the capture's, and no key was dropped.
- */
-const TRUNCATED_RESULT: ToolResult = {
-	content: [{ type: "text", text: "line 1\nline 2\n\n[Showing lines 1-2 of 4200. Use offset=3 to continue.]" }],
-	details: {
-		truncation: {
-			content: "line 1\nline 2",
-			truncated: true,
-			truncatedBy: "lines",
-			totalLines: 4200,
-			totalBytes: 40892,
-			outputLines: 2,
-			outputBytes: 12,
-			lastLinePartial: false,
-			firstLineExceedsLimit: false,
-			maxLines: 2000,
-			maxBytes: 51200,
-		},
-	},
-};
-
-/**
- * recorded-from: ~/.agents/skills/typescript-coding/SKILL.md (read 2026-10-06), trimmed to its frontmatter and
- * first heading — the YAML `name:` is what the skill header shows, and the closing `---` is what ends the scan.
- */
-const SKILL_RESULT: ToolResult = {
-	content: [{ type: "text", text: "---\nname: typescript-coding\ndescription: Dev+test standard\n---\n\n# Mission\n" }],
-};
-
-// invented: the docs label keys on the path, not the body, so three stable lines are enough here.
-const DOCS_RESULT: ToolResult = { content: [{ type: "text", text: "# Usage\n\nRun it.\n" }] };
-
-/**
- * recorded-from: the host's read tool threw `ENOENT: no such file or directory, access '<path>'` for a missing
- * path (probe 2026-10-06); a failure reaches a renderer as a result with the message in a text block and the
- * error flag set (agent-session.js:390-397). The path is the probe's own fixture name, cwd-relative.
- */
-const ERROR_RESULT: ToolResult = {
-	content: [{ type: "text", text: "ENOENT: no such file or directory, access '/work/src/gone.ts'" }],
-	isError: true,
-};
-
-// invented: the multi-line failure shape the predecessor compacted (P helpers.ts:63-72) — consecutive blanks
-// collapse to one, a single blank line survives.
-const MULTILINE_ERROR: ToolResult = {
-	content: [{ type: "text", text: "Error: read failed\n\n\n  at read (gone.ts:1)\n" }],
-	isError: true,
-};
-
-// invented: the message the collapse cap exists for; the path is long enough to pass the limit.
-const LONG_ERROR = `ENOENT: no such file or directory, access '${"/nested".repeat(20)}'`;
-
-// invented: a result whose only block is not text — the shape a future content kind would have (the declared
-// ToolResultContent carries no image fields, so the block stays at its minimal shape).
-const NO_TEXT_RESULT: ToolResult = { content: [{ type: "image" }] };
-
-// ---------------------------------------------------------------------------
-// AC-4 — the call line
-// ---------------------------------------------------------------------------
-
-describe("buildCall — the args gate", () => {
-	it("AC-4: an incomplete argument set yields the tool name only", () => {
-		const ctx = testRenderContext({ args: {}, argsComplete: false });
-		// fails_when: the call line invents an argument value before the host has delivered the arguments
-		expect(readSpec.buildCall({}, ctx).title).toBe("read");
-	});
-
-	it("AC-4: no argument value ever reaches the call line", () => {
-		const ctx = ctxOf({ path: "secret/gone.ts", offset: 7, limit: 2 });
-		// fails_when: the path or range is fabricated into the title (the summary line is where they belong)
-		expect(readSpec.buildCall({ path: "secret/gone.ts", offset: 7, limit: 2 }, ctx).title).toBe("read");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// AC-1 — the golden rows
-// ---------------------------------------------------------------------------
-
-describe("project — the file row", () => {
-	it("AC-1: a complete read summarises the file, and numbers it from line 1 when expanded", () => {
-		const model = modelOf(FILE_RESULT, ctxOf({ path: "src/small.ts" }));
-		// fails_when: the summary renders a wrong path or count, or the content loses the trailing newline's trim
-		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
-			`${PAINT.title("→ read")} ${PAINT.title("src/small.ts")} ${PAINT.muted("5 lines — ctrl+o to expand")}`,
-		);
-		expect(readSpec.project(model, EXPANDED, PAINT)).toBe(
-			[
-				`${PAINT.title("→ read")} ${PAINT.title("src/small.ts")}`,
-				`${PAINT.gutter("  1")} ${PAINT.muted("│")} ${PAINT.output("const a = 1;")}`,
-				`${PAINT.gutter("  2")} ${PAINT.muted("│")} ${PAINT.output("let b = 2;")}`,
-				`${PAINT.gutter("  3")} ${PAINT.muted("│")} ${PAINT.output("function f(): number {")}`,
-				`${PAINT.gutter("  4")} ${PAINT.muted("│")} ${PAINT.output("\treturn a + b;")}`,
-				`${PAINT.gutter("  5")} ${PAINT.muted("│")} ${PAINT.output("}")}`,
-			].join("\n"),
-		);
-	});
-
-	it("AC-1: an offset read numbers from the offset and keeps the host's notice out of the lines", () => {
-		const model = modelOf(LIMIT_RESULT, ctxOf({ path: "src/small.ts", offset: 3, limit: 2 }));
-		// fails_when: the numbering starts at 1 (the predecessor's 0-based leak), or the notice is numbered as a line
-		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
-			`${PAINT.title("→ read")} ${PAINT.title("src/small.ts")}${PAINT.muted(":3")} ${PAINT.muted("2 lines — ctrl+o to expand")}`,
-		);
-		expect(readSpec.project(model, EXPANDED, PAINT)).toBe(
-			[
-				`${PAINT.title("→ read")} ${PAINT.title("src/small.ts")}${PAINT.muted(":3")}`,
-				`${PAINT.gutter("  3")} ${PAINT.muted("│")} ${PAINT.output("function f(): number {")}`,
-				`${PAINT.gutter("  4")} ${PAINT.muted("│")} ${PAINT.output("\treturn a + b;")}`,
-				PAINT.warning("[2 more lines in file. Use offset=5 to continue.]"),
-			].join("\n"),
-		);
-	});
-
-	it("AC-1: a truncated read takes its body from details and warns on the cut", () => {
-		const model = modelOf(TRUNCATED_RESULT, ctxOf({ path: "src/many.txt" }));
-		// fails_when: the displayed body comes from the notice-bearing text (so the notice becomes line 3), or
-		//            a cut read renders silently
-		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
-			`${PAINT.title("→ read")} ${PAINT.title("src/many.txt")} ${PAINT.muted("2 lines — ctrl+o to expand")}`,
-		);
-		expect(readSpec.project(model, EXPANDED, PAINT)).toBe(
-			[
-				`${PAINT.title("→ read")} ${PAINT.title("src/many.txt")}`,
-				`${PAINT.gutter("  1")} ${PAINT.muted("│")} ${PAINT.output("line 1")}`,
-				`${PAINT.gutter("  2")} ${PAINT.muted("│")} ${PAINT.output("line 2")}`,
-				PAINT.warning("[Showing lines 1-2 of 4200. Use offset=3 to continue.]"),
-			].join("\n"),
-		);
-	});
-
-	it("AC-1: a SKILL.md read draws the skill header from the frontmatter name", () => {
-		const model = modelOf(SKILL_RESULT, ctxOf({ path: ".agents/skills/typescript-coding/SKILL.md" }));
-		// fails_when: the frontmatter name is missed (a directory name or a path appears instead), or the expanded
-		//            header loses its collapse hint
-		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
-			`${PAINT.accent("[skill]")} ${PAINT.title("typescript-coding")} ${PAINT.muted("6 lines — ctrl+o to expand")}`,
-		);
-		const expanded = readSpec.project(model, EXPANDED, PAINT).split("\n");
-		expect(expanded[0]).toBe(
-			`${PAINT.accent("[skill]")} ${PAINT.title("typescript-coding")} ${PAINT.muted("ctrl+o to collapse")}`,
-		);
-		expect(expanded.slice(1)).toEqual([
-			`${PAINT.gutter("  1")} ${PAINT.muted("│")} ${PAINT.output("---")}`,
-			`${PAINT.gutter("  2")} ${PAINT.muted("│")} ${PAINT.output("name: typescript-coding")}`,
-			`${PAINT.gutter("  3")} ${PAINT.muted("│")} ${PAINT.output("description: Dev+test standard")}`,
-			`${PAINT.gutter("  4")} ${PAINT.muted("│")} ${PAINT.output("---")}`,
-			`${PAINT.gutter("  5")} ${PAINT.muted("│")} ${PAINT.output("")}`,
-			`${PAINT.gutter("  6")} ${PAINT.muted("│")} ${PAINT.output("# Mission")}`,
-		]);
-	});
-
-	it("AC-1: only docs paths read as documents", () => {
-		const docs = modelOf(DOCS_RESULT, ctxOf({ path: "docs/usage.md" }));
-		// fails_when: every path is labelled a docs row, or a docs path is not
-		expect(readSpec.project(docs, COLLAPSED, PAINT)).toBe(
-			`${PAINT.title("→ read docs")} ${PAINT.title("docs/usage.md")} ${PAINT.muted("3 lines — ctrl+o to expand")}`,
-		);
-		const other = modelOf(DOCS_RESULT, ctxOf({ path: "src/notes.md" }));
-		expect(readSpec.project(other, COLLAPSED, PAINT)).toBe(
-			`${PAINT.title("→ read")} ${PAINT.title("src/notes.md")} ${PAINT.muted("3 lines — ctrl+o to expand")}`,
-		);
-	});
-
-	it("AC-1: the count follows the content, including the empty and single-line cases", () => {
-		const empty = modelOf({ content: [{ type: "text", text: "" }] }, ctxOf({ path: "src/empty.ts" }));
-		const single = modelOf({ content: [{ type: "text", text: "only\n" }] }, ctxOf({ path: "src/one.ts" }));
-		// fails_when: an empty file reports a phantom line, or a one-line file reads "1 lines"
-		expect(readSpec.project(empty, COLLAPSED, PAINT)).toBe(
-			`${PAINT.title("→ read")} ${PAINT.title("src/empty.ts")} ${PAINT.muted("0 lines — ctrl+o to expand")}`,
-		);
-		expect(readSpec.project(single, COLLAPSED, PAINT)).toBe(
-			`${PAINT.title("→ read")} ${PAINT.title("src/one.ts")} ${PAINT.muted("1 line — ctrl+o to expand")}`,
-		);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// AC-2 — error rows
-// ---------------------------------------------------------------------------
-
-describe("project — the error row", () => {
-	it("AC-2: a failed read carries its message on the collapsed line and its body when expanded", () => {
-		const model = modelOf(ERROR_RESULT, ctxOf({ path: "src/gone.ts" }));
-		// fails_when: an error row renders blank, loses the path, or shows the whole body collapsed
-		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
-			`${PAINT.error("→ read")} ${PAINT.title("src/gone.ts")} ${PAINT.error("ENOENT: no such file or directory, access '/work/src/gone.ts'")}`,
-		);
-		expect(readSpec.project(model, EXPANDED, PAINT)).toBe(
-			PAINT.error("ENOENT: no such file or directory, access '/work/src/gone.ts'"),
-		);
-	});
-
-	it("AC-2: a multi-line failure compacts to one blank separator and keeps a blank line blank", () => {
-		const model = modelOf(MULTILINE_ERROR, ctxOf({ path: "src/gone.ts" }));
-		// fails_when: the collapsed line shows a blank first line, or the body paints blank lines
-		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
-			`${PAINT.error("→ read")} ${PAINT.title("src/gone.ts")} ${PAINT.error("Error: read failed")}`,
-		);
-		expect(readSpec.project(model, EXPANDED, PAINT)).toBe(
-			[PAINT.error("Error: read failed"), "", PAINT.error("  at read (gone.ts:1)")].join("\n"),
-		);
-	});
-
-	it("AC-2: a failure with no body still renders a row, and a long message stays one line", () => {
-		const empty = modelOf({ content: [], isError: true }, ctxOf({ path: "src/gone.ts" }));
-		const long = modelOf(
-			{ content: [{ type: "text", text: LONG_ERROR }], isError: true },
-			ctxOf({ path: "src/gone.ts" }),
-		);
-		// fails_when: an empty error body renders a driverless blank line, or the collapsed line grows past one line
-		expect(readSpec.project(empty, COLLAPSED, PAINT)).toBe(
-			`${PAINT.error("→ read")} ${PAINT.title("src/gone.ts")} ${PAINT.error("failed")}`,
-		);
-		expect(readSpec.project(long, COLLAPSED, PAINT)).toBe(
-			`${PAINT.error("→ read")} ${PAINT.title("src/gone.ts")} ${PAINT.error(`${LONG_ERROR.slice(0, 119)}…`)}`,
-		);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Degradation and the seam's structural contract
-// ---------------------------------------------------------------------------
-
-describe("the read spec's degradation and exports", () => {
-	it("degrades to unknown when the result carries no text block", () => {
-		// fails_when: a content kind the spec cannot read is drawn as an empty file row instead of the raw row
-		expect(readSpec.build(NO_TEXT_RESULT, ctxOf({ path: "shot.png" }))).toBe("unknown");
-	});
-
-	it("AC-3: the source carries no execution, registration or prompt text", () => {
-		const source = readFileSync(new URL("./read.ts", import.meta.url), "utf8");
-		// fails_when: an execute wrapper, a tool registration, or model-facing prompt text comes back in
-		for (const pattern of [
-			/registerTool/,
-			/\bexecute\s*[:(=]/,
-			/promptSnippet|promptGuidelines/,
-			/\bdescription\s*:/,
-			/\bparameters\s*:/,
-			/as unknown as/,
-		]) {
-			expect(source).not.toMatch(pattern);
-		}
-	});
-
-	it("AC-5: every escape a row draws is a paint marker", () => {
-		const ctx = ctxOf({ path: "src/small.ts" });
-		const outputs = [
-			readSpec.project(modelOf(FILE_RESULT, ctx), COLLAPSED, PAINT),
-			readSpec.project(modelOf(FILE_RESULT, ctx), EXPANDED, PAINT),
-			readSpec.project(modelOf(SKILL_RESULT, ctxOf({ path: "s/SKILL.md" })), COLLAPSED, PAINT),
-			readSpec.project(modelOf(ERROR_RESULT, ctxOf({ path: "src/gone.ts" })), COLLAPSED, PAINT),
-			readSpec.project(modelOf(ERROR_RESULT, ctxOf({ path: "src/gone.ts" })), EXPANDED, PAINT),
-		];
-		for (const output of outputs) {
-			// fails_when: a hardcoded color or reset leaks past paint
-			assertNoRealEscapes(output);
-			// Non-vacuity: a row always carries the marker paint's own codes (200..231), never an empty string.
-			expect(output).toMatch(/\[38;5;2[0-3]\dm/);
-		}
-		const source = readFileSync(new URL("./read.ts", import.meta.url), "utf8");
-		// fails_when: an escape literal appears in the source, painting around the paint seam
-		expect(source).not.toMatch(/\\x1b|\\u001b|\\033|\[38;5;/);
-	});
-
-	it("exports the record T-28 composes, and erases into the resolver's unknown-typed table", () => {
-		const table: Record<string, RowSpec> = { [readRow.name]: readRow.spec };
-		// fails_when: the table key, the descriptor or the RowSpec<M> erasure stops matching the seam map
-		expect(readRow.name).toBe("read");
-		expect(readRow.spec).toBe(readSpec);
-		expect(readRow.descriptor).toEqual({ key: "row.read", name: "Read row", defaultEnabled: true, settings: [] });
-		expect(table.read).toBe(readSpec);
-	});
-});

package/src/renderers/tool/specs/search.test.ts

@@ -1,197 +0,0 @@
-// Fixture provenance:
-// - pi-fff fixtures (GREP_FFF, GREP_FFF_DETAILS, FUZZY, FIND_WEAK, D0..D2, and the parity bodies):
-//   invented — synthesized from pi-fff 0.11.0's formatting code via the DP4 dossier
-//   (system-analysis/working/dossier-dp4-search-fingerprints.md, 2026-10-06); no live capture exists.
-// - host fixtures (HOST_GREP): invented — synthesized from host pi 1.0.4 grep.js:206 (DP4 raw-data).
-// - the parity bodies are the format examples the predecessor parser pinned at
-//   pi-pretty-tui/src/core/fff-format.ts:12-18,31-41; it shipped no test file (verified — nothing in
-//   pi-pretty-tui imports parseGrepOutput/parseFindOutput), so AC-6 ports those expectations as fixtures.
-
-// shape: none — test module: every behavior is asserted only through the exported SEARCH_SPECS /
-// createSearchSpec seam.
-import { describe, expect, test } from "vitest";
-import { assertNoRealEscapes, markerPaint, testRenderContext } from "../../../../test/fakes/index.ts";
-import { createSearchSpec, SEARCH_SPECS, SEARCH_TOOL_NAMES, type SearchModel, type SearchToolName } from "./search.ts";
-
-const PAINT = markerPaint();
-const COLLAPSED = { expanded: false, isError: false, isPartial: false };
-const EXPANDED = { expanded: true, isError: false, isPartial: false };
-
-type MatchesModel = Extract<SearchModel, { kind: "matches" }>;
-type FilesModel = Extract<SearchModel, { kind: "files" }>;
-type EmptyModel = Extract<SearchModel, { kind: "empty" }>;
-
-function parse(name: SearchToolName, text: string, details: unknown, args: Record<string, unknown> = {}) {
-	const spec = createSearchSpec(name);
-	const row = testRenderContext({ args });
-	const invocation = row.result({ content: [{ type: "text", text }], details });
-	return { spec, model: spec.build(invocation.result, invocation.ctx) };
-}
-
-function narrowMatches(model: SearchModel | "unknown"): MatchesModel {
-	if (model === "unknown" || model.kind !== "matches") {
-		throw new Error(`expected a matches model, got ${JSON.stringify(model)}`);
-	}
-	return model;
-}
-
-function narrowFiles(model: SearchModel | "unknown"): FilesModel {
-	if (model === "unknown" || model.kind !== "files") {
-		throw new Error(`expected a files model, got ${JSON.stringify(model)}`);
-	}
-	return model;
-}
-
-function narrowEmpty(model: SearchModel | "unknown"): EmptyModel {
-	if (model === "unknown" || model.kind !== "empty") {
-		throw new Error(`expected an empty model, got ${JSON.stringify(model)}`);
-	}
-	return model;
-}
-
-const GREP_FFF = [
-	"src/payments.ts  [modified in git]",
-	" 1: export interface PaymentRequest {",
-	" 3: route(...)",
-	"",
-	"src/other.ts  [often touched file]",
-	" 7: const total = sum(payments)",
-].join("\n");
-const GREP_FFF_DETAILS = { totalMatched: 3, totalFiles: 2 };
-
-const HOST_GREP = ["src/payments.ts:1: export interface PaymentRequest {", "src/payments.ts:3: route(...)"].join("\n");
-
-const FUZZY = [
-	"[0 exact matches. Maybe you meant this?]",
-	"src/payments.ts",
-	" 1: export interface PaymentRequest {",
-].join("\n");
-
-const FIND_WEAK = [
-	"src/pay.ts",
-	"src/payments.ts",
-	"",
-	'[Query "p" produced only weak scattered fuzzy matches. Output capped at 5/30.]',
-].join("\n");
-
-// The totals pi-fff always attaches to the shapes above (DP4: FFF:1126-1131).
-const D0 = { totalMatched: 0, totalFiles: 0 };
-const D1 = { totalMatched: 1, totalFiles: 1 };
-const D2 = { totalMatched: 2, totalFiles: 2 };
-
-describe("renderers/tool/specs/search — pi-fff fingerprint rows", () => {
-	test("AC-1 a pi-fff grep result renders a grouped row with the file count and highlighted matches", () => {
-		// fails_when: raw text shown for a pi-fff result.
-		const { spec, model } = parse("ffgrep", GREP_FFF, GREP_FFF_DETAILS, { pattern: "route" });
-		const matches = narrowMatches(model);
-		expect(matches.matchCount).toBe(3);
-		expect(matches.blocks).toHaveLength(2);
-		expect(matches.blocks[0]?.path).toBe("src/payments.ts");
-		expect(matches.blocks[0]?.annotation).toBe("modified in git");
-
-		expect(spec.project(matches, COLLAPSED, PAINT)).toBe(PAINT.muted("3 matches in 2 files"));
-
-		const expanded = spec.project(matches, EXPANDED, PAINT);
-		expect(expanded).toContain(PAINT.muted("3 matches in 2 files"));
-		expect(expanded).toContain(PAINT.accent("src/payments.ts"));
-		expect(expanded).toContain(PAINT.muted("[modified in git]"));
-		expect(expanded).toContain(PAINT.match("route"));
-		assertNoRealEscapes(expanded);
-	});
-
-	test("AC-2 host builtin output is not pi-fff, so build returns unknown", () => {
-		// fails_when: host output gets pi-fff styling (a plausible-but-wrong row).
-		expect(parse("grep", HOST_GREP, undefined).model).toBe("unknown");
-		expect(parse("find", "src/payments.ts\ntest/payments.test.ts", undefined).model).toBe("unknown");
-	});
-
-	test("AC-3 the empty strings separate on details presence only", () => {
-		// fails_when: both render the same way.
-		const styled = narrowEmpty(parse("ffgrep", "No matches found", D0).model);
-		expect(styled.noun).toBe("matches");
-		const emptyRow = parse("ffgrep", "No matches found", D0);
-		expect(emptyRow.spec.project(styled, COLLAPSED, PAINT)).toBe(PAINT.muted("0 matches"));
-		expect(parse("ffgrep", "No matches found", undefined).model).toBe("unknown");
-
-		const files = narrowEmpty(parse("fffind", "No files found matching pattern", D0).model);
-		expect(files.noun).toBe("files");
-		expect(parse("fffind", "No files found matching pattern", undefined).model).toBe("unknown");
-	});
-
-	test("AC-4 the fuzzy prefix is a notice, never a phantom file header", () => {
-		// fails_when: a phantom header inflates the file count (the ported bug).
-		const matches = narrowMatches(parse("ffgrep", FUZZY, D1).model);
-		expect(matches.blocks).toHaveLength(1);
-		expect(matches.blocks[0]?.path).toBe("src/payments.ts");
-		expect(matches.notices).toEqual(["0 exact matches. Maybe you meant this?"]);
-	});
-
-	test("AC-5 a multi-sentence notice stays one notice", () => {
-		// fails_when: the weak-match notice fragments on its internal ". ".
-		const files = narrowFiles(parse("fffind", FIND_WEAK, { totalMatched: 30, totalFiles: 30 }).model);
-		expect(files.files).toHaveLength(2);
-		expect(files.notices).toEqual(['Query "p" produced only weak scattered fuzzy matches. Output capped at 5/30.']);
-	});
-
-	test("AC-1 (find) a pi-fff find result groups by directory with counts and annotations", () => {
-		// fails_when: entries render ungrouped, or a count or annotation is wrong.
-		const body = ["src/payments.ts", "test/payments.test.ts  [modified in git]", "src/api/payments.ts"].join("\n");
-		const { spec, model } = parse("fffind", body, { totalMatched: 3, totalFiles: 3 });
-		const files = narrowFiles(model);
-		expect(spec.project(files, COLLAPSED, PAINT)).toBe(PAINT.muted("3 files"));
-
-		const expanded = spec.project(files, EXPANDED, PAINT);
-		expect(expanded).toContain(PAINT.accent("src/"));
-		expect(expanded).toContain(PAINT.accent("src/api/"));
-		expect(expanded).toContain(PAINT.accent("test/"));
-		expect(expanded).toContain(PAINT.output("payments.test.ts"));
-		expect(expanded).toContain(PAINT.muted("[modified in git]"));
-		assertNoRealEscapes(expanded);
-	});
-});
-
-describe("renderers/tool/specs/search — AC-6 predecessor fff-format parity", () => {
-	test("find: bare path list, annotation suffix, empty string", () => {
-		expect(narrowFiles(parse("fffind", "src/payments.ts\ntest/payments.test.ts", D2).model).files).toHaveLength(2);
-		const annotated = narrowFiles(parse("fffind", "src/payments.ts  [modified in git]", D1).model);
-		expect(annotated.files[0]).toEqual({ path: "src/payments.ts", annotation: "modified in git" });
-		expect(narrowEmpty(parse("fffind", "No files found matching pattern", D0).model).noun).toBe("files");
-	});
-
-	test("grep: numbered match and context lines, file blocks, empty string", () => {
-		const body = ["src/payments.ts", " 2- export interface Payment {", " 3: route(...)", " 4- }"].join("\n");
-		const matches = narrowMatches(parse("ffgrep", body, D1).model);
-		expect(matches.matchCount).toBe(1);
-		expect(matches.blocks[0]?.lines.map((l) => [l.lineNo, l.isMatch])).toEqual([
-			[2, false],
-			[3, true],
-			[4, false],
-		]);
-		expect(narrowEmpty(parse("ffgrep", "No matches found", D0).model).noun).toBe("matches");
-	});
-
-	test("a notice trailer surfaces as one notice", () => {
-		const body = ["src/payments.ts", " 1: x", "", '[Continue with cursor="fff_c1" to continue]'].join("\n");
-		expect(narrowMatches(parse("ffgrep", body, D1).model).notices).toEqual([
-			'Continue with cursor="fff_c1" to continue',
-		]);
-	});
-});
-
-describe("renderers/tool/specs/search — name binding", () => {
-	test("SEARCH_SPECS carries exactly the four names, each buildCall titles its own name", () => {
-		expect(SEARCH_SPECS.map((record) => record.name)).toEqual(["find", "grep", "fffind", "ffgrep"]);
-		expect(SEARCH_TOOL_NAMES).toEqual(["find", "grep", "fffind", "ffgrep"]);
-		const row = testRenderContext({ args: { pattern: "x", path: "src" } });
-		for (const record of SEARCH_SPECS) {
-			expect(record.spec.buildCall(row.args ?? {}, row).title.startsWith(record.name)).toBe(true);
-		}
-		expect(new Set(SEARCH_SPECS.map((record) => record.descriptor.key))).toEqual(new Set(["row.search"]));
-	});
-
-	test("args gate: buildCall shows the name only until argsComplete", () => {
-		// fails_when: a partial argument value is rendered.
-		const row = testRenderContext({ args: {}, argsComplete: false });
-		expect(createSearchSpec("fffind").buildCall({}, row).title).toBe("fffind");
-	});
-});