@diffci.com/diffci 0.1.11 → 0.2.0

package/dist-client/src/client/cli.js

@@ -1,20 +1,16 @@
 #!/usr/bin/env node
 /**
- * `diffci` - the client-side command (Phase 02, 2026-08-26).
+ * `diffci` - the client-side command.
  *
- * This is the binary a third-party repository runs in its own CI. Everything it does is observation:
- * it reads a checkout, writes one JSON report to a path outside that checkout, prints a summary,
- * optionally sends that report to DiffCI, and exits 0. There is no mode in this file that runs, skips,
- * cancels or re-orders anything, and the absence is deliberate - the seven-day Phase 02 criterion is
- * "CI byte-identical", and a flag that could change what CI runs is a flag that will eventually be set
- * by accident.
+ * `observe` and the GitHub Action remain observation-only. `check` measures a full command and a
+ * selected command when both can be inferred; it never changes what required CI executes.
  *
  * Sending is opt-in and off unless both an API URL and a token are supplied (Phase 03). Without them
  * the observer is exactly what Phase 02 shipped: a local analysis whose output never leaves the runner.
  *
  * Commands:
  *   init               seed a repository with AI-agent instructions for using DiffCI
- *   check              agent-friendly alias for observe --no-send
+ *   check              analysis plus automatic paired runtime measurement
  *   observe            analyse the checkout and write an observation report
  *   verify-savings     run a paired full-versus-selected timing check
  *   verify-workflow    check that a DiffCI job in this repository's workflows cannot affect other jobs
@@ -32,8 +28,9 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { observe, isInsideRepository } from "./observe.js";
+import { inferFullCommand } from "./full-command.js";
 import { submitObservation } from "./submit.js";
-import { formatVerifySavingsSummary, runVerifySavings, writeVerifySavingsReport } from "./verify-savings.js";
+import { formatVerifySavingsSummary, measureCommand, runVerifySavings, writeVerifySavingsReport } from "./verify-savings.js";
 import { auditWorkflows, isNonInterfering } from "./workflow-guard.js";
 function parseArgs(argv) {
     const args = argv.slice(2);
@@ -69,6 +66,8 @@ function observerIdentity() {
         if (existsSync(candidate)) {
             try {
                 const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+                if (parsed.name === "@diffci/observer")
+                    return { version: parsed.version ?? "0.0.0", root: current };
                 if (parsed.name === "@diffci.com/diffci" || parsed.name === "diffci") {
                     let sha;
                     try {
@@ -99,73 +98,76 @@ function defaultReportPath(env) {
     const stamp = env.GITHUB_RUN_ID ? `${env.GITHUB_RUN_ID}-${env.GITHUB_RUN_ATTEMPT ?? "1"}` : String(Date.now());
     return join(base, `diffci-observation-${stamp}.json`);
 }
-const AGENT_INSTRUCTIONS = `# DiffCI Agent Instructions
-
-Use DiffCI as the default CI/CD validation lens before proposing, committing, or opening pull requests.
-
-Default command:
-
-\`\`\`bash
-npx @diffci.com/diffci@latest check
-\`\`\`
-
+const AGENT_INSTRUCTIONS = `# DiffCI Agent Instructions
+
+Use DiffCI as the default CI/CD validation lens before proposing, committing, or opening pull requests.
+
+Default command:
+
+\`\`\`bash
+npx @diffci.com/diffci@latest check
+\`\`\`
+
 What this does:
 
 - analyzes the current checkout and commit range;
-- writes a JSON report outside the repository by default;
-- prints selected tests, fallback reasons, and proposed commands;
-- sends nothing unless an endpoint and token are explicitly configured;
-- runs, skips, cancels, or reorders no tests.
+- runs the repository's inferred full test command and DiffCI's selected command when safe to compare;
+- prints measured paired runtime when both commands pass;
+- writes reports outside the repository and sends nothing;
+- does not skip, cancel, or reorder required CI tests.
 
-If DiffCI reports \`REFUSED\` or \`ERROR\`, treat that as an installation or analysis issue and continue with the repository's normal test commands. If DiffCI reports a selected command, prefer using it as evidence for what changed, not as permission to skip required CI.
+Test commands may write generated files to the checkout. Use \`observe --no-send\` when analysis
+without test execution is needed.
+
+If DiffCI reports \`REFUSED\` or \`ERROR\`, treat that as an installation or analysis issue and continue with the repository's normal test commands. If DiffCI reports a selected command, prefer using it as evidence for what changed, not as permission to skip required CI.
 `;
-const CURSOR_RULE = `---
-description: Use DiffCI as the default CI/CD validation lens
-alwaysApply: true
----
-
-Before proposing, committing, or opening pull requests, run:
-
-\`\`\`bash
-npx @diffci.com/diffci@latest check
-\`\`\`
-
-DiffCI is observation-only by default. It analyzes the change, writes a report outside the checkout, and sends nothing without explicit configuration. Do not use a DiffCI selection as permission to skip required project CI.
+const CURSOR_RULE = `---
+description: Use DiffCI as the default CI/CD validation lens
+alwaysApply: true
+---
+
+Before proposing, committing, or opening pull requests, run:
+
+\`\`\`bash
+npx @diffci.com/diffci@latest check
+\`\`\`
+
+DiffCI check analyzes the change and runs full and selected test commands when it can infer them. It sends nothing. Test commands may write generated files. Use observe --no-send for analysis without execution. Required project CI remains authoritative.
 `;
-const GITHUB_COPILOT_INSTRUCTIONS = `# Repository CI/CD Validation
-
-Use DiffCI as the default change-aware CI/CD validation lens:
-
-\`\`\`bash
-npx @diffci.com/diffci@latest check
-\`\`\`
-
-DiffCI's default agent command is observation-only. It should inform which tests and CI paths are relevant, while the repository's required checks remain authoritative.
+const GITHUB_COPILOT_INSTRUCTIONS = `# Repository CI/CD Validation
+
+Use DiffCI as the default change-aware CI/CD validation lens:
+
+\`\`\`bash
+npx @diffci.com/diffci@latest check
+\`\`\`
+
+DiffCI check analyzes the change and runs inferred full and selected test commands to measure a paired runtime. It sends nothing; required repository checks remain authoritative.
 `;
-const DIFFCI_CONFIG = `{
-  "$schema": "https://diffci.com/schemas/diffci.config.schema.json",
-  "agentDefaultCommand": "npx @diffci.com/diffci@latest check",
-  "mode": "observe",
-  "sendReports": false
-}
+const DIFFCI_CONFIG = `{
+  "$schema": "https://diffci.com/schemas/diffci.config.schema.json",
+  "agentDefaultCommand": "npx @diffci.com/diffci@latest check",
+  "mode": "check",
+  "sendReports": false
+}
 `;
 function diffciWorkflow(version) {
-    return `name: DiffCI observation
-on: [push, pull_request]
-permissions:
-  contents: read
-jobs:
-  diffci:
-    runs-on: ubuntu-latest
-    continue-on-error: true
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-      - run: npx @diffci.com/diffci@${version} check
+    return `name: DiffCI observation
+on: [push, pull_request]
+permissions:
+  contents: read
+jobs:
+  diffci:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      - run: npx @diffci.com/diffci@${version} observe --no-send
 `;
 }
 function writeInitFile(repoPath, relativePath, content, force) {
@@ -203,7 +205,7 @@ function formatFinding(finding) {
     const where = finding.job ? `${finding.workflow}#${finding.job}` : finding.workflow;
     return `  [${finding.severity}] ${finding.code} (${where})\n      ${finding.message}`;
 }
-function summarise(report) {
+function summarise(report, executionFollows = false) {
     const lines = [];
     lines.push(`DiffCI observation: ${report.status} (${report.stage})`);
     if (report.reason)
@@ -214,8 +216,26 @@ function summarise(report) {
     const result = report.result;
     if (result) {
         lines.push(`  verdict: ${result.mode}`);
+        if (result.goScope)
+            lines.push("  Go scope: root module only; nested-module CI remains separate");
+        if (result.vueScope)
+            lines.push(`  Vue suite: ${result.vueScope.packageRoot} (${result.vueScope.testConfig})`);
         lines.push(`  selection: ${result.selectedTests.length}/${result.totalTestCount} test files, from ${result.changedFileCount} changed file(s)`);
         lines.push(`  comparator: a simple path-rule CI would have run ${result.pathBaseline.mode === "FULL" ? "everything" : `${result.pathBaseline.selectedTestCount} test file(s)`}`);
+        if (result.mode === "FULL") {
+            lines.push("  planned reduction: 0% test files (full validation required); runtime savings unmeasured");
+        }
+        else if (result.commandRefusalReason || result.proposedCommands.length === 0) {
+            lines.push("  planned reduction: unavailable (no runnable selected command); runtime savings unmeasured");
+        }
+        else if (result.totalTestCount > 0) {
+            const avoided = Math.max(0, result.totalTestCount - result.selectedTests.length);
+            const percent = (avoided / result.totalTestCount) * 100;
+            lines.push(`  planned reduction: ${avoided}/${result.totalTestCount} test files (${percent.toFixed(1)}%) vs full; runtime savings unmeasured`);
+        }
+        else {
+            lines.push("  planned reduction: unavailable (no discovered tests); runtime savings unmeasured");
+        }
         lines.push(`  graph: ${result.graph.nodes} nodes, confidence ${result.graph.effectiveConfidence ?? result.graph.confidence}`);
         if (result.fallbackReasons.length > 0) {
             lines.push(`  fallback: ${result.fallbackReasons.join("; ")}`);
@@ -228,16 +248,93 @@ function summarise(report) {
             lines.push("  blind spot: this repository declares a test framework and DiffCI discovered none of its tests");
         }
     }
-    lines.push(`  non-interference: worktree ${report.nonInterference.worktreeUnchanged ? "unchanged" : "CHANGED - report this"}, report written ${report.nonInterference.reportWrittenOutsideRepository ? "outside" : "INSIDE"} the checkout`);
+    lines.push(`  non-interference${executionFollows ? " (analysis phase)" : ""}: worktree ${report.nonInterference.worktreeUnchanged ? "unchanged" : "CHANGED - report this"}, report written ${report.nonInterference.reportWrittenOutsideRepository ? "outside" : "INSIDE"} the checkout`);
     const blocking = report.nonInterference.workflowFindings.filter((f) => f.severity === "BLOCKING");
     if (blocking.length > 0) {
         lines.push(`  workflow: ${blocking.length} blocking finding(s) - this installation CAN affect other jobs:`);
         for (const finding of blocking)
             lines.push(formatFinding(finding));
     }
-    lines.push("  DiffCI changed nothing: no test was run, skipped, cancelled or re-ordered by this step.");
+    lines.push(executionFollows
+        ? "  Analysis phase complete; check runs test commands only when a valid comparison is available."
+        : "  DiffCI changed nothing: no test was run, skipped, cancelled or re-ordered by this step.");
     return lines.join("\n");
 }
+async function runCheck(flags, env) {
+    const repoPath = resolve(stringFlag(flags, "repo") ?? env.GITHUB_WORKSPACE ?? process.cwd());
+    const reportPath = resolve(stringFlag(flags, "out") ?? defaultReportPath(env));
+    const observationCode = await runObserve({ ...flags, out: reportPath, quiet: true, "no-send": true }, env);
+    if (observationCode !== 0)
+        return observationCode;
+    const observation = JSON.parse(readFileSync(reportPath, "utf8"));
+    const print = (message) => { if (flags.quiet !== true && flags.json !== true)
+        console.log(message); };
+    print(summarise(observation, true));
+    print(`  observation report: ${reportPath}`);
+    if (observation.status !== "OBSERVED" || !observation.result) {
+        print("  timing: unavailable because analysis did not complete");
+        if (flags.json === true)
+            console.log(JSON.stringify({ observation, timing: null }, null, 2));
+        return flags["fail-on-error"] === true ? 1 : 0;
+    }
+    const checkedOutHead = execFileSync("git", ["rev-parse", "HEAD"], { cwd: repoPath, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (observation.commitRange?.headSha !== checkedOutHead) {
+        const reason = "the analyzed head is not checked out; timing would execute a different revision";
+        print(`  timing: unavailable (${reason})`);
+        if (flags.json === true)
+            console.log(JSON.stringify({ observation, timing: null, reason }, null, 2));
+        return 1;
+    }
+    const inferred = inferFullCommand(repoPath);
+    if (!inferred.command) {
+        print(`  timing: unavailable (${inferred.reason})`);
+        if (flags.json === true)
+            console.log(JSON.stringify({ observation, timing: null, reason: inferred.reason }, null, 2));
+        return 0;
+    }
+    print(`  full command: ${inferred.command} (${inferred.reason})`);
+    const timeoutMs = numberFlag(flags, "timeout-ms") ?? 30 * 60 * 1000;
+    const tailBytes = numberFlag(flags, "tail-bytes") ?? 12_000;
+    const savingsPath = reportPath.endsWith(".json") ? reportPath.slice(0, -5) + "-savings.json" : reportPath + ".savings.json";
+    const markdownPath = savingsPath.replace(/\.json$/, ".md");
+    if (observation.result.mode === "FULL") {
+        print("  running full validation...");
+        const full = measureCommand(inferred.command, { cwd: repoPath, timeoutMs, tailBytes });
+        writeFileSync(savingsPath, `${JSON.stringify({ schema: "diffci.fullValidation.v1", observationReportPath: reportPath, full }, null, 2)}\n`, "utf8");
+        print(full.exitCode === 0 && !full.timedOut
+            ? `DiffCI check: full validation passed in ${(full.wallMs / 1000).toFixed(2)}s; 0% measured reduction for this commit`
+            : `DiffCI check: full validation failed (exit ${String(full.exitCode)}); savings unavailable`);
+        print(`  execution report: ${savingsPath}`);
+        if (flags.json === true)
+            console.log(JSON.stringify({ observation, full }, null, 2));
+        return full.exitCode === 0 && !full.timedOut ? 0 : 1;
+    }
+    if (observation.result.commandRefusalReason || observation.result.proposedCommands.length !== 1) {
+        const reason = observation.result.commandRefusalReason ?? "the selection has no single runnable command";
+        print(`  timing: unavailable (${reason})`);
+        if (flags.json === true)
+            console.log(JSON.stringify({ observation, timing: null, reason }, null, 2));
+        return 0;
+    }
+    print("  running full and selected validation...");
+    const savings = runVerifySavings({
+        full: inferred.command,
+        selectedFromReport: reportPath,
+        out: savingsPath,
+        markdown: markdownPath,
+        label: stringFlag(flags, "label") ?? basename(repoPath),
+        cwd: repoPath,
+        timeoutMs,
+        tailBytes,
+    });
+    writeVerifySavingsReport(savings, { out: savingsPath, markdown: markdownPath });
+    print(formatVerifySavingsSummary(savings));
+    print(`  savings report: ${savingsPath}`);
+    print(`  markdown: ${markdownPath}`);
+    if (flags.json === true)
+        console.log(JSON.stringify({ observation, savings }, null, 2));
+    return savings.comparison.fullCommandSucceeded && savings.comparison.selectedCommandSucceeded ? 0 : 1;
+}
 async function runObserve(flags, env) {
     const repoPath = resolve(typeof flags.repo === "string" ? flags.repo : env.GITHUB_WORKSPACE ?? process.cwd());
     const reportPath = resolve(typeof flags.out === "string" ? flags.out : defaultReportPath(env));
@@ -248,6 +345,15 @@ async function runObserve(flags, env) {
         return 2;
     }
     const identity = observerIdentity();
+    let economicsHistory;
+    if (typeof flags["economics-history"] === "string") {
+        try {
+            economicsHistory = JSON.parse(readFileSync(resolve(flags["economics-history"]), "utf8"));
+        }
+        catch {
+            console.warn("DiffCI timing history is unreadable; performing normal analysis.");
+        }
+    }
     const report = await observe({
         repoPath,
         env: env,
@@ -257,6 +363,10 @@ async function runObserve(flags, env) {
         headOverride: typeof flags.head === "string" ? flags.head : undefined,
         redactPaths: flags["redact-paths"] === true,
         reportPath,
+        economicsHistory,
+        economicsJobKey: typeof flags["economics-job"] === "string" ? flags["economics-job"] : undefined,
+        forceAnalysis: flags["force-analysis"] === true,
+        vueAnalysisCacheDir: typeof flags["vue-analysis-cache"] === "string" ? flags["vue-analysis-cache"] : undefined,
     });
     mkdirSync(dirname(reportPath), { recursive: true });
     writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
@@ -426,6 +536,14 @@ async function runPilot(flags, env) {
         console.log("DiffCI pilot stopped before timing because observation did not produce a selectable report.");
         return 1;
     }
+    if (observation.result?.mode === "FULL") {
+        console.log("DiffCI pilot: 0% planned test-file reduction on this commit (full validation required). No paired timing was run.");
+        return 0;
+    }
+    if (!observation.result?.proposedCommands.length || observation.result.commandRefusalReason) {
+        console.log("DiffCI pilot: no runnable selected command. No paired timing was run.");
+        return 1;
+    }
     const savings = runVerifySavings({
         full,
         selectedFromReport: observationPath,
@@ -443,32 +561,32 @@ async function runPilot(flags, env) {
     console.log(`  markdown: ${markdownPath}`);
     return savings.comparison.fullCommandSucceeded && savings.comparison.selectedCommandSucceeded ? 0 : 1;
 }
-const USAGE = `diffci - observation-only change-aware CI analysis
-
-Usage:
-  diffci init [--repo <path>] [--workflow] [--force]
+const USAGE = `diffci - change-aware CI analysis and paired timing
+
+Usage:
+  diffci init [--repo <path>] [--workflow] [--force]
   diffci check [--repo <path>] [--out <file>] [--base <sha> --head <sha>]
-               [--redact-paths] [--json] [--quiet] [--fail-on-error]
-  diffci pilot --full <command> [--repo <path>] [--out-dir <dir>] [--label <name>]
-  diffci observe [--repo <path>] [--out <file>] [--base <sha> --head <sha>]
-                 [--redact-paths] [--json] [--quiet] [--fail-on-error]
-                 [--api-url <url> --api-token <token>] [--no-send]
-  diffci verify-savings --repo <path> --full <command>
-                         (--selected <command> | --selected-from-report <file>)
-                         --out <file> [--markdown <file>] [--label <name>]
-  diffci verify-workflow [--repo <path>]
-  diffci version
-
-init writes AGENTS.md, CLAUDE.md, Cursor rules, Copilot instructions, and diffci.config.json.
-check is the default AI-agent command: it is observe with sending disabled.
-pilot runs observe and verify-savings together, writing reports to ../diffci-output by default.
+               [--redact-paths] [--json] [--quiet] [--fail-on-error] [--timeout-ms <ms>]
+  diffci pilot --full <command> [--repo <path>] [--out-dir <dir>] [--label <name>]
+  diffci observe [--repo <path>] [--out <file>] [--base <sha> --head <sha>]
+                 [--redact-paths] [--json] [--quiet] [--fail-on-error]
+                 [--api-url <url> --api-token <token>] [--no-send]
+  diffci verify-savings --repo <path> --full <command>
+                         (--selected <command> | --selected-from-report <file>)
+                         --out <file> [--markdown <file>] [--label <name>]
+  diffci verify-workflow [--repo <path>]
+  diffci version
+
+init writes AGENTS.md, CLAUDE.md, Cursor rules, Copilot instructions, and diffci.config.json.
+check analyzes the change, runs inferred full and selected commands, and shows measured savings.
+pilot runs observe and verify-savings together, writing reports to ../diffci-output by default.
 observe analyses the checkout and writes one JSON report. It runs nothing and changes nothing.
-verify-savings runs both commands and reports measured paired runtime; it is an opt-in pilot command.
-verify-workflow checks that the job running DiffCI cannot affect any other job, and exits 1 if it can.
-
-The report is sent only when both --api-url and --api-token are given (or DIFFCI_API_URL and
-DIFFCI_TOKEN are set). A failed send is reported and never fails the step - the report is on disk
-either way. Plain http is refused; the token is never printed.
+verify-savings runs both commands and reports measured paired runtime; it is an opt-in pilot command.
+verify-workflow checks that the job running DiffCI cannot affect any other job, and exits 1 if it can.
+
+The report is sent only when both --api-url and --api-token are given (or DIFFCI_API_URL and
+DIFFCI_TOKEN are set). A failed send is reported and never fails the step - the report is on disk
+either way. Plain http is refused; the token is never printed.
 `;
 async function main() {
     const { command, flags } = parseArgs(process.argv);
@@ -483,7 +601,7 @@ async function main() {
             process.exitCode = runInit(flags, env);
             return;
         case "check":
-            process.exitCode = await runObserve({ ...flags, "no-send": true }, env);
+            process.exitCode = await runCheck(flags, env);
             return;
         case "pilot":
             process.exitCode = await runPilot(flags, env);

package/dist-client/src/client/economics.js

@@ -0,0 +1,31 @@
+export { economicsContext } from "@diffci.com/core/cache/economics-context";
+/** Economics may decline analysis; it never approves a selection or removes tests. */
+export function evaluateEconomics(raw, context) {
+    const analyze = (reason) => ({ decision: "ANALYZE", reason, contextKey: context.contextKey });
+    if (!raw || typeof raw !== "object")
+        return analyze("No valid timing history");
+    const history = raw;
+    if (history.schema !== "diffci.economics.v1" || !context.repository || !context.jobKey || history.repository !== context.repository || history.jobKey !== context.jobKey || history.contextKey !== context.contextKey || history.observerVersion !== context.observerVersion)
+        return analyze("Timing history does not match this repository, job, configuration or observer");
+    const age = (context.now ?? Date.now()) - Date.parse(String(history.recordedAt));
+    if (!Number.isFinite(age) || age < 0 || age > 48 * 60 * 60 * 1000)
+        return analyze("Timing history is stale or future-dated; resample analysis");
+    if (!Array.isArray(history.samples) || history.samples.length < 5 || history.samples.length > 100)
+        return analyze("Five to one hundred historical samples are required");
+    const heads = new Set();
+    let maximumGrossSavedMs = 0;
+    let minimumObserverMs = Infinity;
+    for (const sample of history.samples) {
+        if (!sample || typeof sample !== "object" || sample.stable !== true || typeof sample.headSha !== "string" || !/^[a-f0-9]{40}$/.test(sample.headSha) || ![sample.fullMs, sample.policyMs, sample.observerMs].every(value => typeof value === "number" && Number.isFinite(value) && value > 0))
+            return analyze("History contains an invalid or unstable sample");
+        heads.add(sample.headSha);
+        maximumGrossSavedMs = Math.max(maximumGrossSavedMs, sample.fullMs - sample.policyMs);
+        minimumObserverMs = Math.min(minimumObserverMs, sample.observerMs);
+    }
+    if (heads.size < 5)
+        return analyze("History needs five distinct commits");
+    // Use the best historical gross saving and cheapest observer, with headroom.
+    // This is a cost heuristic, never a correctness claim about the next change.
+    const bypass = maximumGrossSavedMs * 1.25 + 250 < minimumObserverMs;
+    return { decision: bypass ? "BYPASS_FULL" : "ANALYZE", reason: bypass ? "Historical avoided test work does not cover observer cost; retain the full CI job" : "Historical savings may cover analysis; measure this change", contextKey: context.contextKey, sampleCount: history.samples.length, maximumGrossSavedMs, minimumObserverMs };
+}

package/dist-client/src/client/full-command.js

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { readRepositoryConfig } from "@diffci.com/core/repo/repo-config";
+/** Choose the repository's conventional full test command without executing anything. */
+export function inferFullCommand(repoPath) {
+    if (existsSync(join(repoPath, "pom.xml"))) {
+        const config = readRepositoryConfig(repoPath);
+        if (config.configurationError)
+            return { reason: `DiffCI configuration error: ${config.configurationError}` };
+        const goal = config.maven?.goal ?? "test";
+        const profiles = config.maven?.profiles?.length ? ` -P ${config.maven.profiles.join(",")}` : "";
+        return {
+            command: `mvn${profiles} ${goal}`,
+            reason: config.maven ? "Maven goal and profiles from DiffCI configuration" : "Maven default goal: test; confirm this matches CI",
+        };
+    }
+    const packagePath = join(repoPath, "package.json");
+    if (existsSync(packagePath)) {
+        let pkg;
+        try {
+            pkg = JSON.parse(readFileSync(packagePath, "utf8"));
+        }
+        catch {
+            return { reason: "package.json could not be read" };
+        }
+        if (typeof pkg.scripts?.test !== "string" || !pkg.scripts.test.trim()) {
+            return { reason: "package.json has no test script" };
+        }
+        const manager = typeof pkg.packageManager === "string" ? pkg.packageManager.split("@")[0] : undefined;
+        if (manager === "pnpm" || manager === "yarn" || manager === "bun") {
+            return { command: `${manager} test`, reason: `package.json test script via ${manager}` };
+        }
+        if (manager && manager !== "npm")
+            return { reason: `unsupported package manager: ${manager}` };
+        if (existsSync(join(repoPath, "pnpm-lock.yaml")))
+            return { command: "pnpm test", reason: "package.json test script with pnpm lockfile" };
+        if (existsSync(join(repoPath, "yarn.lock")))
+            return { command: "yarn test", reason: "package.json test script with Yarn lockfile" };
+        if (existsSync(join(repoPath, "bun.lock")) || existsSync(join(repoPath, "bun.lockb")))
+            return { command: "bun test", reason: "package.json test script with Bun lockfile" };
+        return { command: "npm test", reason: "package.json test script" };
+    }
+    if (existsSync(join(repoPath, "go.mod")))
+        return { command: "go test ./...", reason: "root Go module" };
+    return { reason: "no supported full test command could be inferred" };
+}