@stacknyu/pi-check 0.0.0-stage → 1.1.0

package/extension.ts

@@ -0,0 +1,215 @@
+/**
+ * pi-check — one shared check runner per repo for every Pi session and worktree.
+ *
+ *   check tool        agents run tests / typecheck / lint for what their changes affect; results are
+ *                     shared across sessions, cached by file content, and pre-existing failures are separated
+ *   bash routing      raw `go test`, `pytest`, `vitest`, `tsc`, `eslint`… commands go through the broker too
+ *   /check            status | run [all] | baseline | known | speculate | cancel | stop | restart | init | log
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { Type } from "typebox";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { CLI, SHIM_DIR, call, connect, installShims } from "./lib/client.mjs";
+import { CONFIG_FILE, loadConfig } from "./lib/repo.mjs";
+import { STATE_DIR, repoRoots, shq, tailLines } from "./lib/util.mjs";
+import { isCheckCommand, isGoCommand } from "./lib/commands.mjs";
+
+const rootsMemo = new Map<string, any>();
+function roots(cwd: string): any {
+	if (!rootsMemo.has(cwd)) rootsMemo.set(cwd, repoRoots(cwd) ?? null);
+	return rootsMemo.get(cwd);
+}
+
+function config(cwd: string): any {
+	const r = roots(cwd);
+	return r ? loadConfig(r.main) : undefined;
+}
+
+function statusLine(s: any): string | undefined {
+	if (!s) return undefined;
+	const run = s.running?.filter((j: any) => !j.speculative).length ?? 0;
+	const spec = s.running?.filter((j: any) => j.speculative).length ?? 0;
+	const q = s.pending?.requested ?? 0;
+	if (!run && !spec && !q) return s.stats?.savedMs > 60000 ? `checks idle · reused ${s.stats.saved} unit-runtime` : undefined;
+	return `checks: ${run} running${spec ? ` +${spec} ahead-of-time` : ""}${q ? ` · ${q} queued` : ""}`;
+}
+
+export default function (pi: ExtensionAPI) {
+	let shimsReady = false;
+	try {
+		installShims();
+		shimsReady = true;
+	} catch {}
+
+	let timer: any;
+	const watchStatus = (ctx: any) => {
+		clearInterval(timer);
+		if (!ctx?.hasUI && !ctx?.ui) return;
+		timer = setInterval(async () => {
+			try {
+				const r = roots(ctx.cwd);
+				if (!r || !existsSync(join(r.main, STATE_DIR, "broker.json"))) return ctx.ui?.setStatus?.("check", undefined);
+				const c = await connect(ctx.cwd, { start: false });
+				if (!c.info) return ctx.ui?.setStatus?.("check", undefined);
+				const s = await call(ctx.cwd, "/status", undefined, undefined, { start: false, timeoutMs: 2000 });
+				ctx.ui?.setStatus?.("check", statusLine(s));
+			} catch {}
+		}, 4000);
+		timer.unref?.();
+	};
+
+	pi.on("session_start", async (_e: any, ctx: any) => {
+		const r = roots(ctx.cwd);
+		if (!r) return;
+		// repos that use pi-check: make sure this checkout is watched, so checks run ahead of time
+		if (existsSync(join(r.main, CONFIG_FILE)) || existsSync(join(r.main, STATE_DIR))) {
+			call(ctx.cwd, "/touch", {}).catch(() => {});
+			watchStatus(ctx);
+		}
+	});
+	pi.on("session_shutdown", async () => clearInterval(timer));
+
+	pi.on("tool_call", async (event: any, ctx: any) => {
+		if (event.toolName !== "bash" || typeof event.input?.command !== "string") return;
+		const command: string = event.input.command;
+		if (command.includes("pi-check") || command.includes("PI_CHECK_BYPASS")) return;
+		const r = roots(ctx.cwd);
+		if (!r) return;
+		const cfg = config(ctx.cwd);
+		if (!cfg || cfg.intercept === "off") return;
+		if (isCheckCommand(command)) {
+			if (cfg.intercept === "block")
+				return { block: true, reason: "Run checks with the `check` tool instead (it runs only what your changes affect and shares results with other sessions). For a specific command: pi-check exec -- <command>." };
+			event.input.command = `${shq(process.execPath)} ${shq(CLI)} exec --cwd ${shq(ctx.cwd)} -- ${shq(command)}`;
+			return;
+		}
+		if (shimsReady && cfg.shimGo && isGoCommand(command)) event.input.command = `export PATH=${shq(SHIM_DIR)}:"$PATH"; ${command}`;
+	});
+
+	pi.registerTool({
+		name: "check",
+		label: "Check",
+		description:
+			"Run the repo's tests, type checks and linters (Go, TypeScript/JavaScript, Python) through the shared check broker. By default only what your changes affect (vs the base branch) runs: packages/test files/projects whose inputs changed. Results are cached by file content and shared with every other session and worktree, identical runs in progress are joined instead of repeated, and failures that also fail on the base branch are reported as pre-existing (they do not fail the check).",
+		promptSnippet: "check: run affected tests/typecheck/lint via the shared, cached check broker",
+		promptGuidelines: [
+			"Use the `check` tool to run tests, type checks and linters instead of running go test, pytest, vitest, jest, tsc, eslint or ruff in bash: it runs only what your changes affect, reuses results other sessions already have, and separates pre-existing failures from ones you caused.",
+			"Call `check` after a meaningful set of edits, not after every small edit; it also runs affected checks in the background while you work, so results are often ready.",
+			"Fix failures marked new; failures marked pre-existing also fail on the base branch — leave them unless your task is to fix them.",
+		],
+		parameters: Type.Object({
+			scope: Type.Optional(Type.Union([Type.Literal("changed"), Type.Literal("all")], { description: "changed (default): what your changes affect. all: everything." })),
+			files: Type.Optional(Type.Array(Type.String(), { description: "Only checks that depend on these files (repo- or cwd-relative)" })),
+			kinds: Type.Optional(Type.Array(Type.Union(["test", "typecheck", "lint", "vet", "custom"].map((k) => Type.Literal(k))))),
+			projects: Type.Optional(Type.Array(Type.String({ description: "Project dirs, e.g. apps/dashboard" }))),
+			strict: Type.Optional(Type.Boolean({ description: "Count pre-existing failures too" })),
+			refresh: Type.Optional(Type.Boolean({ description: "Ignore cached results and run again" })),
+		}),
+		async execute(_id: string, p: any, _signal: any, onUpdate: any, ctx: any) {
+			if (!roots(ctx.cwd)) return { content: [{ type: "text", text: "check: not inside a git repository." }], details: {} };
+			const scope = p.files?.length ? "files" : p.scope === "all" ? "all" : "changed";
+			const r = roots(ctx.cwd);
+			const files = (p.files ?? []).map((f: string) => {
+				const abs = f.startsWith("/") ? f : join(ctx.cwd, f);
+				return abs.startsWith(`${r.root}/`) ? abs.slice(r.root.length + 1) : f;
+			});
+			let lastText = "";
+			try {
+				const res: any = await call(ctx.cwd, "/run", { scope, files, kinds: p.kinds, projects: p.projects, strict: p.strict, refresh: p.refresh, label: "check tool" }, (ev: any) => {
+					const t = ev.type === "start" ? `checking ${ev.units} units: ${ev.cached} cached, ${ev.joined} already running elsewhere, ${ev.queued} to run` : ev.type === "progress" ? `${ev.done ?? ""}/${ev.total ?? ""} · ${ev.text ?? ""}` : "";
+					if (t && t !== lastText) {
+						lastText = t;
+						onUpdate?.({ content: [{ type: "text", text: t }], details: {} });
+					}
+				}, { signal: _signal });
+				const rep = res.report;
+				return { content: [{ type: "text", text: rep.text }], details: { ok: rep.ok, newFailures: rep.newFailures, knownFailures: rep.knownFailures, units: rep.units, ran: rep.ran, cached: rep.cache, shared: rep.shared }, isError: !rep.ok };
+			} catch (e: any) {
+				if (_signal?.aborted) return { content: [{ type: "text", text: "check: cancelled this request; other sessions' checks were not cancelled." }], details: {}, isError: true };
+				return { content: [{ type: "text", text: `check: the check broker failed: ${e?.message ?? e}. Inspect /check status before retrying; do not start an unbudgeted duplicate.` }], details: {}, isError: true };
+			}
+		},
+	} as any);
+
+	pi.registerCommand("check", {
+		description: "Shared check broker: /check [status] | run [all] | baseline | known [clear] | speculate [all] | cancel | reload | stop | restart | init | log",
+		handler: async (args: string, ctx: any) => {
+			const [cmd = "status", ...rest] = (args ?? "").trim().split(/\s+/).filter(Boolean);
+			const cwd = ctx.cwd;
+			const r = roots(cwd);
+			if (!r) return ctx.ui.notify("check: not inside a git repository.", "warning");
+			try {
+				if (cmd === "status") {
+					const c = await connect(cwd, { start: false });
+					if (!c.info) return ctx.ui.notify("check: the broker is not running here; it starts with the first check (/check run).", "info");
+					const s: any = await call(cwd, "/status");
+					const st = s.stats;
+					ctx.ui.notify(
+						[
+							`pi-check · ${s.cpus} cores, load ${s.load} · ${s.maxJobs} job slots, ${s.allocatedCpus ?? "?"}/${s.cpuBudget ?? s.cpus} CPU budget allocated${s.configPending ? " · config waiting for idle" : ""} · ahead-of-time runs ${s.speculate ? "on" : "off"}`,
+							`running: ${s.running.map((j: any) => `${j.root}: ${j.label}${j.speculative ? " (ahead of time)" : ""} ${j.for}${j.activity ? ` · ${j.activity}` : ""}`).join(" | ") || "nothing"}`,
+							`queued: ${s.pending.requested} requested, ${s.pending.speculative} ahead-of-time`,
+							`checkouts watched: ${s.roots.map((x: any) => x.name).join(", ")}`,
+							`asked ${st.unitsAsked} units: ${st.cacheHits} cached, ${st.joined} joined a run in progress, ${st.ran} ran · ${st.speculativeRan} ran ahead of time · reused unit-runtime ≈ ${st.saved} (not wall-time savings)`,
+							`pre-existing failures known: ${s.known}`,
+						].join("\n"),
+						"info",
+					);
+					watchStatus(ctx);
+					return;
+				}
+				if (cmd === "run" || cmd === "baseline") {
+					const base = cmd === "baseline";
+					ctx.ui.notify(base ? "check: running everything on the main checkout…" : "check: running…", "info");
+					const res: any = await call(base ? r.main : cwd, "/run", { scope: base || rest[0] === "all" ? "all" : "changed", label: base ? "baseline" : "/check" });
+					ctx.ui.notify(tailLines(res.report.text, 60), res.report.ok ? "info" : "warning");
+					watchStatus(ctx);
+					return;
+				}
+				if (cmd === "known") {
+					const res: any = await call(cwd, "/known", rest[0] === "clear" ? { action: "clear" } : rest[0] === "remove" ? { action: "remove", pattern: rest[1] } : {});
+					const e = Object.entries(res.known);
+					ctx.ui.notify(`${e.map(([id, k]: any) => `${k.source === "manual" ? "[manual] " : ""}${k.title ?? id}`).join("\n") || "(none)"}\n${e.length} known failure(s)`, "info");
+					return;
+				}
+				if (cmd === "speculate") {
+					const res: any = await call(cwd, "/speculate", { all: rest[0] === "all" });
+					ctx.ui.notify(`check: ${res.queued} unit(s) queued to run ahead of time.`, "info");
+					return;
+				}
+				if (cmd === "cancel") {
+					const res: any = await call(cwd, "/cancel", { root: r.root });
+					ctx.ui.notify(`check: cancelled ${res.cancelled}.`, "info");
+					return;
+				}
+				if (cmd === "reload") {
+					const res: any = await call(cwd, "/reload", {});
+					ctx.ui.notify(res.deferred ? "check: configuration queued; applies after requested work finishes." : "check: configuration applied.", "info");
+					return;
+				}
+				if (cmd === "stop" || cmd === "restart") {
+					const c = await connect(cwd, { start: false });
+					if (c.info) await call(cwd, "/stop", {}, undefined, { start: false, timeoutMs: 3000 }).catch(() => {});
+					if (cmd === "restart") {
+						await new Promise((res) => setTimeout(res, 700));
+						await connect(cwd);
+					}
+					ctx.ui.notify(`check: broker ${cmd === "stop" ? "stopped" : "restarted"}.`, "info");
+					return;
+				}
+				if (cmd === "init" || cmd === "log" || cmd === "projects") {
+					const { spawnSync } = await import("node:child_process");
+					const out = spawnSync(process.execPath, [CLI, cmd], { cwd, encoding: "utf8" });
+					ctx.ui.notify(`${out.stdout}${out.stderr}`.trim() || "(no output)", "info");
+					return;
+				}
+				ctx.ui.notify("Usage: /check [status] | run [all] | baseline | known [clear|remove <text>] | speculate [all] | cancel | reload | stop | restart | init | projects | log", "warning");
+			} catch (e: any) {
+				ctx.ui.notify(`check: ${e?.message ?? e}`, "error");
+			}
+		},
+	});
+}
+
+export { statusLine };

package/lib/adapters/custom.mjs

@@ -0,0 +1,35 @@
+// Custom checks from pi-check.json: { name, cwd, cmd, inputs: [globs, repo-relative], timeout, env, parallel }
+import { cleanEnv, matchAny, parseDuration, runProc, sha } from "../util.mjs";
+
+const adapter = {
+	lang: "custom",
+	version: 2,
+	detect(rc) {
+		return (rc.config.custom ?? [])
+			.filter((c) => c?.name && c?.cmd)
+			.map((c) => ({ id: `custom:${c.name}`, lang: "custom", dir: c.cwd ?? ".", name: c.name, kinds: ["custom"], meta: c }));
+	},
+	units(rc, project) {
+		const c = project.meta;
+		const globs = c.inputs?.length ? c.inputs : [project.dir === "." ? "**" : `${project.dir}/**`];
+		return [{ target: c.name, label: c.name, inputs: rc.listing().files.filter((f) => matchAny(globs, f)) }];
+	},
+	group(project) {
+		return { name: `custom:${project.meta.name}`, limit: project.meta.parallel ?? 1 };
+	},
+	batchSize: () => 1,
+	argsKey(_opts, project) {
+		return JSON.stringify({ cmd: project.meta.cmd, env: project.meta.env ?? {} });
+	},
+	async run({ rc, project, units, signal, nice, threads }) {
+		const c = project.meta;
+		const env = cleanEnv({ ...(c.env ?? {}), PI_CHECK_BYPASS: "1", GOMAXPROCS: String(threads), GOFLAGS: `${process.env.GOFLAGS ?? ""} -p=1`.trim() });
+				const r = await runProc({ cmd: "/bin/sh", args: ["-c", c.cmd], cwd: rc.path(project.dir), env, signal, nice, timeoutMs: parseDuration(c.timeout, 30 * 60000) });
+		const out = `${r.stdout}${r.stderr ? `\n${r.stderr}` : ""}`.trim();
+		const u = units[0];
+		const results = new Map([[u.target, r.code === 0 ? { status: "pass", failures: [], passed: 1, output: out.slice(-20000) } : { status: r.killed ? "error" : "fail", failures: [{ id: `custom:${c.name}:${sha(out.split(rc.abs).join("<checkout>")).slice(0, 16)}`, title: `${c.name} failed (exit ${r.code})`, output: out.slice(-6000) }], output: out.slice(-20000) }]]);
+		return { results, ms: r.ms, killed: r.killed };
+	},
+};
+
+export default adapter;

package/lib/adapters/go.mjs

@@ -0,0 +1,358 @@
+// Go: one unit per package. Inputs = the package's files plus every in-repo package it (and its tests) import.
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+import { kindOptions, LOCKFILES } from "../repo.mjs";
+import { SHIM_DIR, cleanEnv, baseOf, dirOf, isUnder, joinRel, matchGlob, normRel, parseDuration, runProc, sha, which } from "../util.mjs";
+
+const SKIP_SEG = /(^|\/)(vendor|testdata|node_modules|_[^/]*|\.[^/]+)(\/|$)/;
+const GO_LOCKFILES = ["go.work", "go.work.sum"];
+const NATIVE_SOURCE = /\.(go|c|cc|cpp|cxx|m|mm|h|hh|hpp|hxx|s|S|sx|f|F|for|f90|swig|swigcxx|syso)$/;
+
+function goHeader(text) {
+	const cut = text.search(/^(func|type|var|const)\b/m);
+	return cut > 0 ? text.slice(0, cut) : text;
+}
+
+function parseGoFile(text) {
+	const head = goHeader(text);
+	const imports = [];
+	const re = /^\s*import\s*(?:\(([\s\S]*?)\)|(?:[\w.]+\s+)?"([^"]+)")/gm;
+	let m;
+	while ((m = re.exec(head))) {
+		if (m[2]) imports.push(m[2]);
+		else if (m[1]) for (const mm of m[1].matchAll(/"([^"]+)"/g)) imports.push(mm[1]);
+	}
+	const embeds = [];
+	for (const em of text.matchAll(/^\s*\/\/go:embed\s+(.+)$/gm)) {
+		for (const token of em[1].match(/"(?:[^"\\]|\\.)*"|`[^`]*`|\S+/g) ?? []) {
+			let pattern = token;
+			try { if (token.startsWith('"')) pattern = JSON.parse(token); } catch { pattern = "**"; }
+			embeds.push(pattern.replace(/^`|`$/g, "").replace(/^all:/, ""));
+		}
+	}
+	return { imports, embeds };
+}
+
+/** Modules, packages and the import graph of a checkout (memoized per checkout version). */
+export function goGraph(rc) {
+	const cached = rc.memo.get("go:graph");
+	if (cached) return cached;
+	const files = rc.listing().files;
+	const modules = [];
+	for (const f of files) {
+		if (baseOf(f) !== "go.mod" || SKIP_SEG.test(dirOf(f) === "." ? "" : dirOf(f))) continue;
+		const m = rc.text(f).match(/^\s*module\s+(\S+)/m);
+		if (m) modules.push({ dir: dirOf(f), path: m[1].replace(/"/g, "") });
+	}
+	modules.sort((a, b) => b.dir.length - a.dir.length);
+	const moduleOf = (dir) => modules.find((m) => isUnder(dir, m.dir));
+	const pkgs = new Map(); // dir -> pkg
+	const byDir = new Map(); // dir -> all files directly in dir
+	for (const f of files) {
+		const d = dirOf(f);
+		if (!byDir.has(d)) byDir.set(d, []);
+		byDir.get(d).push(f);
+	}
+	for (const f of files) {
+		if (!f.endsWith(".go")) continue;
+		const d = dirOf(f);
+		if (SKIP_SEG.test(d === "." ? "" : d)) continue;
+		const mod = moduleOf(d);
+		if (!mod) continue;
+		let p = pkgs.get(d);
+		if (!p) {
+			const relInMod = d === mod.dir ? "" : mod.dir === "." ? d : d.slice(mod.dir.length + 1);
+			p = { dir: d, module: mod, importPath: relInMod ? `${mod.path}/${relInMod}` : mod.path, rel: relInMod ? `./${relInMod}` : ".", goFiles: [], imports: new Set(), testImports: new Set(), embeds: [], productionEmbeds: [], hasTests: false };
+			pkgs.set(d, p);
+		}
+		p.goFiles.push(f);
+		const memoKey = `go:file:${rc.hash(f)}`;
+		let parsed = rc.hasher.memo.get(memoKey);
+		if (!parsed) {
+			parsed = parseGoFile(rc.text(f));
+			rc.hasher.memo.set(memoKey, parsed);
+		}
+		const isTest = f.endsWith("_test.go");
+		if (isTest) p.hasTests = true;
+		for (const i of parsed.imports) (isTest ? p.testImports : p.imports).add(i);
+		for (const e of parsed.embeds) { p.embeds.push(e); if (!isTest) p.productionEmbeds.push(e); }
+	}
+	const byImport = new Map();
+	for (const p of pkgs.values()) byImport.set(p.importPath, p);
+	for (const p of pkgs.values()) {
+		p.extra = [];
+		p.productionExtra = [];
+		p.dirFiles = byDir.get(p.dir) ?? [];
+	}
+	// Visit ancestor packages, not the entire repository once per package.
+	for (const f of files) {
+		for (let d = dirOf(f); ; d = dirOf(d)) {
+			const p = pkgs.get(d);
+			if (p) {
+				const r = d === "." ? f : f.slice(d.length + 1);
+				const parts = r.split("/");
+				// Conservatively include character-class matches; the generic glob matcher has no Go path.Match classes.
+				const matches = (e) => parts.some((_, i) => matchGlob(e.replace(/\[[^\]]+\]/g, "?"), parts.slice(0, i + 1).join("/")));
+				if (r.startsWith("testdata/") || p.embeds.some(matches)) p.extra.push(f);
+				if (p.productionEmbeds.some(matches)) p.productionExtra.push(f);
+			}
+			if (d === ".") break;
+		}
+	}
+	const g = { modules, pkgs, byImport, depMemo: new Map() };
+	rc.memo.set("go:graph", g);
+	return g;
+}
+
+function deps(g, p) {
+	// transitive in-repo non-test imports
+	let s = g.depMemo.get(p.dir);
+	if (s) return s;
+	s = new Set();
+	g.depMemo.set(p.dir, s);
+	for (const i of p.imports) {
+		const q = g.byImport.get(i);
+		if (!q || s.has(q.dir)) continue;
+		s.add(q.dir);
+		for (const d of deps(g, q)) s.add(d);
+	}
+	return s;
+}
+
+function closure(g, p) {
+	const s = new Set([p.dir, ...deps(g, p)]);
+	for (const i of p.testImports) {
+		const q = g.byImport.get(i);
+		if (!q) continue;
+		s.add(q.dir);
+		for (const d of deps(g, q)) s.add(d);
+	}
+	return s;
+}
+
+const adapter = {
+	lang: "go",
+	version: 4,
+
+	detect(rc) {
+		if (!rc.config.languages.go) return [];
+		const g = goGraph(rc);
+		return [...g.modules]
+			.sort((a, b) => a.dir.localeCompare(b.dir))
+			.map((m) => ({ id: `go:${m.dir}`, lang: "go", dir: m.dir, name: m.path, kinds: ["vet", "test"].filter((k) => kindOptions(rc.config, m.dir, k) !== false) }));
+	},
+
+	units(rc, project, kind, request = {}) {
+		const g = goGraph(rc);
+		const opts = kindOptions(rc.config, project.dir, kind) || {};
+		const candidates = [...g.pkgs.values()].filter((p) => p.module.dir === project.dir);
+		let eligible;
+		// Ask Go only when build constraints can exclude whole packages; ordinary graphs stay filesystem-only.
+		if (candidates.some((p) => p.goFiles.some((f) => /_(?:aix|android|darwin|dragonfly|freebsd|illumos|ios|js|linux|netbsd|openbsd|plan9|solaris|wasip1|windows|386|amd64|arm|arm64|loong64|mips\w*|ppc64\w*|riscv64|s390x|wasm)(?:_test)?\.go$/.test(f) || /^\/\/(?:go:build|\s*\+build)\s/m.test(rc.text(f))))) {
+			const env = cleanEnv({ ...request.env, ...opts.env });
+			const args = [...(opts.args ?? []), ...(request.extraArgs ?? [])];
+			const tags = args.flatMap((a, i) => /^-(?:tags|mod)$/.test(a) ? [a, args[i + 1]] : /^-(?:tags|race|msan|asan|mod)(?:=|$)/.test(a) ? [a] : []);
+			const listed = spawnSync(which("go", { skipDir: SHIM_DIR, pathEnv: env.PATH }) ?? "go", ["list", "-e", ...tags, "-f", "{{if or .GoFiles .CgoFiles .TestGoFiles .XTestGoFiles}}{{.ImportPath}}{{end}}", "./..."], { cwd: rc.path(project.dir), env, encoding: "utf8", timeout: 30000 });
+			if (listed.status !== 0) throw new Error(`Go package discovery failed: ${listed.error?.message ?? listed.stderr}`);
+			eligible = new Set(listed.stdout.trim().split(/\s+/));
+		}
+		const extraGlobs = opts.inputs ?? [];
+		const extraFiles = extraGlobs.length ? rc.filesUnder(project.dir).filter((f) => extraGlobs.some((gl) => matchGlob(gl, project.dir === "." ? f : f.slice(project.dir.length + 1)))) : [];
+		const roots = GO_LOCKFILES.filter((f) => rc.has(f));
+		const out = [];
+		for (const p of candidates) {
+			if (eligible && !eligible.has(p.importPath)) continue;
+			const inputs = [...p.dirFiles.filter((f) => !LOCKFILES.includes(baseOf(f)) || GO_LOCKFILES.includes(baseOf(f))), ...p.extra, ...extraFiles, ...roots];
+			const mods = new Set([p.module]);
+			for (const d of closure(g, p)) {
+				const q = g.pkgs.get(d);
+				if (!q) continue;
+				mods.add(q.module);
+				if (q === p) continue;
+				inputs.push(...q.dirFiles.filter((f) => NATIVE_SOURCE.test(f) && !f.endsWith("_test.go")), ...q.productionExtra);
+			}
+			for (const m of mods) for (const f of ["go.mod", "go.sum"]) if (rc.has(joinRel(m.dir, f))) inputs.push(joinRel(m.dir, f));
+			out.push({ target: p.dir, label: p.importPath, inputs });
+		}
+		return out;
+	},
+
+	group(project, kind, opts) {
+		// A project can opt into serialization for shared ports/databases. Otherwise the
+		// broker budgets package processes globally, independently of agent count.
+		return { name: `go:${project.dir}:${kind}`, limit: opts?.parallel ?? Infinity };
+	},
+
+	batchSize: () => 1,
+
+	/** Args that change results (part of the cache key). */
+	argsKey(opts) {
+		return JSON.stringify({ args: opts?.args ?? [], env: opts?.env ?? {}, timeout: opts?.timeout ?? "10m" });
+	},
+
+	executionKey(rc, project, opts) {
+		const env = cleanEnv(opts?.env);
+		const binary = which("go", { skipDir: SHIM_DIR, pathEnv: env.PATH }) ?? "go";
+		const normalize = (k, v) => k === "GOWORK" && v.startsWith(`${rc.abs}/`) ? v.slice(rc.abs.length + 1) : v;
+		const settings = Object.entries(env).filter(([k]) => /^(GO[A-Z0-9_]*|CGO_[A-Z0-9_]+|CC|CXX|PKG_CONFIG|PATH)$/.test(k)).map(([k, v]) => [k, normalize(k, v)]).sort();
+		const key = `go:environment:${project.dir}:${sha(JSON.stringify([binary, rc.hasher.hash(binary), settings]))}`;
+		if (!rc.memo.has(key)) {
+			const r = spawnSync(binary, ["env", "-json", "GOVERSION", "GOROOT", "GOOS", "GOARCH", "GOFLAGS", "GOWORK", "CGO_ENABLED", "GOEXPERIMENT", "CC", "CXX"], { cwd: rc.path(project.dir), env, encoding: "utf8", timeout: 10000, maxBuffer: 1024 * 1024 });
+			let values;
+			try { values = Object.fromEntries(Object.entries(JSON.parse(r.stdout)).map(([k, v]) => [k, normalize(k, v)])); } catch { values = r.stdout ?? ""; }
+			rc.memo.set(key, sha(JSON.stringify([key, r.status, values, r.stderr ?? ""])));
+		}
+		return rc.memo.get(key);
+	},
+
+	async run({ rc, project, kind, units, opts, threads, signal, nice, extraArgs = [], onUnit, onProgress }) {
+		const g = goGraph(rc);
+		const goBin = which("go", { skipDir: SHIM_DIR, pathEnv: opts?.env?.PATH }) ?? "go";
+		const cwd = rc.path(project.dir);
+		const pkgs = units.map((u) => g.pkgs.get(u.target)).filter(Boolean);
+		const env = cleanEnv({ ...(opts?.env ?? {}), GOMAXPROCS: String(threads), GOFLAGS: `${opts?.env?.GOFLAGS ?? process.env.GOFLAGS ?? ""} -p=${threads}`.trim() });
+		const results = new Map();
+		if (kind === "vet") {
+			const r = await runProc({ cmd: goBin, args: ["vet", ...(opts?.args ?? []), ...extraArgs, ...pkgs.map((p) => p.rel)], cwd, env, signal, nice, timeoutMs: parseDuration(opts?.timeout, 15 * 60000) });
+			const diags = new Map();
+			let header;
+			for (const raw of `${r.stdout}\n${r.stderr}`.split("\n")) {
+				const line = raw.replace(/^vet: /, "");
+				const h = line.match(/^# (\S+)/);
+				if (h) {
+					header = g.byImport.get(h[1]);
+					continue;
+				}
+				const m = line.match(/^(?:\.\/)?([^:\s][^:]*\.go):(\d+):(?:(\d+):)?\s*(.*)$/);
+				if (!m) {
+					if (header && line.trim()) (diags.get(header.dir) ?? diags.set(header.dir, []).get(header.dir)).push({ file: "", msg: line.trim(), line: 0 });
+					continue;
+				}
+				const file = normRel(joinRel(project.dir, m[1]));
+				const owner = g.pkgs.get(dirOf(file)) ?? header;
+				if (!owner) continue;
+				(diags.get(owner.dir) ?? diags.set(owner.dir, []).get(owner.dir)).push({ file, line: Number(m[2]), msg: m[4] });
+			}
+			for (const p of pkgs) {
+				const d = diags.get(p.dir) ?? [];
+				if (d.length) results.set(p.dir, { status: "fail", failures: d.map((x) => ({ id: `${p.importPath}:vet:${x.file}:${x.msg}`, title: `${x.file ? `${x.file}:${x.line}: ` : ""}${x.msg}`, output: "" })), output: d.map((x) => `${x.file}:${x.line}: ${x.msg}`).join("\n") });
+				else if (r.code !== 0 && !diags.size) results.set(p.dir, { status: "fail", failures: [{ id: `${p.importPath}:vet:[error]`, title: "go vet failed", output: `${r.stdout}\n${r.stderr}`.trim().slice(-4000) }], output: r.stderr.slice(-4000) });
+				else results.set(p.dir, { status: "pass", failures: [], passed: 1, output: "" });
+			}
+			return { results, ms: r.ms, killed: r.killed };
+		}
+		// test — events stream in; each package's result is reported as soon as go finishes it
+		const args = ["test", "-json", "-count=1", ...(opts?.args ?? []), ...extraArgs];
+		if (opts?.timeout && !extraArgs.some((a) => a.startsWith("-timeout"))) args.push("-timeout", String(opts.timeout));
+		args.push(...pkgs.map((p) => p.rel));
+		const timeoutIndex = args.findLastIndex((a) => a === "-timeout" || a.startsWith("-timeout="));
+		const timeout = timeoutIndex < 0 ? "10m" : args[timeoutIndex].includes("=") ? args[timeoutIndex].slice(9) : args[timeoutIndex + 1];
+		const goTimeout = parseDuration(timeout, 10 * 60000);
+		const per = new Map();
+		const buildOut = new Map();
+		const byIp = new Map(pkgs.map((p) => [p.importPath, p]));
+		const get = (ip) => {
+			let x = per.get(ip);
+			if (!x) per.set(ip, (x = { tests: new Map(), out: [], status: undefined, elapsed: 0 }));
+			return x;
+		};
+		const finish = (p, killed = false, stderr = "") => {
+			const x = per.get(p.importPath);
+			const out = x ? x.out.join("") : "";
+			if (x && (x.status === "pass" || x.status === "skip")) {
+				const passed = [...x.tests.entries()].filter(([n, t]) => t.status === "pass" && !n.includes("/")).length;
+				return { status: "pass", failures: [], passed, output: out.slice(-200000), seconds: x.elapsed };
+			}
+			if (x && x.status === "fail") {
+				const failed = [...x.tests.entries()].filter(([, t]) => t.status === "fail");
+				const leaves = failed.filter(([n]) => !failed.some(([m]) => m !== n && m.startsWith(`${n}/`)));
+				const failures = leaves.map(([n, t]) => ({ id: `${p.importPath}:${n}`, title: `${p.importPath} ${n}`, output: t.out.join("").slice(-6000) }));
+				const timedOut = /panic: test timed out after/.test(out);
+				if (!failures.length || timedOut) {
+					const why = (buildOut.get(p.importPath) ?? "") + out;
+					const built = buildOut.has(p.importPath) || /\[build failed\]|\[setup failed\]/.test(out);
+					if (!failures.length) failures.push({ id: `${p.importPath}:${built ? "[build]" : timedOut ? "[timeout]" : "[package]"}`, title: `${p.importPath} ${built ? "does not build" : timedOut ? `timed out (${(out.match(/timed out after (\S+)/) ?? [])[1] ?? ""}) — raise the timeout: go test -timeout 30m, or "timeout" for this project in pi-check.json` : "failed (no single test to blame: panic or TestMain)"}`, output: why.slice(-6000) });
+				}
+				const passed = [...x.tests.entries()].filter(([n, t]) => t.status === "pass" && !n.includes("/")).length;
+				// a timeout says nothing about the code: report it, never cache it
+				return { status: timedOut ? "error" : "fail", failures, passed, output: out.slice(-200000), seconds: x.elapsed };
+			}
+			const why = buildOut.get(p.importPath) ?? "";
+			if (killed) return { status: "error", failures: [{ id: `${p.importPath}:[killed]`, title: `${p.importPath}: run stopped (timeout or cancelled)`, output: stderr.slice(-3000) }], output: "" };
+			return { status: "fail", failures: [{ id: `${p.importPath}:[build]`, title: `${p.importPath} does not build`, output: (why || stderr).slice(-6000) }], output: why };
+		};
+		const done = new Set();
+		let buf = "";
+		const onLine = (line) => {
+			if (!line.startsWith("{")) return;
+			let e;
+			try {
+				e = JSON.parse(line);
+			} catch {
+				return;
+			}
+			if (e.Action === "build-output" || e.Action === "build-fail") {
+				const ip = String(e.ImportPath ?? "").replace(/\s.*$/, "");
+				if (e.Output) buildOut.set(ip, (buildOut.get(ip) ?? "") + e.Output);
+				return;
+			}
+			if (!e.Package) return;
+			const x = get(e.Package);
+			if (["run", "pass", "fail", "skip"].includes(e.Action)) onProgress?.(`${e.Package}${e.Test ? ` ${e.Test}` : ""}: ${e.Action}`);
+			if (e.Test) {
+				let t = x.tests.get(e.Test);
+				if (!t) x.tests.set(e.Test, (t = { status: undefined, out: [] }));
+				if (e.Action === "output") {
+					t.out.push(e.Output);
+					x.out.push(e.Output);
+				} else if (["pass", "fail", "skip"].includes(e.Action)) t.status = e.Action;
+			} else if (e.Action === "output") x.out.push(e.Output);
+			else if (["pass", "fail", "skip"].includes(e.Action)) {
+				x.status = e.Action;
+				x.elapsed = e.Elapsed ?? 0;
+				const p = byIp.get(e.Package);
+				if (p && !done.has(p.dir)) {
+					done.add(p.dir);
+					const res = finish(p);
+					results.set(p.dir, res);
+					onUnit?.(p.dir, res);
+				}
+			}
+		};
+		const r = await runProc({
+			cmd: goBin,
+			args,
+			cwd,
+			env,
+			signal,
+			nice,
+			timeoutMs: goTimeout === 0 ? undefined : goTimeout * Math.max(1, Math.ceil(pkgs.length / threads)) + 120000,
+			onData: (d, stream) => {
+				if (stream !== "stdout") return;
+				buf += d;
+				let i;
+				while ((i = buf.indexOf("\n")) >= 0) {
+					onLine(buf.slice(0, i));
+					buf = buf.slice(i + 1);
+				}
+			},
+		});
+		if (buf) onLine(buf);
+		// build errors printed to stderr by older Go versions: "# importpath" blocks
+		let cur;
+		for (const line of r.stderr.split("\n")) {
+			const h = line.match(/^# (\S+)/);
+			if (h) {
+				cur = h[1];
+				continue;
+			}
+			if (cur && line.trim()) buildOut.set(cur, (buildOut.get(cur) ?? "") + `${line}\n`);
+		}
+		for (const p of pkgs) if (!done.has(p.dir)) results.set(p.dir, finish(p, r.killed, r.stderr));
+		return { results, ms: r.ms, killed: r.killed };
+	},
+};
+
+export default adapter;
+export { parseGoFile, closure as goClosure };
+export const goBinary = () => which("go", { skipDir: SHIM_DIR }) ?? "go";