@vitest-agent/reporter 5.0.9 → 6.0.1

package/README.md

@@ -11,7 +11,7 @@ The default reporter package and the reference for custom-reporter authors. Ship
 ## Features
 
 - **`DefaultVitestAgentReporter`** — the production default `VitestAgentReporterFactory` the plugin wires automatically; classifies runs into one of 12 shape × outcome cells, owns the Ink live-mount lifecycle, and emits a GitHub Actions Step Summary in CI
-- **Dispatch helpers** — `buildDispatchInputs`, `resolveCellOptions`, `renderAgentStringForReport`, `renderHumanStringForReport`
+- **Dispatch helpers** — `buildDispatchInputs`, `renderAgentStringForReport`, `renderHumanStringForReport`
 - **Contract re-exports** — `VitestAgentReporterFactory`, `ReporterKit`, `ReporterRenderInput`, `RenderedOutput`, `VitestAgentReporter`, `ResolvedReporterConfig` all re-exported from `@vitest-agent/sdk` so you only need one import
 - **Worked example** — `DefaultVitestAgentReporter` source in this package is the canonical reference for the `VitestAgentReporterFactory` contract
 

package/defaultReporter.js

@@ -1,45 +1,13 @@
-import { renderGithubLog, toDisplayPath } from "./githubLog.js";
+import { resolveFileLink } from "./fileLinks.js";
+import { summarizeProject } from "./projectSummary.js";
+import { renderGithubLog, strayOutputOf, toDisplayPath } from "./githubLog.js";
 import { LiveViewEnv, startLiveView } from "./liveView.js";
-import { Doc, Render, Status } from "@effected/cli";
-import { RUN_REPORT_FILE_SCHEMA_URL, countSuiteFailures, isTimeoutError } from "@vitest-agent/sdk";
+import { Doc, Fmt, Render, Status } from "@effected/cli";
+import { RUN_REPORT_FILE_SCHEMA_URL, formatStrayOutputNote } from "@vitest-agent/sdk";
 import { classifyOutcome, classifyRunShape, dispatch, reduceRenderStateAll, synthesizeFromAgentReport } from "@vitest-agent/ui";
+import { Effect } from "effect";
 
 // src/defaultReporter.ts
-const countTimeouts = (report) => {
-	let timeoutCount = 0;
-	for (const mod of report.failed) for (const test of mod.tests) {
-		const firstError = test.errors?.[0];
-		if (test.state === "failed" && firstError !== void 0 && isTimeoutError({ message: firstError.message })) timeoutCount++;
-	}
-	return timeoutCount;
-};
-const summarizeProject = (report) => {
-	const collapsedTagCounts = report.tagCounts !== void 0 ? collapseTagCounts(report.tagCounts) : void 0;
-	const tagCountsHasEntries = collapsedTagCounts !== void 0 && Object.keys(collapsedTagCounts).length > 0;
-	const belowTargetCount = report.coverage?.belowTargetFiles?.length;
-	const violationsCount = report.coverage !== void 0 && report.coverage.lowCoverage.length > 0 ? report.coverage.lowCoverage.length : void 0;
-	const timeoutCount = countTimeouts(report);
-	return {
-		name: report.project ?? "default",
-		passCount: report.summary.passed,
-		failCount: report.summary.failed + countSuiteFailures(report) - timeoutCount,
-		skipCount: report.summary.skipped,
-		durationMs: report.summary.duration,
-		...timeoutCount > 0 ? { timeoutCount } : {},
-		...tagCountsHasEntries && collapsedTagCounts !== void 0 ? { tagCounts: collapsedTagCounts } : {},
-		...belowTargetCount !== void 0 ? { belowTarget: belowTargetCount } : {},
-		...violationsCount !== void 0 ? { violations: violationsCount } : {}
-	};
-};
-const collapseTagCounts = (entries) => {
-	const out = {};
-	if (entries === void 0) return out;
-	for (const [tag, entry] of Object.entries(entries)) {
-		const total = (entry.passed ?? 0) + (entry.failed ?? 0) + (entry.skipped ?? 0);
-		if (total > 0) out[tag] = total;
-	}
-	return out;
-};
 const collectBelowTarget = (reports) => {
 	const out = [];
 	for (const r of reports) {
@@ -78,28 +46,20 @@ const buildDispatchInputs = (state, input, overrides = {}) => {
 		runCommand: overrides.runCommand ?? null
 	};
 };
-/**
-* Build `CellOptions` from a {@link ReporterKit}. Picks the kit's
-* resolved `noColor` value and the pre-bound OSC-8 hyperlink helper.
-*
-* @public
-*/
-const resolveCellOptions = (kit) => ({
-	noColor: kit.config.noColor,
-	osc8: kit.stdOsc8
-});
 const shouldRenderForMode = (mode) => mode === "agent";
+const synthesizeOptionsFrom = (options) => ({ ...options.suggestedActions !== void 0 ? { suggestedActions: options.suggestedActions } : {} });
 /**
 * Convenience helper for one-shot consumers (e.g. a CLI command
 * replaying a stored run). Synthesizes a minimal `ReporterRenderInput`
 * from a single `AgentReport`, classifies the shape and outcome, and
 * returns the dispatched agent-string for the matching cell. Equivalent
-* to the pre-2.0 `renderRun(events, "agent")` shortcut.
+* to the pre-2.0 `renderRun(events, "agent")` shortcut. Pass
+* `options.suggestedActions` to append the run's `Actions:` list.
 *
 * @public
 */
-const renderAgentStringForReport = (report) => {
-	const events = synthesizeFromAgentReport(report);
+const renderAgentStringForReport = (report, options = {}) => {
+	const events = synthesizeFromAgentReport(report, synthesizeOptionsFrom(options));
 	const state = reduceRenderStateAll(events);
 	const projects = [summarizeProject(report)];
 	const inputs = {
@@ -111,10 +71,7 @@ const renderAgentStringForReport = (report) => {
 		belowTarget: collectBelowTarget([report]),
 		runCommand: null
 	};
-	return dispatch(inputs, {
-		noColor: true,
-		osc8: (_url, label) => label
-	});
+	return dispatch(inputs, {});
 };
 /**
 * Same as {@link renderAgentStringForReport} but returns the Ink-half
@@ -140,7 +97,7 @@ const renderHumanStringForReport = (report, options = {}) => renderHumanString(r
 * @internal
 */
 const renderHumanString = async (report, options, env) => {
-	const events = synthesizeFromAgentReport(report);
+	const events = synthesizeFromAgentReport(report, synthesizeOptionsFrom(options));
 	const state = reduceRenderStateAll(events);
 	const projects = [summarizeProject(report)];
 	const inputs = {
@@ -152,12 +109,11 @@ const renderHumanString = async (report, options, env) => {
 		belowTarget: collectBelowTarget([report]),
 		runCommand: null
 	};
-	const opts = {
-		noColor: false,
-		osc8: (_url, label) => label
-	};
 	const { renderInkReport } = await import("./humanReport.js");
-	return await renderInkReport(inputs, opts, env, options.width) ?? dispatch(inputs, opts);
+	const rendered = await renderInkReport(inputs, env, options.width);
+	if (rendered !== null) return rendered;
+	const link = await Effect.runPromise(resolveFileLink.pipe(Effect.provide(env)));
+	return dispatch(inputs, { link });
 };
 const NON_STABLE_SUMMARY_CLASSIFICATIONS = [
 	"new-failure",
@@ -166,6 +122,8 @@ const NON_STABLE_SUMMARY_CLASSIFICATIONS = [
 	"recovered"
 ];
 const MAX_SUMMARY_COVERAGE_ROWS = 10;
+/** Sample lines shown in the step summary's stray-output section; the same cap the human note uses. */
+const MAX_SUMMARY_STRAY_SAMPLES = 3;
 /**
 * The step summary and `summary.md` are files, not log lines, so their
 * markdown context opts out of the `ci` default that neutralizes workflow
@@ -212,6 +170,42 @@ const renderTrendSection = (trendSummary) => {
 	return Render.markdown([Doc.heading(3, "Trend"), Doc.lines(lines)], summaryRenderContext);
 };
 /**
+* Split a plain-text note on its backtick spans into inlines, so a span the
+* shared formatter wrote as `` `x` `` renders as a code span in markdown
+* rather than as the sanitizer's escaped literal backticks. An unmatched
+* trailing backtick is kept as text.
+*/
+const inlineWithCodeSpans = (text) => {
+	const parts = text.split("`");
+	const inlines = [];
+	parts.forEach((part, index) => {
+		if (part.length === 0) return;
+		const insideSpan = index % 2 === 1 && index < parts.length - 1;
+		inlines.push(insideSpan ? Doc.code(part) : Doc.text(part));
+	});
+	return inlines;
+};
+/**
+* What the run wrote straight to the terminal, past Vitest's console capture
+* (issue #578): the same headline the human and agent notes print, the byte
+* count, then the sample lines as code spans (a sample is untrusted text, so
+* it is never read as markdown). `null` when the run wrote nothing stray.
+*/
+const renderStrayOutputSection = (reports) => {
+	const stray = strayOutputOf(reports);
+	if (stray === void 0) return null;
+	const [headline = ""] = formatStrayOutputNote(stray);
+	const shown = stray.samples.slice(0, MAX_SUMMARY_STRAY_SAMPLES);
+	const lines = shown.map((sample) => [Doc.text(`${sample.stream}: `), Doc.code(sample.text)]);
+	const more = stray.total - shown.length;
+	if (more > 0 && shown.length > 0) lines.push([Doc.text(`(+${more} more)`)]);
+	return Render.markdown([
+		Doc.heading(3, "Stray output"),
+		Doc.paragraph(...inlineWithCodeSpans(`${headline} ${Fmt.plural(stray.bytes, "byte")} recorded.`)),
+		...lines.length > 0 ? [Doc.lines(lines)] : []
+	], summaryRenderContext);
+};
+/**
 * Per-project pass/fail/timeout/skip/duration table — the unconditional
 * half of the summary body.
 *
@@ -265,7 +259,7 @@ const renderTotalsSection = (reports) => {
 * Assemble the vitest-agent markdown body shared by the GitHub step
 * summary and the `summary.md` report file: a `## vitest-agent` heading,
 * the always-present per-project totals table, then whichever of the
-* classification, coverage, and trend sections have content.
+* classification, coverage, trend, and stray-output sections have content.
 *
 * Always returns markdown. An all-green run still gets a body — with
 * Vitest's own job summary disabled, returning `null` here left the step
@@ -278,7 +272,8 @@ const buildSummaryMarkdown = (input) => {
 	const sections = [
 		renderClassificationsSection(input.classifications),
 		renderCoverageSection(input.reports),
-		renderTrendSection(input.trendSummary)
+		renderTrendSection(input.trendSummary),
+		renderStrayOutputSection(input.reports)
 	].filter((section) => section !== null);
 	return [
 		"## vitest-agent",
@@ -341,11 +336,10 @@ const DefaultVitestAgentReporter = (kit) => {
 		render(input, renderKit) {
 			const out = [];
 			if (shouldRenderForMode(renderKit.config.consoleMode)) {
-				const events = input.reports.flatMap((r) => synthesizeFromAgentReport(r));
+				const events = input.reports.flatMap((r) => synthesizeFromAgentReport(r, { ...input.suggestedActions !== void 0 ? { suggestedActions: input.suggestedActions } : {} }));
 				const state = reduceRenderStateAll(events);
 				const inputs = buildDispatchInputs(state, input, { runCommand: renderKit.config.runCommand ?? null });
-				const opts = resolveCellOptions(renderKit);
-				const content = dispatch(inputs, opts);
+				const content = dispatch(inputs, {});
 				if (content.length > 0) out.push({
 					target: "stdout",
 					content,
@@ -378,4 +372,4 @@ const DefaultVitestAgentReporter = (kit) => {
 	};
 };
 
-export { DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForReport, renderHumanString, renderHumanStringForReport, resolveCellOptions };
+export { DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForReport, renderHumanString, renderHumanStringForReport };

package/fileLinks.js

@@ -0,0 +1,43 @@
+import { CliLinks } from "@effected/cli";
+import { Effect, Option } from "effect";
+import { Audience, TerminalEnv } from "@effected/env";
+
+// src/fileLinks.ts
+/**
+* The file-link writer the reporter's human renders draw paths through
+* (issue #541): `@effected/cli`'s `CliLinks.linker` over the services the
+* reporter's environment carries.
+*
+* The kit decides everything about a link. `CliLinks` picks where a file
+* opens (`vscode://file/<path>:<line>:<col>` when `TERM_PROGRAM` is VS Code
+* or a `.vscode/` directory sits at the project root, `file://` otherwise,
+* or nothing under `editorLinks: "off"`); `TerminalEnv` says whether stdout
+* renders OSC 8 at all (a pipe, tmux, GNU screen, `NO_COLOR` and
+* `NO_HYPERLINK` all say no); and the `Audience` rule keeps every escape
+* away from an agent. The writer is pure, so it is resolved once and handed
+* to the cells (`CellOptions.link`) and to the Ink tree (`FileLinkProvider`).
+*
+* @internal
+*/
+/** The writer an agent, a pipe or an environment without the kit's services gets: the label alone. */
+const plainFileLink = (_target, label) => label;
+/**
+* Resolve the writer from the environment, when it carries the kit's
+* `CliLinks`, `TerminalEnv` and `Audience`; the label alone when any is
+* missing (a test environment fixed to a theme only, say). It never fails
+* and never requires: a reporter rendering without `CliEnv` keeps working,
+* it just writes no link.
+*/
+const resolveFileLink = Effect.gen(function* () {
+	const links = yield* Effect.serviceOption(CliLinks);
+	const terminal = yield* Effect.serviceOption(TerminalEnv);
+	const audience = yield* Effect.serviceOption(Audience);
+	if (Option.isNone(links) || Option.isNone(terminal) || Option.isNone(audience)) return plainFileLink;
+	return CliLinks.linker({
+		links: links.value,
+		hyperlinks: terminal.value.stdout.hyperlinks,
+		audience: audience.value.kind
+	});
+});
+
+export { plainFileLink, resolveFileLink };

package/githubLog.js

@@ -1,4 +1,6 @@
-import { Doc, Render, Status } from "@effected/cli";
+import { summarizeProject } from "./projectSummary.js";
+import { Doc, Fmt, Render, Status } from "@effected/cli";
+import { formatStrayOutputNote } from "@vitest-agent/sdk";
 import { relative } from "node:path";
 
 // src/githubLog.ts
@@ -17,14 +19,21 @@ import { relative } from "node:path";
 * `::group::`) and rendered with `Render.githubLog`, which also neutralizes
 * any workflow command a project name or path could otherwise inject.
 *
-* Known inconsistency, kept deliberately for now: the per-project line counts
-* a timed-out test as `failed` (it reads `report.summary.failed`), while the
-* step-summary totals table splits timeouts into their own column.
+* The per-project counts come from `summarizeProject`, the same projection
+* the step-summary totals table renders, so a timed-out test reads
+* `timed out` here as it does there instead of folding into `failed`.
 *
 * @internal
 */
 const MAX_NAMED_FILES = 3;
 /**
+* The run's stray output. It is a run-level signal (the bytes arrive on one
+* stream shared by every project), so every project report of a run carries
+* the same value and the first one found is the run's; `undefined` when the
+* run wrote nothing past Vitest's console capture.
+*/
+const strayOutputOf = (reports) => reports.find((report) => report.strayOutput !== void 0)?.strayOutput;
+/**
 * Renders a coverage-target file path relative to `process.cwd()` for
 * display. Falls back to the original string unchanged when the relative
 * path is empty or escapes the root (starts with `..`) rather than
@@ -41,30 +50,39 @@ const NON_STABLE_CLASSIFICATIONS = [
 	"flaky",
 	"recovered"
 ];
-/** `<project>: <passed>/<total> passed, <failed> failed, <skipped> skipped` — every counter shown, zeros included. */
+/**
+* `<project>: <passed>/<total> passed, <failed> failed, <timed out> timed out, <skipped> skipped` — every counter
+* shown, zeros included, read from the same `ProjectSummary` the totals table renders.
+*/
 const projectCounts = (report) => {
-	const { passed, failed, skipped, total } = report.summary;
+	const { passCount, failCount, skipCount, timeoutCount = 0 } = summarizeProject(report);
 	return Doc.counts({
 		label: report.project ?? "default",
 		layout: "inline",
-		total: () => total,
+		total: () => report.summary.total,
 		counters: [
 			Doc.counter(Status.core, "success", {
 				key: "passed",
 				label: "passed",
-				n: passed,
+				n: passCount,
 				showZero: true
 			}),
 			Doc.counter(Status.core, "failure", {
 				key: "failed",
 				label: "failed",
-				n: failed,
+				n: failCount,
+				showZero: true
+			}),
+			Doc.counter(Status.core, "warning", {
+				key: "timedOut",
+				label: "timed out",
+				n: timeoutCount,
 				showZero: true
 			}),
 			Doc.counter(Status.core, "skip", {
 				key: "skipped",
 				label: "skipped",
-				n: skipped,
+				n: skipCount,
 				showZero: true
 			})
 		]
@@ -82,6 +100,12 @@ function renderGithubLog(input, kit) {
 	for (const classification of input.classifications.values()) classificationCounts.set(classification, (classificationCounts.get(classification) ?? 0) + 1);
 	const classificationParts = NON_STABLE_CLASSIFICATIONS.filter((kind) => (classificationCounts.get(kind) ?? 0) > 0).map((kind) => `${kind}: ${classificationCounts.get(kind)}`);
 	if (classificationParts.length > 0) body.push(Doc.paragraph(`classifications: ${classificationParts.join(", ")}`));
+	const stray = strayOutputOf(input.reports);
+	if (stray !== void 0) {
+		const [headline, ...samples] = formatStrayOutputNote(stray);
+		body.push(Doc.paragraph(`${headline} ${Fmt.plural(stray.bytes, "byte")} recorded.`));
+		if (samples.length > 0) body.push(Doc.verbatim(samples.join("\n")));
+	}
 	if (kit.config.dbPath !== void 0) body.push(Doc.paragraph(`db: ${kit.config.dbPath}`));
 	const ctx = Render.contextOf({
 		audience: "ci",
@@ -94,4 +118,4 @@ function renderGithubLog(input, kit) {
 	};
 }
 
-export { renderGithubLog, toDisplayPath };
+export { renderGithubLog, strayOutputOf, toDisplayPath };

package/humanReport.js

@@ -1,7 +1,8 @@
-import { CliUi, UiProvider } from "@effected/cli/ui";
+import { resolveFileLink } from "./fileLinks.js";
 import { Effect } from "effect";
 import { TerminalEnv } from "@effected/env";
-import { dispatchInk } from "@vitest-agent/ui/ink";
+import { CliUi, UiProvider } from "@effected/cli/ui";
+import { FileLinkProvider, dispatchInk } from "@vitest-agent/ui/ink";
 import { renderToString } from "ink";
 import { createElement } from "react";
 
@@ -14,22 +15,26 @@ const FALLBACK_COLUMNS = 80;
 *
 * The layout width is `width` when given, else the terminal's
 * (`TerminalEnv.width`: stdout's columns, else `COLUMNS`, else 80 — so a
-* non-TTY run lays out at 80).
+* non-TTY run lays out at 80). File paths are drawn through the link writer
+* the environment decides (`resolveFileLink`): the cell's own string gets it
+* as `CellOptions.link`, and the tree through `FileLinkProvider`.
 *
 * @internal
 */
-const renderInkReport = async (inputs, opts, env, width) => {
-	const element = dispatchInk(inputs, opts);
-	if (element === null) return null;
-	const { context, columns } = await Effect.runPromise(Effect.gen(function* () {
+const renderInkReport = async (inputs, env, width) => {
+	const { context, columns, link } = await Effect.runPromise(Effect.gen(function* () {
 		const context = yield* CliUi.context;
 		const terminal = yield* TerminalEnv;
+		const link = yield* resolveFileLink;
 		return {
 			context,
-			columns: width ?? terminal.width(FALLBACK_COLUMNS)
+			columns: width ?? terminal.width(FALLBACK_COLUMNS),
+			link
 		};
 	}).pipe(Effect.provide(env)));
-	return renderToString(createElement(UiProvider, { value: context }, element), { columns });
+	const element = dispatchInk(inputs, { link });
+	if (element === null) return null;
+	return renderToString(createElement(UiProvider, { value: context }, createElement(FileLinkProvider, { link }, element)), { columns });
 };
 
 export { renderInkReport };

package/index.d.ts

@@ -8,15 +8,27 @@ import "@effected/env";
 declare const FileCoverageReport: Schema.Struct<{
   readonly file: Schema.String;
   readonly summary: Schema.Struct<{
-    readonly statements: Schema.Number;
-    readonly branches: Schema.Number;
-    readonly functions: Schema.Number;
-    readonly lines: Schema.Number;
+    readonly statements: Schema.Finite;
+    readonly branches: Schema.Finite;
+    readonly functions: Schema.Finite;
+    readonly lines: Schema.Finite;
   }>;
   readonly uncoveredLines: Schema.String;
 }>;
 /** @public */
 type FileCoverageReport = typeof FileCoverageReport.Type;
+/**
+ * A `SuggestedAction` event, denormalized into the queue the renderer reads.
+ * @public
+ */
+declare const SuggestedActionRecord: Schema.Struct<{
+  readonly severity: Schema.Literals<readonly ["info", "warn", "blocker"]>;
+  readonly title: Schema.String;
+  readonly detail: Schema.String;
+  readonly targetTool: Schema.optional<Schema.String>;
+}>;
+/** @public */
+type SuggestedActionRecord = typeof SuggestedActionRecord.Type;
 /**
  * The renderer state. Both the human (Ink) and agent (string)
  * renderers read this shape; the reducer is the only producer.
@@ -80,24 +92,24 @@ declare const RenderState: Schema.Struct<{
   }>;
   readonly coverage: Schema.NullOr<Schema.Struct<{
     readonly metrics: Schema.Struct<{
-      readonly statements: Schema.Number;
-      readonly branches: Schema.Number;
-      readonly functions: Schema.Number;
-      readonly lines: Schema.Number;
+      readonly statements: Schema.Finite;
+      readonly branches: Schema.Finite;
+      readonly functions: Schema.Finite;
+      readonly lines: Schema.Finite;
     }>;
     readonly thresholds: Schema.Struct<{
-      readonly lines: Schema.optional<Schema.Number>;
-      readonly functions: Schema.optional<Schema.Number>;
-      readonly branches: Schema.optional<Schema.Number>;
-      readonly statements: Schema.optional<Schema.Number>;
+      readonly lines: Schema.optional<Schema.Finite>;
+      readonly functions: Schema.optional<Schema.Finite>;
+      readonly branches: Schema.optional<Schema.Finite>;
+      readonly statements: Schema.optional<Schema.Finite>;
     }>;
     readonly gaps: Schema.$Array<Schema.Struct<{
       readonly file: Schema.String;
       readonly missing: Schema.Struct<{
-        readonly statements: Schema.Number;
-        readonly branches: Schema.Number;
-        readonly functions: Schema.Number;
-        readonly lines: Schema.Number;
+        readonly statements: Schema.Finite;
+        readonly branches: Schema.Finite;
+        readonly functions: Schema.Finite;
+        readonly lines: Schema.Finite;
       }>;
       readonly uncoveredLines: Schema.optional<Schema.String>;
     }>>;
@@ -112,16 +124,16 @@ declare const RenderState: Schema.Struct<{
     readonly globShortfalls: Schema.optional<Schema.$Array<Schema.Struct<{
       readonly pattern: Schema.String;
       readonly summary: Schema.Struct<{
-        readonly statements: Schema.Number;
-        readonly branches: Schema.Number;
-        readonly functions: Schema.Number;
-        readonly lines: Schema.Number;
+        readonly statements: Schema.Finite;
+        readonly branches: Schema.Finite;
+        readonly functions: Schema.Finite;
+        readonly lines: Schema.Finite;
       }>;
       readonly thresholds: Schema.Struct<{
-        readonly lines: Schema.optional<Schema.Number>;
-        readonly functions: Schema.optional<Schema.Number>;
-        readonly branches: Schema.optional<Schema.Number>;
-        readonly statements: Schema.optional<Schema.Number>;
+        readonly lines: Schema.optional<Schema.Finite>;
+        readonly functions: Schema.optional<Schema.Finite>;
+        readonly branches: Schema.optional<Schema.Finite>;
+        readonly statements: Schema.optional<Schema.Finite>;
       }>;
     }>>>;
   }>>;
@@ -178,15 +190,35 @@ declare const RenderState: Schema.Struct<{
    * wrote nothing stray.
    */
   readonly strayOutput: Schema.optional<Schema.Struct<{
-    readonly total: Schema.Number;
-    readonly stdout: Schema.Number;
-    readonly stderr: Schema.Number;
-    readonly bytes: Schema.Number;
+    readonly total: Schema.Finite;
+    readonly stdout: Schema.Finite;
+    readonly stderr: Schema.Finite;
+    readonly bytes: Schema.Finite;
     readonly samples: Schema.$Array<Schema.Struct<{
       readonly stream: Schema.Literals<readonly ["stdout", "stderr"]>;
       readonly text: Schema.String;
     }>>;
   }>>;
+  /**
+   * `console.*` output Vitest captured from tests that did not fail, folded
+   * from `RunFinished.consoleLeaks`. Absent when the run logged nothing
+   * (issue #544).
+   */
+  readonly consoleLeaks: Schema.optional<Schema.Struct<{
+    readonly total: Schema.Finite;
+    readonly byFile: Schema.$Array<Schema.Struct<{
+      readonly file: Schema.String;
+      readonly stdout: Schema.Finite;
+      readonly stderr: Schema.Finite;
+      readonly tests: Schema.optional<Schema.$Array<Schema.String>>;
+      readonly sample: Schema.optional<Schema.String>;
+    }>>;
+    readonly truncated: Schema.optional<Schema.Boolean>;
+    readonly fromFailingTests: Schema.optional<Schema.Struct<{
+      readonly total: Schema.Finite;
+      readonly files: Schema.Finite;
+    }>>;
+  }>>;
 }>;
 /** @public */
 type RenderState = typeof RenderState.Type;
@@ -289,27 +321,41 @@ interface DispatchInputs {
   readonly runCommand: string | null;
 }
 /**
- * Render-time options threaded into each cell from the resolved
- * `ReporterKit`. These are concerns the cell needs to format its
- * output but that do not belong on the state-derived
- * {@link DispatchInputs} struct.
+ * Where a file link points: a path, with an optional line and column.
  *
- * The plugin builds this once per run from the kit and passes it into
+ * The file half of `@effected/cli`'s `LinkTarget`, spelled structurally so
+ * this platform-free contract names no kit type. A relative path resolves
+ * against the working directory the kit's `CliLinks` layer was built with.
+ * @public
+ */
+interface FileLinkTarget {
+  readonly file: string;
+  readonly line?: number;
+  readonly col?: number;
+}
+/**
+ * Render-time options threaded into each cell. These are concerns the
+ * cell needs to format its output but that do not belong on the
+ * state-derived {@link DispatchInputs} struct.
+ *
+ * The caller builds this once per render and passes it into
  * `dispatch(inputs, opts)`. Cells destructure only what they consume.
  * @public
  */
 interface CellOptions {
   /**
-   * Resolved value of the `NO_COLOR` env var. Cells gate ANSI escape
-   * sequences and OSC-8 hyperlinks on this.
-   */
-  readonly noColor: boolean;
-  /**
-   * Pre-bound OSC-8 hyperlink helper. The plugin has already decided
-   * whether OSC-8 should be enabled (`target=stdout`, `!noColor`) so
-   * cells can call this directly without re-consulting the environment.
+   * Writes a file path as a link for the audience and terminal the output
+   * is for: the label wrapped in an OSC 8 hyperlink when the reader can
+   * follow it, the label unchanged otherwise. The kit decides both halves
+   * (`@effected/cli`'s `CliLinks.linker`, `Render.context("stdout").link`):
+   * `vscode://file/<path>:<line>:<col>` under VS Code, `file://` otherwise,
+   * never for an agent audience, and nothing on a terminal that cannot
+   * render hyperlinks (a pipe, tmux, GNU screen, `NO_COLOR`).
+   *
+   * Omitted, every path is its label alone, which is what an agent reads;
+   * a cell therefore never writes an escape sequence of its own.
    */
-  readonly osc8: (url: string, label: string) => string;
+  readonly link?: (target: FileLinkTarget, label: string) => string;
 }
 /**
  * One unit of rendered reporter output, tagged by where it goes.
@@ -343,11 +389,11 @@ declare const AgentReport: Schema.Struct<{
   readonly project: Schema.optional<Schema.String>;
   readonly reason: Schema.Literals<readonly ["passed", "failed", "interrupted"]>;
   readonly summary: Schema.Struct<{
-    readonly total: Schema.Number;
-    readonly passed: Schema.Number;
-    readonly failed: Schema.Number;
-    readonly skipped: Schema.Number;
-    readonly duration: Schema.Number;
+    readonly total: Schema.Finite;
+    readonly passed: Schema.Finite;
+    readonly failed: Schema.Finite;
+    readonly skipped: Schema.Finite;
+    readonly duration: Schema.Finite;
     /**
      * Count of every collected module, passing modules included.
      * `AgentReport.failed` only carries failing modules, so a green run
@@ -355,12 +401,12 @@ declare const AgentReport: Schema.Struct<{
      * this a fully-passing replay reads as "0 modules all-passed"
      * (issue #204). Optional to keep existing fixtures/reports valid.
      */
-    readonly modules: Schema.optional<Schema.Number>;
+    readonly modules: Schema.optional<Schema.Finite>;
   }>;
   readonly failed: Schema.$Array<Schema.Struct<{
     readonly file: Schema.String;
     readonly state: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
-    readonly duration: Schema.optional<Schema.Number>;
+    readonly duration: Schema.optional<Schema.Finite>;
     readonly errors: Schema.optional<Schema.$Array<Schema.Struct<{
       readonly message: Schema.String;
       readonly stack: Schema.optional<Schema.String>;
@@ -372,7 +418,7 @@ declare const AgentReport: Schema.Struct<{
       readonly name: Schema.String;
       readonly fullName: Schema.String;
       readonly state: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
-      readonly duration: Schema.optional<Schema.Number>;
+      readonly duration: Schema.optional<Schema.Finite>;
       readonly flaky: Schema.optional<Schema.Boolean>;
       readonly slow: Schema.optional<Schema.Boolean>;
       readonly errors: Schema.optional<Schema.$Array<Schema.Struct<{
@@ -395,81 +441,81 @@ declare const AgentReport: Schema.Struct<{
   readonly failedFiles: Schema.$Array<Schema.String>;
   readonly coverage: Schema.optional<Schema.Struct<{
     readonly totals: Schema.Struct<{
-      readonly statements: Schema.Number;
-      readonly branches: Schema.Number;
-      readonly functions: Schema.Number;
-      readonly lines: Schema.Number;
+      readonly statements: Schema.Finite;
+      readonly branches: Schema.Finite;
+      readonly functions: Schema.Finite;
+      readonly lines: Schema.Finite;
     }>;
     readonly thresholds: Schema.Struct<{
       readonly global: Schema.Struct<{
-        readonly lines: Schema.optional<Schema.Number>;
-        readonly functions: Schema.optional<Schema.Number>;
-        readonly branches: Schema.optional<Schema.Number>;
-        readonly statements: Schema.optional<Schema.Number>;
+        readonly lines: Schema.optional<Schema.Finite>;
+        readonly functions: Schema.optional<Schema.Finite>;
+        readonly branches: Schema.optional<Schema.Finite>;
+        readonly statements: Schema.optional<Schema.Finite>;
       }>;
       readonly patterns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Struct<{
-        readonly lines: Schema.optional<Schema.Number>;
-        readonly functions: Schema.optional<Schema.Number>;
-        readonly branches: Schema.optional<Schema.Number>;
-        readonly statements: Schema.optional<Schema.Number>;
+        readonly lines: Schema.optional<Schema.Finite>;
+        readonly functions: Schema.optional<Schema.Finite>;
+        readonly branches: Schema.optional<Schema.Finite>;
+        readonly statements: Schema.optional<Schema.Finite>;
         readonly perFile: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Struct<{
-          readonly lines: Schema.optional<Schema.Number>;
-          readonly functions: Schema.optional<Schema.Number>;
-          readonly branches: Schema.optional<Schema.Number>;
-          readonly statements: Schema.optional<Schema.Number>;
+          readonly lines: Schema.optional<Schema.Finite>;
+          readonly functions: Schema.optional<Schema.Finite>;
+          readonly branches: Schema.optional<Schema.Finite>;
+          readonly statements: Schema.optional<Schema.Finite>;
         }>]>>;
       }>]>>, never>;
     }>;
     readonly targets: Schema.optional<Schema.Struct<{
       readonly global: Schema.Struct<{
-        readonly lines: Schema.optional<Schema.Number>;
-        readonly functions: Schema.optional<Schema.Number>;
-        readonly branches: Schema.optional<Schema.Number>;
-        readonly statements: Schema.optional<Schema.Number>;
+        readonly lines: Schema.optional<Schema.Finite>;
+        readonly functions: Schema.optional<Schema.Finite>;
+        readonly branches: Schema.optional<Schema.Finite>;
+        readonly statements: Schema.optional<Schema.Finite>;
       }>;
       readonly patterns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Struct<{
-        readonly lines: Schema.optional<Schema.Number>;
-        readonly functions: Schema.optional<Schema.Number>;
-        readonly branches: Schema.optional<Schema.Number>;
-        readonly statements: Schema.optional<Schema.Number>;
+        readonly lines: Schema.optional<Schema.Finite>;
+        readonly functions: Schema.optional<Schema.Finite>;
+        readonly branches: Schema.optional<Schema.Finite>;
+        readonly statements: Schema.optional<Schema.Finite>;
         readonly perFile: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Struct<{
-          readonly lines: Schema.optional<Schema.Number>;
-          readonly functions: Schema.optional<Schema.Number>;
-          readonly branches: Schema.optional<Schema.Number>;
-          readonly statements: Schema.optional<Schema.Number>;
+          readonly lines: Schema.optional<Schema.Finite>;
+          readonly functions: Schema.optional<Schema.Finite>;
+          readonly branches: Schema.optional<Schema.Finite>;
+          readonly statements: Schema.optional<Schema.Finite>;
         }>]>>;
       }>]>>, never>;
     }>>;
     readonly baselines: Schema.optional<Schema.Struct<{
       readonly global: Schema.Struct<{
-        readonly lines: Schema.optional<Schema.Number>;
-        readonly functions: Schema.optional<Schema.Number>;
-        readonly branches: Schema.optional<Schema.Number>;
-        readonly statements: Schema.optional<Schema.Number>;
+        readonly lines: Schema.optional<Schema.Finite>;
+        readonly functions: Schema.optional<Schema.Finite>;
+        readonly branches: Schema.optional<Schema.Finite>;
+        readonly statements: Schema.optional<Schema.Finite>;
       }>;
       readonly patterns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Struct<{
-        readonly lines: Schema.optional<Schema.Number>;
-        readonly functions: Schema.optional<Schema.Number>;
-        readonly branches: Schema.optional<Schema.Number>;
-        readonly statements: Schema.optional<Schema.Number>;
+        readonly lines: Schema.optional<Schema.Finite>;
+        readonly functions: Schema.optional<Schema.Finite>;
+        readonly branches: Schema.optional<Schema.Finite>;
+        readonly statements: Schema.optional<Schema.Finite>;
         readonly perFile: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Struct<{
-          readonly lines: Schema.optional<Schema.Number>;
-          readonly functions: Schema.optional<Schema.Number>;
-          readonly branches: Schema.optional<Schema.Number>;
-          readonly statements: Schema.optional<Schema.Number>;
+          readonly lines: Schema.optional<Schema.Finite>;
+          readonly functions: Schema.optional<Schema.Finite>;
+          readonly branches: Schema.optional<Schema.Finite>;
+          readonly statements: Schema.optional<Schema.Finite>;
         }>]>>;
       }>]>>, never>;
     }>>;
     readonly scoped: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
     readonly scopedFiles: Schema.optional<Schema.$Array<Schema.String>>;
-    readonly totalFiles: Schema.optional<Schema.Number>;
+    readonly totalFiles: Schema.optional<Schema.Finite>;
     readonly lowCoverage: Schema.$Array<Schema.Struct<{
       readonly file: Schema.String;
       readonly summary: Schema.Struct<{
-        readonly statements: Schema.Number;
-        readonly branches: Schema.Number;
-        readonly functions: Schema.Number;
-        readonly lines: Schema.Number;
+        readonly statements: Schema.Finite;
+        readonly branches: Schema.Finite;
+        readonly functions: Schema.Finite;
+        readonly lines: Schema.Finite;
       }>;
       readonly uncoveredLines: Schema.String;
     }>>;
@@ -477,10 +523,10 @@ declare const AgentReport: Schema.Struct<{
     readonly belowTarget: Schema.optional<Schema.$Array<Schema.Struct<{
       readonly file: Schema.String;
       readonly summary: Schema.Struct<{
-        readonly statements: Schema.Number;
-        readonly branches: Schema.Number;
-        readonly functions: Schema.Number;
-        readonly lines: Schema.Number;
+        readonly statements: Schema.Finite;
+        readonly branches: Schema.Finite;
+        readonly functions: Schema.Finite;
+        readonly lines: Schema.Finite;
       }>;
       readonly uncoveredLines: Schema.String;
     }>>>;
@@ -488,44 +534,44 @@ declare const AgentReport: Schema.Struct<{
     readonly globShortfalls: Schema.optional<Schema.$Array<Schema.Struct<{
       readonly pattern: Schema.String;
       readonly summary: Schema.Struct<{
-        readonly statements: Schema.Number;
-        readonly branches: Schema.Number;
-        readonly functions: Schema.Number;
-        readonly lines: Schema.Number;
+        readonly statements: Schema.Finite;
+        readonly branches: Schema.Finite;
+        readonly functions: Schema.Finite;
+        readonly lines: Schema.Finite;
       }>;
       readonly thresholds: Schema.Struct<{
-        readonly lines: Schema.optional<Schema.Number>;
-        readonly functions: Schema.optional<Schema.Number>;
-        readonly branches: Schema.optional<Schema.Number>;
-        readonly statements: Schema.optional<Schema.Number>;
+        readonly lines: Schema.optional<Schema.Finite>;
+        readonly functions: Schema.optional<Schema.Finite>;
+        readonly branches: Schema.optional<Schema.Finite>;
+        readonly statements: Schema.optional<Schema.Finite>;
       }>;
     }>>>;
   }>>;
   readonly tagCounts: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
-    readonly passed: Schema.optional<Schema.Number>;
-    readonly failed: Schema.optional<Schema.Number>;
-    readonly skipped: Schema.optional<Schema.Number>;
+    readonly passed: Schema.optional<Schema.Finite>;
+    readonly failed: Schema.optional<Schema.Finite>;
+    readonly skipped: Schema.optional<Schema.Finite>;
   }>>>;
   readonly consoleLeaks: Schema.optional<Schema.Struct<{
-    readonly total: Schema.Number;
+    readonly total: Schema.Finite;
     readonly byFile: Schema.$Array<Schema.Struct<{
       readonly file: Schema.String;
-      readonly stdout: Schema.Number;
-      readonly stderr: Schema.Number;
+      readonly stdout: Schema.Finite;
+      readonly stderr: Schema.Finite;
       readonly tests: Schema.optional<Schema.$Array<Schema.String>>;
       readonly sample: Schema.optional<Schema.String>;
     }>>;
     readonly truncated: Schema.optional<Schema.Boolean>;
     readonly fromFailingTests: Schema.optional<Schema.Struct<{
-      readonly total: Schema.Number;
-      readonly files: Schema.Number;
+      readonly total: Schema.Finite;
+      readonly files: Schema.Finite;
     }>>;
   }>>;
   readonly strayOutput: Schema.optional<Schema.Struct<{
-    readonly total: Schema.Number;
-    readonly stdout: Schema.Number;
-    readonly stderr: Schema.Number;
-    readonly bytes: Schema.Number;
+    readonly total: Schema.Finite;
+    readonly stdout: Schema.Finite;
+    readonly stderr: Schema.Finite;
+    readonly bytes: Schema.Finite;
     readonly samples: Schema.$Array<Schema.Struct<{
       readonly stream: Schema.Literals<readonly ["stdout", "stderr"]>;
       readonly text: Schema.String;
@@ -701,24 +747,24 @@ declare const RunEvent: Schema.Union<readonly [Schema.TaggedStruct<"RunStarted",
   readonly runCount: Schema.Number;
 }>, Schema.TaggedStruct<"CoverageReady", {
   readonly metrics: Schema.Struct<{
-    readonly statements: Schema.Number;
-    readonly branches: Schema.Number;
-    readonly functions: Schema.Number;
-    readonly lines: Schema.Number;
+    readonly statements: Schema.Finite;
+    readonly branches: Schema.Finite;
+    readonly functions: Schema.Finite;
+    readonly lines: Schema.Finite;
   }>;
   readonly thresholds: Schema.Struct<{
-    readonly lines: Schema.optional<Schema.Number>;
-    readonly functions: Schema.optional<Schema.Number>;
-    readonly branches: Schema.optional<Schema.Number>;
-    readonly statements: Schema.optional<Schema.Number>;
+    readonly lines: Schema.optional<Schema.Finite>;
+    readonly functions: Schema.optional<Schema.Finite>;
+    readonly branches: Schema.optional<Schema.Finite>;
+    readonly statements: Schema.optional<Schema.Finite>;
   }>;
   readonly gaps: Schema.$Array<Schema.Struct<{
     readonly file: Schema.String;
     readonly missing: Schema.Struct<{
-      readonly statements: Schema.Number;
-      readonly branches: Schema.Number;
-      readonly functions: Schema.Number;
-      readonly lines: Schema.Number;
+      readonly statements: Schema.Finite;
+      readonly branches: Schema.Finite;
+      readonly functions: Schema.Finite;
+      readonly lines: Schema.Finite;
     }>;
     readonly uncoveredLines: Schema.optional<Schema.String>;
   }>>;
@@ -728,16 +774,16 @@ declare const RunEvent: Schema.Union<readonly [Schema.TaggedStruct<"RunStarted",
   readonly globShortfalls: Schema.optional<Schema.$Array<Schema.Struct<{
     readonly pattern: Schema.String;
     readonly summary: Schema.Struct<{
-      readonly statements: Schema.Number;
-      readonly branches: Schema.Number;
-      readonly functions: Schema.Number;
-      readonly lines: Schema.Number;
+      readonly statements: Schema.Finite;
+      readonly branches: Schema.Finite;
+      readonly functions: Schema.Finite;
+      readonly lines: Schema.Finite;
     }>;
     readonly thresholds: Schema.Struct<{
-      readonly lines: Schema.optional<Schema.Number>;
-      readonly functions: Schema.optional<Schema.Number>;
-      readonly branches: Schema.optional<Schema.Number>;
-      readonly statements: Schema.optional<Schema.Number>;
+      readonly lines: Schema.optional<Schema.Finite>;
+      readonly functions: Schema.optional<Schema.Finite>;
+      readonly branches: Schema.optional<Schema.Finite>;
+      readonly statements: Schema.optional<Schema.Finite>;
     }>;
   }>>>;
 }>, Schema.TaggedStruct<"ThresholdViolation", {
@@ -788,15 +834,35 @@ declare const RunEvent: Schema.Union<readonly [Schema.TaggedStruct<"RunStarted",
    * wrote nothing stray, and in older replay data.
    */
   readonly strayOutput: Schema.optional<Schema.Struct<{
-    readonly total: Schema.Number;
-    readonly stdout: Schema.Number;
-    readonly stderr: Schema.Number;
-    readonly bytes: Schema.Number;
+    readonly total: Schema.Finite;
+    readonly stdout: Schema.Finite;
+    readonly stderr: Schema.Finite;
+    readonly bytes: Schema.Finite;
     readonly samples: Schema.$Array<Schema.Struct<{
       readonly stream: Schema.Literals<readonly ["stdout", "stderr"]>;
       readonly text: Schema.String;
     }>>;
   }>>;
+  /**
+   * `console.*` output Vitest captured from tests that did not fail
+   * (`AgentReport.consoleLeaks`). Optional: absent when the run logged
+   * nothing, and in older replay data (issue #544).
+   */
+  readonly consoleLeaks: Schema.optional<Schema.Struct<{
+    readonly total: Schema.Finite;
+    readonly byFile: Schema.$Array<Schema.Struct<{
+      readonly file: Schema.String;
+      readonly stdout: Schema.Finite;
+      readonly stderr: Schema.Finite;
+      readonly tests: Schema.optional<Schema.$Array<Schema.String>>;
+      readonly sample: Schema.optional<Schema.String>;
+    }>>;
+    readonly truncated: Schema.optional<Schema.Boolean>;
+    readonly fromFailingTests: Schema.optional<Schema.Struct<{
+      readonly total: Schema.Finite;
+      readonly files: Schema.Finite;
+    }>>;
+  }>>;
 }>]>;
 /** @public */
 type RunEvent = typeof RunEvent.Type;
@@ -806,27 +872,27 @@ type RunEvent = typeof RunEvent.Type;
  */
 declare const ResolvedThresholds: Schema.Struct<{
   readonly global: Schema.Struct<{
-    readonly lines: Schema.optional<Schema.Number>;
-    readonly functions: Schema.optional<Schema.Number>;
-    readonly branches: Schema.optional<Schema.Number>;
-    readonly statements: Schema.optional<Schema.Number>;
+    readonly lines: Schema.optional<Schema.Finite>;
+    readonly functions: Schema.optional<Schema.Finite>;
+    readonly branches: Schema.optional<Schema.Finite>;
+    readonly statements: Schema.optional<Schema.Finite>;
   }>;
   readonly perFile: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Boolean, Schema.Struct<{
-    readonly lines: Schema.optional<Schema.Number>;
-    readonly functions: Schema.optional<Schema.Number>;
-    readonly branches: Schema.optional<Schema.Number>;
-    readonly statements: Schema.optional<Schema.Number>;
+    readonly lines: Schema.optional<Schema.Finite>;
+    readonly functions: Schema.optional<Schema.Finite>;
+    readonly branches: Schema.optional<Schema.Finite>;
+    readonly statements: Schema.optional<Schema.Finite>;
   }>]>, never>;
   readonly patterns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Struct<{
-    readonly lines: Schema.optional<Schema.Number>;
-    readonly functions: Schema.optional<Schema.Number>;
-    readonly branches: Schema.optional<Schema.Number>;
-    readonly statements: Schema.optional<Schema.Number>;
+    readonly lines: Schema.optional<Schema.Finite>;
+    readonly functions: Schema.optional<Schema.Finite>;
+    readonly branches: Schema.optional<Schema.Finite>;
+    readonly statements: Schema.optional<Schema.Finite>;
     readonly perFile: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Struct<{
-      readonly lines: Schema.optional<Schema.Number>;
-      readonly functions: Schema.optional<Schema.Number>;
-      readonly branches: Schema.optional<Schema.Number>;
-      readonly statements: Schema.optional<Schema.Number>;
+      readonly lines: Schema.optional<Schema.Finite>;
+      readonly functions: Schema.optional<Schema.Finite>;
+      readonly branches: Schema.optional<Schema.Finite>;
+      readonly statements: Schema.optional<Schema.Finite>;
     }>]>>;
   }>]>>, never>;
 }>;
@@ -857,8 +923,8 @@ type Transport = typeof Transport.Type;
  *
  * `detail` is pre-resolved by the plugin (via `DetailResolver`) but
  * reporters that want to override can ignore it. `noColor` is the resolved
- * value of the `NO_COLOR` env var; reporters use it to gate ANSI escapes and
- * OSC-8 hyperlinks.
+ * value of the `NO_COLOR` env var; reporters use it to gate ANSI escapes
+ * (hyperlinks are the kit's decision: `@effected/cli`'s `CliLinks`).
  * @public
  */
 interface ResolvedReporterConfig {
@@ -943,8 +1009,9 @@ interface ResolvedReporterConfig {
  * Plugin-provided primitives passed to the reporter factory at construction
  * time. The `std*` prefix marks these as "the plugin gives you these — do
  * not import equivalents yourself"; they are pre-resolved with full context
- * (environment, executor, NO_COLOR, target=stdout) so the reporter doesn't
- * have to re-derive that state.
+ * (environment, executor, NO_COLOR) so the reporter doesn't have to
+ * re-derive that state. File hyperlinks are not among them: the reporter
+ * reads `@effected/cli`'s `CliLinks` from its own environment.
  *
  * The shape is open to additions: future fields (e.g. `stdLogger`,
  * `stdRuntime`) won't break existing reporters because the parameter is a
@@ -954,12 +1021,6 @@ interface ResolvedReporterConfig {
 interface ReporterKit {
   readonly config: ResolvedReporterConfig;
   readonly stdEnv: Environment;
-  /**
-   * Pre-bound OSC-8 hyperlink helper. The plugin has already decided
-   * whether OSC-8 should be enabled (target=stdout, !noColor) so the
-   * reporter can call this directly without consulting environment.
-   */
-  readonly stdOsc8: (url: string, label: string) => string;
   /**
    * Live run-event channel. The plugin publishes one `RunEvent`
    * per Vitest streaming callback (`onTestRunStart`, `onTestModuleStart`,
@@ -990,6 +1051,13 @@ interface ReporterKit {
 interface ReporterRenderInput {
   readonly reports: ReadonlyArray<AgentReport>;
   readonly classifications: ReadonlyMap<string, TestClassification>;
+  /**
+   * Run-level suggested actions for the agent (a `SuggestedAction` event
+   * each), rendered as a compact `Actions:` list after the cell output. The
+   * default reporter feeds them to the synthesizer for every report; absent
+   * when the plugin has nothing to suggest (issue #544).
+   */
+  readonly suggestedActions?: ReadonlyArray<SuggestedActionRecord>;
   readonly trendSummary?: {
     readonly direction: "improving" | "regressing" | "stable";
     readonly runCount: number;
@@ -1087,22 +1155,34 @@ export declare const buildDispatchInputs: (state: RenderState, input: ReporterRe
   readonly runCommand?: string | null;
 }) => DispatchInputs;
 /**
- * Build `CellOptions` from a {@link ReporterKit}. Picks the kit's
- * resolved `noColor` value and the pre-bound OSC-8 hyperlink helper.
+ * Options for the one-shot report renderers.
  *
  * @public
  */
-export declare const resolveCellOptions: (kit: ReporterKit) => CellOptions;
+interface ReportRenderOptions {
+  /** Run-level suggested actions to append as the `Actions:` list (issue #544). */
+  readonly suggestedActions?: ReadonlyArray<SuggestedActionRecord>;
+}
+/**
+ * Options for the Ink one-shot renderer: the agent options plus a layout width.
+ *
+ * @public
+ */
+interface HumanReportRenderOptions extends ReportRenderOptions {
+  /** The column width to lay out at; the terminal's (else 80) when omitted. */
+  readonly width?: number;
+}
 /**
  * Convenience helper for one-shot consumers (e.g. a CLI command
  * replaying a stored run). Synthesizes a minimal `ReporterRenderInput`
  * from a single `AgentReport`, classifies the shape and outcome, and
  * returns the dispatched agent-string for the matching cell. Equivalent
- * to the pre-2.0 `renderRun(events, "agent")` shortcut.
+ * to the pre-2.0 `renderRun(events, "agent")` shortcut. Pass
+ * `options.suggestedActions` to append the run's `Actions:` list.
  *
  * @public
  */
-export declare const renderAgentStringForReport: (report: AgentReport) => string;
+export declare const renderAgentStringForReport: (report: AgentReport, options?: ReportRenderOptions) => string;
 /**
  * Same as {@link renderAgentStringForReport} but returns the Ink-half
  * rendered to a string via Ink's `renderToString`, inside the kit's
@@ -1119,9 +1199,7 @@ export declare const renderAgentStringForReport: (report: AgentReport) => string
  *
  * @public
  */
-export declare const renderHumanStringForReport: (report: AgentReport, options?: {
-  readonly width?: number;
-}) => Promise<string>;
+export declare const renderHumanStringForReport: (report: AgentReport, options?: HumanReportRenderOptions) => Promise<string>;
 /**
  * The default reporter factory.
  *
@@ -1155,5 +1233,5 @@ export declare const DefaultVitestAgentReporter: VitestAgentReporterFactory;
  * @public
  */
 export declare const CURRENT_REPORTER_VERSION: string;
-export type { AgentReport, CellOptions, ConsoleMode, DetailLevel, DispatchInputs, Environment, Executor, FileCoverageReport, ProjectSummary, RenderState, RenderedOutput, ReporterKit, ReporterRenderInput, ResolvedReporterConfig, ResolvedThresholds, RunEvent, RunOutcome, RunShape, TestClassification, Transport, TrendSummary, VitestAgentReporter, VitestAgentReporterFactory };
+export type { AgentReport, CellOptions, ConsoleMode, DetailLevel, DispatchInputs, Environment, Executor, FileCoverageReport, FileLinkTarget, HumanReportRenderOptions, ProjectSummary, RenderState, RenderedOutput, ReportRenderOptions, ReporterKit, ReporterRenderInput, ResolvedReporterConfig, ResolvedThresholds, RunEvent, RunOutcome, RunShape, SuggestedActionRecord, TestClassification, Transport, TrendSummary, VitestAgentReporter, VitestAgentReporterFactory };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,4 +1,4 @@
-import { DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForReport, renderHumanStringForReport, resolveCellOptions } from "./defaultReporter.js";
+import { DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForReport, renderHumanStringForReport } from "./defaultReporter.js";
 
 // src/index.ts
 /**
@@ -8,6 +8,6 @@ import { DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForRe
 *
 * @public
 */
-const CURRENT_REPORTER_VERSION = "5.0.9";
+const CURRENT_REPORTER_VERSION = "6.0.1";
 
-export { CURRENT_REPORTER_VERSION, DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForReport, renderHumanStringForReport, resolveCellOptions };
+export { CURRENT_REPORTER_VERSION, DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForReport, renderHumanStringForReport };

package/liveView.js

@@ -1,9 +1,10 @@
+import { plainFileLink, resolveFileLink } from "./fileLinks.js";
 import { CliEnv, Doc } from "@effected/cli";
 import { initialRenderState } from "@vitest-agent/sdk";
 import { SPINNER_FRAME_MS, reduceRenderState, renderAgent } from "@vitest-agent/ui";
+import { Cause, Deferred, Effect, Exit, Layer, PubSub, Scope } from "effect";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { CliUi } from "@effected/cli/ui";
-import { Cause, Deferred, Effect, Exit, Layer, PubSub, Scope } from "effect";
 
 // src/liveView.ts
 /**
@@ -41,29 +42,40 @@ import { Cause, Deferred, Effect, Exit, Layer, PubSub, Scope } from "effect";
 * watch rerun.
 */
 /**
-* The live view's options, everything but `events`: what the reporter hands
-* `CliUi.live`, and what the tests hand `CliUiTest.live`, so both run the
-* same fold, drawing and run predicates.
+* The live view's options, everything but `events`, for a view whose paths
+* are drawn through `link`: what the reporter hands `CliUi.live` once it has
+* resolved the writer from its environment (`resolveFileLink`).
 *
 * @internal
 */
-const liveViewOptions = {
+const liveViewOptionsWith = (link) => ({
 	initial: initialRenderState,
 	reduce: reduceRenderState,
-	render: CliUi.lazyView(() => import("./streamView.js")),
+	render: CliUi.lazyView(() => import("./streamView.js").then((view) => view.makeStreamView(link))),
 	isStart: (event) => event._tag === "RunStarted",
 	isTerminal: (event) => event._tag === "RunFinished" || event._tag === "RunTimedOut",
 	begins: (event, before, after) => event._tag === "RunStarted" || before.phase === "idle" && after.phase !== "idle",
 	mode: "owned",
 	tickMillis: SPINNER_FRAME_MS,
 	final: (state) => renderAgent(state).trimEnd().split("\n").map((line) => Doc.line(line, { wrap: false }))
-};
+});
+/**
+* The live view's options with no link writer (every path its label alone):
+* what the tests hand `CliUiTest.live`, so they run the same fold, drawing
+* and run predicates `startLiveView` does.
+*
+* @internal
+*/
+const liveViewOptions = liveViewOptionsWith(plainFileLink);
 /**
 * The environment a Vitest-hosted live view reads: the kit's `CliEnv` over
 * Node's stdio and terminal. It builds `CliTheme` (colour from the terminal,
-* glyphs `auto`, so `TERM=dumb` draws ASCII) and `TerminalEnv` (the width
-* the report-time human render lays out at), and sets `CliInteractive` (a
-* human audience with a TTY on stdin and stdout).
+* glyphs `auto`, so `TERM=dumb` draws ASCII), `TerminalEnv` (the width the
+* report-time human render lays out at, and whether stdout renders OSC 8),
+* `Audience` and `CliLinks` (where a file link opens; the platform is
+* provided outside `CliEnv.layer`, so a `.vscode/` directory is looked for
+* and a relative path resolved against the working directory), and sets
+* `CliInteractive` (a human audience with a TTY on stdin and stdout).
 *
 * @internal
 */
@@ -95,10 +107,10 @@ const startLiveView = (channel, env = LiveViewEnv) => {
 	const scope = Effect.runSync(Scope.make());
 	const subscription = Effect.runSync(PubSub.subscribe(channel).pipe(Scope.provide(scope)));
 	const mounted = Effect.runSync(Deferred.make());
-	const program = CliUi.live({
-		...liveViewOptions,
+	const program = resolveFileLink.pipe(Effect.flatMap((link) => CliUi.live({
+		...liveViewOptionsWith(link),
 		events: subscription
-	}).pipe(Effect.onExit((exit) => Deferred.done(mounted, exit)), Effect.flatMap((handle) => handle.done), Scope.provide(scope), Effect.provide(env));
+	})), Effect.onExit((exit) => Deferred.done(mounted, exit)), Effect.flatMap((handle) => handle.done), Scope.provide(scope), Effect.provide(env));
 	Effect.runFork(program);
 	let closing;
 	let print;
@@ -117,4 +129,4 @@ const startLiveView = (channel, env = LiveViewEnv) => {
 	};
 };
 
-export { LiveViewEnv, liveViewOptions, printAbove, startLiveView };
+export { LiveViewEnv, liveViewOptionsWith, printAbove, startLiveView };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/reporter",
-	"version": "5.0.9",
+	"version": "6.0.1",
 	"private": false,
 	"description": "Named VitestAgentReporterFactory implementations for the vitest-agent ecosystem.",
 	"keywords": [
@@ -40,17 +40,17 @@
 	},
 	"dependencies": {
 		"@effect/platform-node": "^4.0.6",
-		"@vitest-agent/sdk": "7.1.0",
-		"@vitest-agent/ui": "5.0.9",
+		"@vitest-agent/sdk": "8.0.0",
+		"@vitest-agent/ui": "5.1.1",
 		"effect": "^4.0.6",
 		"ink": "^8.0.0",
 		"react": "^19.3.1"
 	},
 	"peerDependencies": {
-		"@effected/cli": "^0.22.0",
+		"@effected/cli": "^0.22.1",
 		"@effected/env": "^0.5.0",
 		"@effected/glob": "^0.14.0",
-		"@effected/walker": "^0.19.0",
+		"@effected/walker": "^0.20.0",
 		"@vitest/coverage-istanbul": "^5.0.0",
 		"@vitest/coverage-v8": "^5.0.0",
 		"vitest": "^5.0.0"

package/projectSummary.js

@@ -0,0 +1,41 @@
+import { countSuiteFailures, isTimeoutError } from "@vitest-agent/sdk";
+
+// src/projectSummary.ts
+/** Timed-out tests in `report.failed[].tests[]`, identified per test by `isTimeoutError`. */
+const countTimeouts = (report) => {
+	let timeoutCount = 0;
+	for (const mod of report.failed) for (const test of mod.tests) {
+		const firstError = test.errors?.[0];
+		if (test.state === "failed" && firstError !== void 0 && isTimeoutError({ message: firstError.message })) timeoutCount++;
+	}
+	return timeoutCount;
+};
+const collapseTagCounts = (entries) => {
+	const out = {};
+	if (entries === void 0) return out;
+	for (const [tag, entry] of Object.entries(entries)) {
+		const total = (entry.passed ?? 0) + (entry.failed ?? 0) + (entry.skipped ?? 0);
+		if (total > 0) out[tag] = total;
+	}
+	return out;
+};
+const summarizeProject = (report) => {
+	const collapsedTagCounts = report.tagCounts !== void 0 ? collapseTagCounts(report.tagCounts) : void 0;
+	const tagCountsHasEntries = collapsedTagCounts !== void 0 && Object.keys(collapsedTagCounts).length > 0;
+	const belowTargetCount = report.coverage?.belowTargetFiles?.length;
+	const violationsCount = report.coverage !== void 0 && report.coverage.lowCoverage.length > 0 ? report.coverage.lowCoverage.length : void 0;
+	const timeoutCount = countTimeouts(report);
+	return {
+		name: report.project ?? "default",
+		passCount: report.summary.passed,
+		failCount: report.summary.failed + countSuiteFailures(report) - timeoutCount,
+		skipCount: report.summary.skipped,
+		durationMs: report.summary.duration,
+		...timeoutCount > 0 ? { timeoutCount } : {},
+		...tagCountsHasEntries && collapsedTagCounts !== void 0 ? { tagCounts: collapsedTagCounts } : {},
+		...belowTargetCount !== void 0 ? { belowTarget: belowTargetCount } : {},
+		...violationsCount !== void 0 ? { violations: violationsCount } : {}
+	};
+};
+
+export { countTimeouts, summarizeProject };

package/streamView.js

@@ -1,12 +1,17 @@
 import { SPINNER_FRAME_MS } from "@vitest-agent/ui";
-import { StreamApp } from "@vitest-agent/ui/ink";
+import { FileLinkProvider, StreamApp } from "@vitest-agent/ui/ink";
 import { createElement } from "react";
 
 // src/streamView.ts
-const streamView = (state, frame) => createElement(StreamApp, {
+/**
+* The view for one live view, closed over its link writer.
+*
+* @internal
+*/
+const makeStreamView = (link) => (state, frame) => createElement(FileLinkProvider, { link }, createElement(StreamApp, {
 	state,
 	frameIndex: frame,
 	nowMs: frame * SPINNER_FRAME_MS
-});
+}));
 
-export { streamView as default };
+export { makeStreamView };

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.59.1"
+      "packageVersion": "7.59.4"
     }
   ]
 }