@poetic-ai/poetic 1.42.0

package/dist/chunk-3ZPQLGV7.js

@@ -0,0 +1,2904 @@
+import {
+  extractChangedFilesMeta
+} from "./chunk-CFBIG37O.js";
+import {
+  hasRecordedTestExecutionEvidence,
+  hasUnrecognizedRecordedTestStatus,
+  normalizeRecordedTestStatus
+} from "./chunk-KT6VHSPF.js";
+import {
+  stripAnsiSequences
+} from "./chunk-VTW7HP3R.js";
+import {
+  changedFilesRequireVerification,
+  resolveVerificationChannelScope,
+  selectScopedTestCommands
+} from "./chunk-KP6YILMU.js";
+import {
+  extractDiffText
+} from "./chunk-ETYDXCK7.js";
+import {
+  JUDGE_FEATURE_FLAGS
+} from "./chunk-BSE4R6XD.js";
+import {
+  createVerificationCommandEnv,
+  runVerificationCommand
+} from "./chunk-D5RYINO7.js";
+import {
+  detectProjectCapabilities,
+  hasProjectLanguage
+} from "./chunk-FHOWVDF5.js";
+import {
+  isProjectTestPath,
+  languageForProjectPath
+} from "./chunk-UDMS5AD3.js";
+import {
+  tailLines,
+  truncateToByteLimit
+} from "./chunk-TSXGRLPR.js";
+import {
+  describeVerificationCommand,
+  detectExitZeroVerifyFailure,
+  detectVerificationToolUnavailable,
+  detectZeroCollectedTests,
+  isPythonStdlibUnittestCommand,
+  resolveVerificationExitCode,
+  selectFallbacksForCommand
+} from "./chunk-2QLYTVYX.js";
+
+// src/core/judge/lint-on-diff.ts
+function isTimeoutLike(error) {
+  return error.timedOut === true || error.killed === true || error.signal === "SIGTERM";
+}
+function isToolUnavailable(exitCode, output, error) {
+  const normalized = output.toLowerCase();
+  return error?.code === "ENOENT" || exitCode === 127 || normalized.includes("command not found") || normalized.includes("not recognized as an internal or external command") || normalized.includes("no such file or directory");
+}
+function verificationCoverageForLint(params) {
+  if (params.error && isTimeoutLike(params.error)) {
+    return {
+      status: "unverified",
+      command: params.command,
+      reason: "Lint command timed out or was interrupted."
+    };
+  }
+  if (isToolUnavailable(params.exitCode, params.output, params.error)) {
+    return {
+      status: "skipped_tool_unavailable",
+      command: params.command,
+      reason: "Lint command was unavailable in the execution environment."
+    };
+  }
+  return { status: "verified", command: params.command };
+}
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    return String(error.message);
+  }
+  return String(error);
+}
+function extractJsonObject(text) {
+  const raw = String(text ?? "").trim();
+  if (!raw) return null;
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start < 0 || end < 0 || end <= start) return null;
+  const candidate = raw.slice(start, end + 1);
+  try {
+    return { text: candidate, parsed: JSON.parse(candidate) };
+  } catch {
+    return null;
+  }
+}
+function formatBiomeDiagnosticSummary(extracted) {
+  if (!extracted) return "";
+  try {
+    const json = extracted.parsed;
+    const diagnostics = Array.isArray(json?.diagnostics) ? json.diagnostics : [];
+    const lines = [];
+    for (const diag of diagnostics) {
+      const loc = diag?.location;
+      const filePath = loc?.path;
+      if (typeof filePath !== "string" || filePath.trim().length === 0) continue;
+      const span = loc?.span;
+      const start = span?.start;
+      const line = typeof start?.line === "number" ? start.line : 1;
+      const column = typeof start?.column === "number" ? start.column : 1;
+      const category = typeof diag?.category === "string" ? diag.category : typeof diag?.code === "string" ? diag.code : typeof diag?.rule === "string" ? diag.rule : typeof diag?.severity === "string" ? diag.severity : "issue";
+      lines.push(`${filePath}:${line}:${column} ${category}`);
+    }
+    return lines.length > 0 ? lines.slice(0, 200).join("\n") : "";
+  } catch {
+    return "";
+  }
+}
+function isBiomeLintCommand(command) {
+  return /\bbiome\s+check\b/.test(command);
+}
+function appendBiomeSinceArg(command, baseBranch) {
+  if (!baseBranch || !isBiomeLintCommand(command) || !command.includes("--changed")) {
+    return command;
+  }
+  if (command.includes("--since=")) {
+    return command;
+  }
+  if (!/^[A-Za-z0-9._/-]+$/.test(baseBranch) || baseBranch.startsWith("-")) {
+    return command;
+  }
+  return command.replace(/\s--changed(?=\s|$)/, ` --changed --since=${baseBranch}`);
+}
+function buildBiomeArtifactResult(params) {
+  const extracted = extractJsonObject(params.stdoutRaw) ?? extractJsonObject(params.combined);
+  const jsonCandidateText = extracted?.text ?? params.stdoutRaw;
+  const diagnosticSummary = formatBiomeDiagnosticSummary(
+    extracted ?? (jsonCandidateText ? { text: jsonCandidateText, parsed: void 0 } : null)
+  );
+  const outputTail = truncateToByteLimit(
+    [diagnosticSummary, tailLines(params.combined, params.maxTailLines)].filter(Boolean).join("\n"),
+    1e5
+  );
+  const parsed = params.exitCode === 0 || params.exitCode === 1 ? parseBiomeOutput(jsonCandidateText, params.exitCode, extracted?.parsed) : null;
+  const noopLint = params.combined.includes("No files were processed") || params.combined.includes("No files were processed in the specified paths");
+  return {
+    exitCode: noopLint ? 0 : params.exitCode,
+    outputTail,
+    result: noopLint || params.exitCode === 0 && (!params.stdoutRaw.trim() || parsed === null) ? {
+      success: true,
+      errorCount: 0,
+      warningCount: 0,
+      fixableCount: 0,
+      filesWithIssues: [],
+      exitCode: 0
+    } : parsed,
+    verificationCoverage: {
+      status: noopLint ? "skipped_not_relevant" : "verified",
+      command: params.command
+    }
+  };
+}
+async function runLintOnDiffWithArtifacts(workingDirectory, options) {
+  const start = Date.now();
+  const timeoutMs = options?.timeoutMs;
+  const maxTailLines = options?.tailLines ?? 200;
+  if (options?.command && options.command.trim().length > 0) {
+    const scopedCommand = options.command;
+    const scopedLanguage = describeVerificationCommand(scopedCommand).language;
+    try {
+      const result = await runVerificationCommand(scopedCommand, {
+        cwd: workingDirectory,
+        timeoutMs,
+        abortSignal: options?.abortSignal
+      });
+      const { exitCode: resolvedExitCode } = resolveVerificationExitCode(scopedCommand, result);
+      const rawOutput = String(result.all ?? "");
+      const exitZeroFailure = resolvedExitCode === 0 ? detectExitZeroVerifyFailure(scopedCommand, rawOutput)?.message : void 0;
+      const exitCode = exitZeroFailure ? 1 : resolvedExitCode;
+      const output = exitZeroFailure ? `${rawOutput}
+${exitZeroFailure}`.trim() : rawOutput;
+      return {
+        command: scopedCommand,
+        exitCode,
+        durationMs: Date.now() - start,
+        outputTail: truncateToByteLimit(tailLines(output, maxTailLines), 1e5),
+        result: {
+          success: exitCode === 0,
+          errorCount: exitCode === 0 ? 0 : 1,
+          warningCount: 0,
+          fixableCount: 0,
+          filesWithIssues: [],
+          exitCode
+        },
+        verificationCoverage: verificationCoverageForLint({
+          command: scopedCommand,
+          exitCode,
+          output
+        }),
+        language: scopedLanguage
+      };
+    } catch (error) {
+      const err = error;
+      const message = errorMessage(error);
+      const timedOut = isTimeoutLike(err);
+      const exitCode = timedOut ? 124 : 1;
+      return {
+        command: scopedCommand,
+        exitCode,
+        durationMs: Date.now() - start,
+        outputTail: truncateToByteLimit(tailLines(message, maxTailLines), 1e5),
+        result: timedOut ? null : {
+          success: false,
+          errorCount: 1,
+          warningCount: 0,
+          fixableCount: 0,
+          filesWithIssues: [],
+          exitCode
+        },
+        verificationCoverage: verificationCoverageForLint({
+          command: scopedCommand,
+          exitCode,
+          output: message,
+          error: err
+        }),
+        language: scopedLanguage
+      };
+    }
+  }
+  const detectedProjectLintCommand = detectProjectCapabilities(workingDirectory).verification.lint[0];
+  const projectLintCommand = detectedProjectLintCommand ? appendBiomeSinceArg(detectedProjectLintCommand, options?.baseBranch) : void 0;
+  const projectLintLanguage = projectLintCommand ? describeVerificationCommand(projectLintCommand).language : void 0;
+  if (projectLintCommand) {
+    try {
+      const result = await runVerificationCommand(projectLintCommand, {
+        cwd: workingDirectory,
+        timeoutMs,
+        abortSignal: options?.abortSignal
+      });
+      const { exitCode: resolvedExitCode } = resolveVerificationExitCode(
+        projectLintCommand,
+        result
+      );
+      const rawOutput = String(result.all ?? "");
+      const exitZeroFailure = resolvedExitCode === 0 ? detectExitZeroVerifyFailure(projectLintCommand, rawOutput)?.message : void 0;
+      const exitCode = exitZeroFailure ? 1 : resolvedExitCode;
+      const output = exitZeroFailure ? `${rawOutput}
+${exitZeroFailure}`.trim() : rawOutput;
+      if (isBiomeLintCommand(projectLintCommand)) {
+        const biomeArtifact = buildBiomeArtifactResult({
+          command: projectLintCommand,
+          exitCode,
+          durationMs: Date.now() - start,
+          combined: output,
+          stdoutRaw: String(result.stdout ?? result.all ?? ""),
+          maxTailLines
+        });
+        return {
+          command: projectLintCommand,
+          durationMs: Date.now() - start,
+          ...biomeArtifact,
+          language: projectLintLanguage
+        };
+      }
+      return {
+        command: projectLintCommand,
+        exitCode,
+        durationMs: Date.now() - start,
+        outputTail: truncateToByteLimit(tailLines(output, maxTailLines), 1e5),
+        result: {
+          success: exitCode === 0,
+          errorCount: exitCode === 0 ? 0 : 1,
+          warningCount: 0,
+          fixableCount: 0,
+          filesWithIssues: [],
+          exitCode
+        },
+        verificationCoverage: verificationCoverageForLint({
+          command: projectLintCommand,
+          exitCode,
+          output
+        }),
+        language: projectLintLanguage
+      };
+    } catch (error) {
+      const err = error;
+      const message = errorMessage(error);
+      const timedOut = isTimeoutLike(err);
+      const exitCode = timedOut ? 124 : 1;
+      return {
+        command: projectLintCommand,
+        exitCode,
+        durationMs: Date.now() - start,
+        outputTail: truncateToByteLimit(tailLines(message, maxTailLines), 1e5),
+        result: timedOut ? null : {
+          success: false,
+          errorCount: 1,
+          warningCount: 0,
+          fixableCount: 0,
+          filesWithIssues: [],
+          exitCode
+        },
+        verificationCoverage: verificationCoverageForLint({
+          command: projectLintCommand,
+          exitCode,
+          output: message,
+          error: err
+        }),
+        language: projectLintLanguage
+      };
+    }
+  }
+  const outputTail = "Skipped lint gate: no project lint command detected by resolver.";
+  const skippedCommand = "lint (not configured)";
+  return {
+    command: skippedCommand,
+    exitCode: 127,
+    durationMs: Date.now() - start,
+    outputTail,
+    result: null,
+    verificationCoverage: {
+      status: "skipped_no_command",
+      command: skippedCommand,
+      reason: "No project lint command was detected by the capabilities resolver."
+    },
+    language: "unknown"
+  };
+}
+function parseBiomeOutput(output, exitCode, preParsed) {
+  try {
+    const json = preParsed !== void 0 ? preParsed : JSON.parse(output);
+    const summary = json.summary ?? {};
+    const errorCount = summary.errors ?? 0;
+    const warningCount = summary.warnings ?? 0;
+    const diagnostics = json.diagnostics ?? [];
+    const filesWithIssues = Array.from(
+      new Set(
+        diagnostics.map((d) => d.location?.path).filter((path2) => Boolean(path2))
+      )
+    );
+    const fixableCount = diagnostics.filter((d) => d.canFix === true).length;
+    return {
+      success: exitCode === 0,
+      errorCount,
+      warningCount,
+      fixableCount,
+      filesWithIssues,
+      exitCode,
+      rawOutput: output
+    };
+  } catch (_parseError) {
+    console.debug("[lint-on-diff] Failed to parse Biome JSON, returning null");
+    return null;
+  }
+}
+
+// src/core/project/poetic-vitest-harness.ts
+import { existsSync } from "fs";
+import path from "path";
+function hasPoeticVitestHarness(root) {
+  return existsSync(path.join(root, "scripts", "dynamic-node-options.mjs"));
+}
+function displayArg(value) {
+  return /[\s"'\\]/.test(value) ? JSON.stringify(value) : value;
+}
+function buildExternalVitestRunInvocation(args = []) {
+  const commandArgs = ["--no-install", "vitest", "run", ...args, "--reporter=verbose"];
+  return {
+    display: ["npx", ...commandArgs].map(displayArg).join(" "),
+    cmd: "npx",
+    args: commandArgs
+  };
+}
+
+// src/core/judge/test-gate.ts
+import { existsSync as existsSync2, readdirSync, readFileSync } from "fs";
+import { dirname, extname, join, posix as pathPosix, relative, resolve, sep } from "path";
+import { execa } from "execa";
+var DEFAULT_CONFIG = {
+  timeout: 12e4,
+  testFilePatterns: [
+    /\.(test|spec)\.(ts|js|tsx|jsx)$/,
+    /__tests__\/.*\.(ts|js|tsx|jsx)$/,
+    /(^|\/)test_.*\.py$/,
+    /(^|\/).*_test\.py$/,
+    /_test\.go$/,
+    /(^|\/)tests\/.*\.rs$/,
+    /\.tests\.ps1$/i
+  ]
+};
+var TEST_DISCOVERY_ROOTS = ["tests", "test", "src"];
+var SKIPPED_TEST_DISCOVERY_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".poetic", "dist", "build"]);
+var SOURCE_FILE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
+var JS_LIKE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".mjs", ".cjs"]);
+var MULTI_COMMAND_TEST_BUDGET_MS = 12e4;
+function createVerificationTestEnv() {
+  return createVerificationCommandEnv();
+}
+function extractFailingTestsFromVitestOutput(output) {
+  if (!output) return [];
+  const names = /* @__PURE__ */ new Set();
+  const failHeader = /^\s*FAIL\s+(.+?)\s+>\s+(.+)$/gm;
+  let match = failHeader.exec(output);
+  while (match !== null) {
+    const remainder = (match[2] ?? "").trim();
+    if (remainder) names.add(remainder);
+    match = failHeader.exec(output);
+  }
+  const cross = /^\s*[×]\s+(.+?)(?:\s+\(\d+ms\))?\s*$/gm;
+  let crossMatch = cross.exec(output);
+  while (crossMatch !== null) {
+    const name = (crossMatch[1] ?? "").trim();
+    if (name) names.add(name);
+    crossMatch = cross.exec(output);
+  }
+  return Array.from(names).slice(0, 20);
+}
+function asMeasuredMetrics(metrics) {
+  return { ...metrics, metricsMeasured: metrics.testsRun > 0 };
+}
+function inferSuccessStatusFromMetrics(metrics) {
+  if (metrics.testsRun === 0) {
+    return "error";
+  }
+  return metrics.testsFailed === 0 ? "passed" : "failed";
+}
+function inferSuccessStatusForRunner(_runner, metrics) {
+  return inferSuccessStatusFromMetrics(metrics);
+}
+function isPoeticSuiteSkipOutput(command, output) {
+  if (!/skipping\s+tests/i.test(output)) return false;
+  const normalizedCommand = command ?? "";
+  return /\bnpm\s+run\s+test:(?:fast|changed)\b/.test(normalizedCommand) || normalizedCommand.includes("scripts/dynamic-node-options.mjs");
+}
+function fullProvenanceCoversRequiredCommands(testsExecuted, worktreePath, changedFiles) {
+  if (changedFiles.length === 0) return true;
+  const changedLanguages = changedProjectLanguages(changedFiles);
+  if (changedLanguages.size === 0 && !changedFilesRequireVerification(changedFiles)) {
+    return true;
+  }
+  const scope = resolveVerificationChannelScope(worktreePath, changedFiles);
+  const testScope = scope.test;
+  if (testScope.availability === "unavailable") {
+    return false;
+  }
+  const required = testScope.availability === "relevant" ? selectScopedTestCommands(scope) : [];
+  if (required.length === 0) return true;
+  const recorded = testsExecuted.commands;
+  if (!recorded || recorded.length === 0) return false;
+  const recordedSet = new Set(recorded);
+  return required.every((command) => recordedSet.has(command));
+}
+function canReuseRecordedProvenance(testsExecuted, mode, worktreePath, changedFiles) {
+  if (testsExecuted.scope === "none") return false;
+  if (mode !== "full") return true;
+  if (testsExecuted.scope !== "full") return false;
+  return fullProvenanceCoversRequiredCommands(testsExecuted, worktreePath, changedFiles);
+}
+async function executeRequiredTestCommands(worktreePath, commands, options) {
+  const abortSignal = options?.abortSignal;
+  const scope = options?.scope ?? "full";
+  const startedAt = Date.now();
+  const artifacts = [];
+  const fallbacks = detectProjectCapabilities(worktreePath).verification.testFallback ?? [];
+  const coveredPrimaries = [];
+  for (const command of commands) {
+    if (abortSignal?.aborted) {
+      break;
+    }
+    const remaining = Math.max(0, MULTI_COMMAND_TEST_BUDGET_MS - (Date.now() - startedAt));
+    if (remaining <= 0) {
+      artifacts.push({
+        command,
+        exitCode: 124,
+        durationMs: 0,
+        outputTail: "Test command skipped: shared multi-command timeout budget exhausted.",
+        status: "timeout",
+        failingTests: []
+      });
+      continue;
+    }
+    const commandStart = Date.now();
+    artifacts.push(
+      await runCapabilityTestCommandWithFallback(worktreePath, command, fallbacks, {
+        timeoutMs: remaining,
+        tailLines: 200,
+        start: commandStart,
+        abortSignal
+      })
+    );
+    coveredPrimaries.push(command);
+    if (abortSignal?.aborted) break;
+  }
+  if (abortSignal?.aborted && artifacts.length !== commands.length) {
+    return {
+      testStatus: "error",
+      availability: "executed",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      metricsAvailable: false,
+      duration: Date.now() - startedAt,
+      filesTested: [],
+      command: artifacts.map((artifact) => artifact.command).join("\n"),
+      commands: coveredPrimaries,
+      scope,
+      exitCode: 130,
+      outputTail: "Test verification aborted before every selected command completed.",
+      failingTests: []
+    };
+  }
+  const combined = combineVitestPlanResults(artifacts);
+  const capabilityRunner = detectTestRunner(worktreePath) ?? "generic";
+  const commandMetrics = artifacts.map(
+    (artifact) => (
+      // Per-artifact runner: a multi-command plan can mix toolchains, and the
+      // project-wide runner id would parse a stdlib-unittest tail with the wrong
+      // parser (in a polyglot repo detectTestRunner reports the Node runner).
+      parseTestOutput(
+        resolveArtifactMetricRunner(artifact.command, capabilityRunner),
+        artifact.outputTail
+      )
+    )
+  );
+  const metrics = commandMetrics.reduce(
+    (total, current) => ({
+      testsRun: total.testsRun + current.testsRun,
+      testsPassed: total.testsPassed + current.testsPassed,
+      testsFailed: total.testsFailed + current.testsFailed
+    }),
+    { testsRun: 0, testsPassed: 0, testsFailed: 0 }
+  );
+  const metricsAvailable = commandMetrics.length > 0 && commandMetrics.every((command) => command.metricsMeasured);
+  const combinedUnavailable = combined.status === "unavailable" || combined.status === "passed" && !metricsAvailable;
+  return {
+    testStatus: combinedUnavailable ? "not_run" : combined.status === "passed" ? "passed" : combined.status === "timeout" ? "timeout" : combined.status === "unavailable" ? "not_run" : combined.status === "error" ? "error" : "failed",
+    availability: combinedUnavailable ? "unavailable" : "executed",
+    ...combinedUnavailable ? { skipReason: "no-supported-test-runner" } : {},
+    testsRun: metrics.testsRun,
+    testsPassed: metrics.testsPassed,
+    testsFailed: metrics.testsFailed,
+    metricsAvailable,
+    duration: Date.now() - startedAt,
+    filesTested: [],
+    // Display/audit: actual commands that ran (may be approved fallbacks).
+    command: combined.command,
+    // Structured coverage: resolver primaries for completed plan steps only.
+    commands: coveredPrimaries,
+    scope,
+    exitCode: combinedUnavailable ? void 0 : combined.exitCode,
+    outputTail: combined.outputTail,
+    failingTests: combined.failingTests
+  };
+}
+async function runTestGate(variant, worktreePath, enabledOrOptions) {
+  const enabled = typeof enabledOrOptions === "boolean" ? enabledOrOptions : enabledOrOptions.enabled;
+  const mode = typeof enabledOrOptions === "boolean" ? "touched" : enabledOrOptions.mode ?? "touched";
+  const abortSignal = typeof enabledOrOptions === "boolean" ? void 0 : enabledOrOptions.abortSignal;
+  if (!enabled || !JUDGE_FEATURE_FLAGS.TEST_GATE_FOR_TEST_INTENT) {
+    return {
+      testStatus: "not_run",
+      availability: "skipped",
+      skipReason: "disabled",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      duration: 0,
+      filesTested: [],
+      command: "",
+      scope: "none"
+    };
+  }
+  const recordedChangedFiles = extractChangedFilesMeta(extractDiffText(variant)).map(
+    (file) => file.path
+  );
+  if (variant.testsExecuted && canReuseRecordedProvenance(variant.testsExecuted, mode, worktreePath, recordedChangedFiles)) {
+    const scope = variant.testsExecuted.scope === "targeted" ? "touched" : variant.testsExecuted.scope;
+    const exitCode = variant.testsExecuted.exitCode;
+    const isEnvCommandFailure = (code) => code === 126 || code === 127;
+    const recordedStatus = normalizeRecordedTestStatus(variant.testStatus);
+    const inferredStatus = recordedStatus !== void 0 ? recordedStatus : (
+      // Fail closed: a status was recorded but is outside the vocabulary Poetic
+      // can interpret (VariantResult.testStatus is `... | string`, so a provider
+      // vocabulary, a stale value, or a fabricated one all type-check). A bare
+      // exit-0 beside such a status is not a pass observation. Failure inference
+      // from a non-zero exit is deliberately unchanged — downgrading an observed
+      // failure would fail open in the dangerous direction.
+      hasUnrecognizedRecordedTestStatus(variant.testStatus) && exitCode === 0 ? "not_run" : exitCode === 0 ? "passed" : exitCode === 124 ? "timeout" : isEnvCommandFailure(exitCode) ? "error" : exitCode === void 0 ? "not_run" : "failed"
+    );
+    const failedTests = variant.testMetrics?.failedTests ?? 0;
+    const totalTests = variant.testMetrics?.totalTests ?? 0;
+    const hasExecutionEvidence = hasRecordedTestExecutionEvidence({
+      command: variant.testsExecuted.command,
+      filesTested: variant.testsExecuted.filesTested,
+      totalTests,
+      exitCode: variant.testsExecuted.exitCode
+    });
+    if (!hasExecutionEvidence) {
+      if (!existsSync2(worktreePath)) {
+        return {
+          testStatus: "not_run",
+          availability: "skipped",
+          skipReason: "no-execution-provenance",
+          testsRun: 0,
+          testsPassed: 0,
+          testsFailed: 0,
+          duration: variant.testsExecuted.durationMs ?? variant.testMetrics?.durationMs ?? 0,
+          filesTested: [],
+          command: "",
+          scope: "none",
+          exitCode: void 0,
+          outputTail: void 0,
+          failingTests: [],
+          signalConsistency: "consistent"
+        };
+      }
+    } else {
+      const normalizedStatus = inferredStatus === "passed" && totalTests === 0 ? "not_run" : inferredStatus;
+      const isContradiction = inferredStatus === "failed" && failedTests === 0 && totalTests > 0;
+      const signalConsistency = isContradiction ? "inconsistent" : "consistent";
+      const recordedCommands = variant.testsExecuted.commands;
+      return {
+        testStatus: normalizedStatus,
+        availability: normalizedStatus === "not_run" ? "unavailable" : "executed",
+        skipReason: normalizedStatus === "not_run" ? "no-execution-provenance" : void 0,
+        testsRun: normalizedStatus === "not_run" ? 0 : totalTests,
+        testsPassed: normalizedStatus === "not_run" ? 0 : variant.testMetrics?.passedTests ?? 0,
+        testsFailed: normalizedStatus === "not_run" ? 0 : failedTests,
+        // Reused provenance carries no parse provenance of its own, so a recorded
+        // count is the only measurement evidence available. Reporting it keeps a
+        // zero-count reuse from reading as measured verification downstream.
+        ...normalizedStatus === "not_run" ? { metricsAvailable: false } : { metricsAvailable: true },
+        duration: variant.testsExecuted.durationMs ?? variant.testMetrics?.durationMs ?? 0,
+        filesTested: normalizedStatus === "not_run" ? [] : variant.testsExecuted.filesTested ?? [],
+        command: normalizedStatus === "not_run" ? "" : variant.testsExecuted.command ?? "",
+        ...normalizedStatus !== "not_run" && recordedCommands && recordedCommands.length > 0 ? { commands: recordedCommands } : {},
+        scope,
+        exitCode: normalizedStatus === "not_run" ? void 0 : exitCode,
+        outputTail: variant.testsExecuted.outputTail,
+        failingTests: variant.testsExecuted.failingTests ?? [],
+        signalConsistency,
+        evidenceSource: "reused_provenance"
+      };
+    }
+  }
+  const diffText = extractDiffText(variant);
+  const changedTestFiles = getChangedTestFiles(diffText);
+  const changedFilesMeta = extractChangedFilesMeta(diffText);
+  const changedFiles = changedFilesMeta.map((file) => file.path);
+  if (mode === "full") {
+    const changedLanguages = changedProjectLanguages(changedFiles);
+    if (changedLanguages.size > 0 || changedFilesRequireVerification(changedFiles)) {
+      const scope = resolveVerificationChannelScope(worktreePath, changedFiles);
+      const commands = scope.test.availability === "relevant" ? selectScopedTestCommands(scope) : [];
+      if (commands.length === 0) {
+        return {
+          testStatus: "not_run",
+          availability: "unavailable",
+          skipReason: "no-supported-test-runner",
+          testsRun: 0,
+          testsPassed: 0,
+          testsFailed: 0,
+          metricsAvailable: false,
+          duration: 0,
+          filesTested: [],
+          command: "",
+          scope: "none",
+          exitCode: 127,
+          outputTail: "Full test verification unavailable: no command covers every changed language.",
+          failingTests: []
+        };
+      }
+      return executeRequiredTestCommands(worktreePath, commands, {
+        abortSignal,
+        scope: "full"
+      });
+    }
+    return executeRequestedSuite(worktreePath, abortSignal);
+  }
+  {
+    const scope = resolveVerificationChannelScope(worktreePath, changedFiles);
+    const requiredCommands = scope.test.availability === "relevant" ? selectScopedTestCommands(scope) : [];
+    const changedLanguages = changedProjectLanguages(changedFiles);
+    if (changedLanguages.size > 1 && requiredCommands.length > 1) {
+      return executeRequiredTestCommands(worktreePath, requiredCommands, {
+        abortSignal,
+        scope: "full"
+      });
+    }
+  }
+  const selectedTestFiles = mode === "affected" ? selectTestFilesForAffectedMode(worktreePath, changedFilesMeta, changedTestFiles) : selectTestFilesForTouchedMode(worktreePath, changedFilesMeta, changedTestFiles);
+  const runner = detectTestRunner(worktreePath);
+  if (selectedTestFiles.files.length === 0) {
+    if (shouldRunFullSuiteForUnmappedSourceChange(runner, changedFilesMeta)) {
+      return executeRequestedSuite(worktreePath, abortSignal);
+    }
+    return {
+      testStatus: "not_run",
+      availability: "skipped",
+      skipReason: "no-test-files-selected",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      duration: 0,
+      filesTested: [],
+      command: "",
+      scope: "none"
+    };
+  }
+  if (!runner) {
+    return {
+      testStatus: "not_run",
+      availability: "unavailable",
+      skipReason: "no-supported-test-runner",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      duration: 0,
+      filesTested: [],
+      command: "",
+      scope: selectedTestFiles.scope,
+      exitCode: void 0,
+      outputTail: "Skipped test gate: no supported test runner detected from project manifests.",
+      failingTests: []
+    };
+  }
+  const scopedNodeInvocation = runner === "vitest" || runner === "jest" || runner === "mocha" || runner === "ava" || runner === "node-test" ? resolveScopedNodeTestInvocation(runner, selectedTestFiles.files, worktreePath) : void 0;
+  if ((runner === "vitest" || runner === "jest" || runner === "mocha" || runner === "ava" || runner === "node-test") && !scopedNodeInvocation) {
+    return {
+      testStatus: "not_run",
+      availability: "unavailable",
+      skipReason: "no-supported-test-runner",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      duration: 0,
+      filesTested: [],
+      command: "",
+      scope: selectedTestFiles.scope,
+      exitCode: void 0,
+      outputTail: "Skipped test gate: no safely scoped or declared project test command is available.",
+      failingTests: []
+    };
+  }
+  const unscopedFullSuiteRunner = runner === "maven" || runner === "gradle" || runner === "unittest";
+  const executionScope = unscopedFullSuiteRunner || scopedNodeInvocation?.scope === "full" ? "full" : selectedTestFiles.scope;
+  const testCommand = scopedNodeInvocation?.display ?? buildTestCommand(runner, selectedTestFiles.files, worktreePath);
+  const result = await executeTests(
+    runner,
+    selectedTestFiles.files,
+    worktreePath,
+    abortSignal,
+    scopedNodeInvocation
+  );
+  const unavailableSignal = detectVerificationToolUnavailable(testCommand, result.outputTail ?? "");
+  if (result.status === "unavailable") {
+    return {
+      testStatus: "not_run",
+      availability: "unavailable",
+      skipReason: "no-matching-tests",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      duration: result.duration,
+      filesTested: [],
+      command: testCommand,
+      scope: executionScope,
+      exitCode: void 0,
+      outputTail: result.outputTail,
+      failingTests: []
+    };
+  }
+  const resultUnavailable = result.status === "error" && result.testsRun === 0 && (result.exitCode === 126 || result.exitCode === 127 || /\b(?:ENOENT|command not found)\b/i.test(result.outputTail ?? "") || unavailableSignal !== void 0);
+  return {
+    testStatus: resultUnavailable ? "not_run" : result.status,
+    availability: resultUnavailable ? "unavailable" : "executed",
+    skipReason: resultUnavailable ? "no-supported-test-runner" : void 0,
+    testsRun: result.testsRun,
+    testsPassed: result.testsPassed,
+    testsFailed: result.testsFailed,
+    // Carry the measurement flag on the executed path too: previously only the
+    // suite/multi-command paths set it, so a scoped run's unmeasured counts
+    // reached consumers as if they had been parsed.
+    ...resultUnavailable ? {} : { metricsAvailable: result.metricsMeasured },
+    duration: result.duration,
+    filesTested: executionScope === "full" ? [] : selectedTestFiles.files,
+    command: testCommand,
+    scope: executionScope,
+    exitCode: resultUnavailable ? void 0 : result.exitCode,
+    outputTail: resultUnavailable && unavailableSignal ? truncateToByteLimit(
+      [result.outputTail, unavailableSignal.message].filter(Boolean).join("\n"),
+      1e5
+    ) : result.outputTail,
+    failingTests: result.failingTests
+  };
+}
+async function executeRequestedSuite(worktreePath, abortSignal) {
+  const startTime = Date.now();
+  const suiteCommand = detectSuiteCommand(worktreePath);
+  if (!suiteCommand) {
+    return {
+      testStatus: "not_run",
+      availability: "unavailable",
+      skipReason: "no-supported-test-runner",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      duration: 0,
+      filesTested: [],
+      command: "",
+      scope: "full",
+      exitCode: void 0,
+      outputTail: "No test suite command detected (package.json missing or no supported runner/scripts)",
+      failingTests: []
+    };
+  }
+  const { display, cmd, args, timeoutMs, runner } = suiteCommand;
+  try {
+    const result = await execa(cmd, args, {
+      cwd: worktreePath,
+      stdio: "pipe",
+      all: true,
+      reject: false,
+      timeout: timeoutMs,
+      env: createVerificationTestEnv(),
+      extendEnv: false,
+      cancelSignal: abortSignal
+    });
+    const duration = Date.now() - startTime;
+    const { exitCode } = resolveVerificationExitCode(display, result);
+    const all = String(result.all ?? "");
+    const outputTail = truncateToByteLimit(tailLines(all, 200), 1e5);
+    if (isPoeticSuiteSkipOutput(display, all)) {
+      return {
+        testStatus: "not_run",
+        availability: "skipped",
+        skipReason: "suite-command-skipped",
+        testsRun: 0,
+        testsPassed: 0,
+        testsFailed: 0,
+        duration,
+        filesTested: [],
+        command: display,
+        scope: "none",
+        exitCode: void 0,
+        outputTail,
+        failingTests: []
+      };
+    }
+    if (exitCode === 0 && detectZeroCollectedTests(
+      runner === "maven" ? "mvn test" : runner === "gradle" ? "gradle test" : display,
+      all
+    )) {
+      return {
+        testStatus: "not_run",
+        availability: "unavailable",
+        skipReason: "no-matching-tests",
+        testsRun: 0,
+        testsPassed: 0,
+        testsFailed: 0,
+        duration,
+        filesTested: [],
+        command: display,
+        scope: "full",
+        exitCode: void 0,
+        outputTail,
+        failingTests: []
+      };
+    }
+    const failingTests = exitCode === 0 ? [] : runner === "vitest" ? extractFailingTestsFromVitestOutput(all) : extractGenericFailures(all);
+    const metrics = parseTestOutput(resolveArtifactMetricRunner(display, runner), all);
+    if (exitCode === 1 && /No test files found/i.test(all)) {
+      return {
+        testStatus: "not_run",
+        availability: "unavailable",
+        skipReason: "no-matching-tests",
+        testsRun: 0,
+        testsPassed: 0,
+        testsFailed: 0,
+        duration,
+        filesTested: [],
+        command: display,
+        scope: "full",
+        exitCode: void 0,
+        outputTail,
+        failingTests: []
+      };
+    }
+    const unavailableSignal = detectVerificationToolUnavailable(display, all);
+    if (unavailableSignal) {
+      return {
+        testStatus: "not_run",
+        availability: "unavailable",
+        skipReason: "no-supported-test-runner",
+        testsRun: 0,
+        testsPassed: 0,
+        testsFailed: 0,
+        duration,
+        filesTested: [],
+        command: display,
+        scope: "full",
+        exitCode: void 0,
+        outputTail: truncateToByteLimit(
+          [outputTail, unavailableSignal.message].filter(Boolean).join("\n"),
+          1e5
+        ),
+        failingTests: []
+      };
+    }
+    const exitZeroFailure = exitCode === 0 ? detectExitZeroVerifyFailure(display, all) : void 0;
+    if (exitZeroFailure) {
+      return {
+        testStatus: "failed",
+        availability: "executed",
+        testsRun: metrics.testsRun,
+        testsPassed: metrics.testsPassed,
+        testsFailed: Math.max(metrics.testsFailed, 1),
+        duration,
+        filesTested: [],
+        command: display,
+        scope: "full",
+        exitCode: 1,
+        outputTail: truncateToByteLimit(
+          [outputTail, exitZeroFailure.message].filter(Boolean).join("\n"),
+          1e5
+        ),
+        failingTests: [exitZeroFailure.message]
+      };
+    }
+    if (exitCode === 0) {
+      if (!metrics.metricsMeasured && metrics.testsFailed === 0) {
+        return {
+          testStatus: "not_run",
+          availability: "unavailable",
+          skipReason: "no-supported-test-runner",
+          testsRun: 0,
+          testsPassed: 0,
+          testsFailed: 0,
+          metricsAvailable: false,
+          duration,
+          filesTested: [],
+          command: display,
+          scope: "full",
+          exitCode: void 0,
+          outputTail,
+          failingTests: []
+        };
+      }
+      const testStatus = inferSuccessStatusForRunner(runner, metrics);
+      const metricsAvailable = metrics.metricsMeasured;
+      return {
+        testStatus,
+        availability: "executed",
+        testsRun: metrics.testsRun,
+        testsPassed: metrics.testsPassed,
+        testsFailed: metrics.testsFailed,
+        metricsAvailable,
+        duration,
+        filesTested: [],
+        command: display,
+        scope: "full",
+        // DERIVED, not observed: failure prose on a clean process exit remains a
+        // non-zero verification result so exit-code-first consumers cannot launder
+        // it into a pass.
+        exitCode: testStatus === "passed" ? exitCode : 1,
+        outputTail,
+        failingTests
+      };
+    }
+    if (exitCode === 124) {
+      return {
+        testStatus: "timeout",
+        availability: "executed",
+        testsRun: metrics.testsRun,
+        testsPassed: metrics.testsPassed,
+        testsFailed: metrics.testsFailed,
+        duration,
+        filesTested: [],
+        command: display,
+        scope: "full",
+        exitCode,
+        outputTail,
+        failingTests
+      };
+    }
+    return {
+      testStatus: "failed",
+      availability: "executed",
+      testsRun: metrics.testsRun,
+      testsPassed: metrics.testsPassed,
+      testsFailed: metrics.testsFailed,
+      duration,
+      filesTested: [],
+      command: display,
+      scope: "full",
+      exitCode,
+      outputTail,
+      failingTests
+    };
+  } catch (error) {
+    const err = error;
+    const duration = Date.now() - startTime;
+    const output = String(err?.all ?? err?.stdout ?? err?.stderr ?? err?.message ?? "");
+    const isNotFound = err?.code === "ENOENT" || /\bENOENT\b/i.test(output) || /command not found/i.test(output);
+    const isTimedOut = Boolean(err?.timedOut) || err?.killed && err?.signal === "SIGTERM";
+    if (isNotFound) {
+      return {
+        testStatus: "error",
+        availability: "unavailable",
+        testsRun: 0,
+        testsPassed: 0,
+        testsFailed: 0,
+        duration,
+        filesTested: [],
+        command: display,
+        scope: "full",
+        exitCode: 127,
+        outputTail: truncateToByteLimit(tailLines(output, 200), 1e5),
+        failingTests: runner === "vitest" ? extractFailingTestsFromVitestOutput(output) : extractGenericFailures(output)
+      };
+    }
+    if (isTimedOut) {
+      return {
+        testStatus: "timeout",
+        availability: "executed",
+        testsRun: 0,
+        testsPassed: 0,
+        testsFailed: 0,
+        duration,
+        filesTested: [],
+        command: display,
+        scope: "full",
+        exitCode: 124,
+        outputTail: truncateToByteLimit(tailLines(output, 200), 1e5),
+        failingTests: runner === "vitest" ? extractFailingTestsFromVitestOutput(output) : extractGenericFailures(output)
+      };
+    }
+    return {
+      testStatus: "error",
+      availability: "unavailable",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      duration,
+      filesTested: [],
+      command: display,
+      scope: "full",
+      exitCode: 1,
+      outputTail: truncateToByteLimit(tailLines(output, 200), 1e5),
+      failingTests: runner === "vitest" ? extractFailingTestsFromVitestOutput(output) : extractGenericFailures(output)
+    };
+  }
+}
+function detectSuiteCommand(worktreePath) {
+  try {
+    const pkgJsonPath = join(worktreePath, "package.json");
+    const scripts = existsSync2(pkgJsonPath) ? JSON.parse(readFileSync(pkgJsonPath, "utf-8"))?.scripts ?? {} : {};
+    const runner = detectTestRunner(worktreePath);
+    const capabilities = detectProjectCapabilities(worktreePath);
+    const isPoeticSelfHarness = hasPoeticVitestHarness(worktreePath);
+    if (isPoeticSelfHarness && typeof scripts["test:fast"] === "string") {
+      return {
+        display: "npm run test:fast",
+        cmd: "npm",
+        args: ["run", "test:fast"],
+        timeoutMs: 12e4,
+        runner: runner === "jest" ? "jest" : "vitest"
+      };
+    }
+    if (isPoeticSelfHarness && typeof scripts["test:changed"] === "string") {
+      return {
+        display: "npm run test:changed -- --local",
+        cmd: "npm",
+        args: ["run", "test:changed", "--", "--local"],
+        timeoutMs: 12e4,
+        runner: runner === "jest" ? "jest" : "vitest"
+      };
+    }
+    const resolverCommand = selectSuiteResolverCommand(capabilities.verification.test);
+    if (!runner || runner === "vitest" && !isPoeticSelfHarness && resolverCommand) {
+      const command = resolverCommand;
+      if (command) {
+        const [cmd, ...args] = splitCommand(command);
+        if (cmd) {
+          return {
+            display: command,
+            cmd,
+            args,
+            timeoutMs: 12e4,
+            runner: "generic"
+          };
+        }
+      }
+    }
+    if (runner === "vitest") {
+      if (!isPoeticSelfHarness) {
+        const invocation = buildExternalVitestRunInvocation();
+        return {
+          display: invocation.display,
+          cmd: invocation.cmd,
+          args: invocation.args,
+          timeoutMs: 12e4,
+          runner
+        };
+      }
+      return {
+        display: "node scripts/dynamic-node-options.mjs vitest run --changed --reporter=verbose",
+        cmd: "node",
+        args: [
+          "scripts/dynamic-node-options.mjs",
+          "vitest",
+          "run",
+          "--changed",
+          "--reporter=verbose"
+        ],
+        timeoutMs: 12e4,
+        runner
+      };
+    }
+    if (runner === "jest") {
+      return {
+        display: "npx --no-install jest --verbose",
+        cmd: "npx",
+        args: ["--no-install", "jest", "--verbose"],
+        timeoutMs: 12e4,
+        runner
+      };
+    }
+    if (runner === "mocha" || runner === "ava" || runner === "node-test") {
+      const fallbackCommand = runner === "mocha" ? "npx --no-install mocha" : runner === "ava" ? "npx --no-install ava" : "node --test";
+      const command = resolverCommand ?? fallbackCommand;
+      const [cmd, ...args] = splitCommand(command);
+      if (!cmd) return null;
+      return { display: command, cmd, args, timeoutMs: 12e4, runner };
+    }
+    if (runner === "pytest" || runner === "unittest") {
+      const command = (runner === "unittest" ? detectPythonUnittestCommand(capabilities) : void 0) ?? capabilities.verification.test[0] ?? "pytest";
+      const [cmd, ...args] = splitCommand(command);
+      if (!cmd) return null;
+      return { display: command, cmd, args, timeoutMs: 12e4, runner };
+    }
+    if (runner === "go" || runner === "cargo") {
+      const fallbackCommand = runner === "go" ? "go test ./..." : "cargo test --locked";
+      const command = selectRunnerLanguageResolverCommand(capabilities.verification.test, runner) ?? fallbackCommand;
+      const [cmd, ...args] = splitCommand(command);
+      if (!cmd) return null;
+      return { display: command, cmd, args, timeoutMs: 12e4, runner };
+    }
+    if (runner === "maven" || runner === "gradle") {
+      const command = selectRunnerLanguageResolverCommand(capabilities.verification.test, runner) ?? capabilities.verification.test[0];
+      if (!command) return null;
+      const [cmd, ...args] = splitCommand(command);
+      if (!cmd) return null;
+      return { display: command, cmd, args, timeoutMs: 12e4, runner };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function selectSuiteResolverCommand(commands) {
+  return commands.find((command) => {
+    const normalized = command.trim();
+    return !/\b(?:npm|pnpm|yarn|bun)\s+run\s+test:(?:fast|changed)\b/.test(normalized);
+  });
+}
+var RUNNER_VERIFICATION_LANGUAGES = {
+  go: "go",
+  cargo: "rust",
+  maven: "jvm",
+  gradle: "jvm"
+};
+function selectRunnerLanguageResolverCommand(commands, runner) {
+  const language = RUNNER_VERIFICATION_LANGUAGES[runner];
+  if (!language) return void 0;
+  return commands.find((command) => {
+    const described = describeVerificationCommand(command).language;
+    return described === language || described === "unknown";
+  });
+}
+var NODE_SCOPED_RUNNERS = /* @__PURE__ */ new Set([
+  "vitest",
+  "jest",
+  "mocha",
+  "ava",
+  "node-test"
+]);
+var SCOPED_SAFE_OPTIONS_COMMON = {
+  "--reporter": { takesValue: true },
+  "--require": { takesValue: true },
+  "-r": { takesValue: true },
+  "--verbose": {},
+  "--silent": {},
+  "--bail": {},
+  "--color": {},
+  "--colors": {},
+  "--no-color": {},
+  "--no-colors": {},
+  "--coverage": {},
+  "--no-coverage": {}
+};
+var NODE_SCOPED_SAFE_OPTIONS = {
+  vitest: {
+    ...SCOPED_SAFE_OPTIONS_COMMON,
+    "--preload": { takesValue: true },
+    "--pool": { takesValue: true },
+    "--sequencer": { takesValue: true },
+    "--transformMode": { takesValue: true },
+    "--environment": { takesValue: true },
+    "--no-file-parallelism": {},
+    "--isolate": {},
+    "--no-isolate": {}
+  },
+  jest: {
+    ...SCOPED_SAFE_OPTIONS_COMMON,
+    "--runInBand": {},
+    "--forceExit": {},
+    "--detectOpenHandles": {},
+    "--ci": {},
+    "--json": {},
+    "--maxWorkers": { takesValue: true },
+    "--testTimeout": { takesValue: true },
+    "--outputFile": { takesValue: true }
+  },
+  mocha: {
+    ...SCOPED_SAFE_OPTIONS_COMMON,
+    // Mocha `-t` / `--timeout` are duration, not name selectors (unlike Jest/Vitest `-t`).
+    "--timeout": { takesValue: true },
+    "-t": { takesValue: true },
+    "--ui": { takesValue: true },
+    "-u": { takesValue: true },
+    "--slow": { takesValue: true },
+    "-R": { takesValue: true },
+    "-b": {},
+    "--exit": {},
+    "--recursive": {},
+    "--full-trace": {},
+    "--async-only": {},
+    "-A": {},
+    "--delay": {},
+    "--forbid-only": {},
+    "--forbid-pending": {},
+    "--parallel": {},
+    "--jobs": { takesValue: true }
+  },
+  ava: {
+    ...SCOPED_SAFE_OPTIONS_COMMON,
+    "--timeout": { takesValue: true },
+    "--concurrency": { takesValue: true },
+    "--serial": {},
+    "--tap": {}
+  },
+  "node-test": {
+    "--test-reporter": { takesValue: true },
+    "--test-timeout": { takesValue: true },
+    "--experimental-test-coverage": {}
+  }
+};
+function extractPackageManagerScriptName(command) {
+  const normalized = command.trim();
+  const runMatch = normalized.match(/^(?:npm|pnpm|yarn|bun)\s+run\s+([^\s]+)/);
+  if (runMatch?.[1]) return runMatch[1];
+  if (/^(?:npm|pnpm|yarn|bun)\s+test\b/.test(normalized)) return "test";
+  return void 0;
+}
+function packageManagerForwardedArgs(command) {
+  const tokens = splitCommand(command.trim());
+  if (tokens[1] === "run" && tokens[2]) {
+    return tokens.slice(3);
+  }
+  if (tokens[1] === "test") {
+    return tokens.slice(2);
+  }
+  return [];
+}
+function readPackageScriptBody(worktreePath, scriptName) {
+  try {
+    const pkgJsonPath = join(worktreePath, "package.json");
+    if (!existsSync2(pkgJsonPath)) return void 0;
+    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    const body = pkgJson.scripts?.[scriptName];
+    return typeof body === "string" && body.trim().length > 0 ? body.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function hasOnlySafeScopedOptions(flagTail, runner) {
+  const safeOptions = NODE_SCOPED_SAFE_OPTIONS[runner];
+  const tokens = splitCommand(flagTail.trim());
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token === "--") {
+      return i + 1 >= tokens.length;
+    }
+    if (token.startsWith("-")) {
+      const flagName = token.split("=", 1)[0] ?? token;
+      const option = safeOptions[flagName];
+      if (!option) {
+        return false;
+      }
+      if (option.takesValue && !token.includes("=")) {
+        if (i + 1 >= tokens.length || tokens[i + 1].startsWith("-")) {
+          return false;
+        }
+        i += 2;
+        continue;
+      }
+      i += 1;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function isSimpleScopedNodeRunnerInvocation(command, runner) {
+  let normalized = command.trim();
+  if (!normalized) return false;
+  if (/(?:&&|\|\||[;|<>`]|\$\()/.test(normalized)) return false;
+  normalized = normalized.replace(/^(?:npx|bunx)(?:\s+--no-install)?\s+/u, "").replace(/^(?:pnpm|yarn)\s+(?:exec|dlx)\s+/u, "").replace(/^node\s+scripts\/dynamic-node-options\.mjs\s+/u, "").replace(/^(?:\.\/)?node_modules\/\.bin\//u, "");
+  switch (runner) {
+    case "vitest": {
+      if (!/^vitest\b/.test(normalized)) return false;
+      const rest = normalized.replace(/^vitest(?:\s+run)?\b/, "");
+      return hasOnlySafeScopedOptions(rest, "vitest");
+    }
+    case "jest": {
+      if (!/^jest\b/.test(normalized)) return false;
+      return hasOnlySafeScopedOptions(normalized.replace(/^jest\b/, ""), "jest");
+    }
+    case "mocha": {
+      if (!/^mocha\b/.test(normalized)) return false;
+      return hasOnlySafeScopedOptions(normalized.replace(/^mocha\b/, ""), "mocha");
+    }
+    case "ava": {
+      if (!/^ava\b/.test(normalized)) return false;
+      return hasOnlySafeScopedOptions(normalized.replace(/^ava\b/, ""), "ava");
+    }
+    case "node-test": {
+      const tokens = splitCommand(normalized);
+      if (tokens[0] !== "node") return false;
+      const testIdx = tokens.findIndex((token, index) => index > 0 && token === "--test");
+      if (testIdx < 0) return false;
+      const before = tokens.slice(1, testIdx).join(" ");
+      const after = tokens.slice(testIdx + 1).join(" ");
+      return hasOnlySafeScopedOptions(before, "node-test") && hasOnlySafeScopedOptions(after, "node-test");
+    }
+    default:
+      return false;
+  }
+}
+function isScopedFileCompatibleNodeCommand(command, runner, worktreePath) {
+  const normalized = command.trim();
+  if (!normalized) return false;
+  if (/\b(?:npm|pnpm|yarn|bun)\s+run\s+test:(?:smoke|fast|changed)\b/.test(normalized)) {
+    return false;
+  }
+  if (/\b(?:npm|pnpm|yarn|bun)\s+test:(?:smoke|fast|changed)\b/.test(normalized)) {
+    return false;
+  }
+  if (/^(?:npm|pnpm|yarn|bun)\b/.test(normalized)) {
+    const scriptName = extractPackageManagerScriptName(normalized);
+    if (!scriptName) return false;
+    if (scriptName !== "test" && scriptName !== "test:unit") return false;
+    const scriptBody = readPackageScriptBody(worktreePath, scriptName);
+    if (!scriptBody) return false;
+    const forwardedArgs = packageManagerForwardedArgs(normalized);
+    if (forwardedArgs.length > 0 && !(forwardedArgs.length === 1 && forwardedArgs[0] === "--")) {
+      return false;
+    }
+    return isSimpleScopedNodeRunnerInvocation(scriptBody, runner);
+  }
+  return isSimpleScopedNodeRunnerInvocation(normalized, runner);
+}
+function selectNodeScopedResolverCommand(worktreePath, runner) {
+  if (!NODE_SCOPED_RUNNERS.has(runner)) return void 0;
+  const commands = detectProjectCapabilities(worktreePath).verification.test;
+  return commands.find((command) => {
+    if (!isNodeVerificationCommand(command)) return false;
+    return isScopedFileCompatibleNodeCommand(command, runner, worktreePath);
+  });
+}
+function selectNodeSuiteResolverCommand(worktreePath) {
+  return detectProjectCapabilities(worktreePath).verification.test.find(isNodeVerificationCommand);
+}
+function isNodeVerificationCommand(command) {
+  const { language } = describeVerificationCommand(command);
+  return language === "node" || language === "unknown" || commandMatchesLanguage(command, "javascript") || commandMatchesLanguage(command, "typescript");
+}
+function formatScopedDisplay(cmd, args) {
+  const bare = /* @__PURE__ */ new Set([
+    "npx",
+    "npm",
+    "pnpm",
+    "yarn",
+    "bun",
+    "node",
+    "run",
+    "test",
+    "vitest",
+    "jest",
+    "mocha",
+    "ava",
+    "--",
+    "--no-install",
+    "--reporter=verbose",
+    "--verbose",
+    "--test"
+  ]);
+  const formatArg = (part) => {
+    if (bare.has(part) || part.startsWith("--") && !part.includes("/")) return part;
+    if (part.includes("/") || part.includes(".") || /\s/.test(part)) return `"${part}"`;
+    return part;
+  };
+  return [cmd, ...args].map((part, index) => index === 0 ? part : formatArg(part)).join(" ");
+}
+function appendScopedFilesToCommand(command, testFiles) {
+  const tokens = splitCommand(command);
+  const cmd = tokens[0] ?? command;
+  const baseArgs = tokens.slice(1);
+  if (cmd === "yarn") {
+    const args2 = [...baseArgs, ...testFiles];
+    return { cmd, args: args2, display: formatScopedDisplay(cmd, args2) };
+  }
+  if (cmd === "npm" || cmd === "pnpm" || cmd === "bun") {
+    if (baseArgs.includes("--")) {
+      const args3 = [...baseArgs, ...testFiles];
+      return { cmd, args: args3, display: formatScopedDisplay(cmd, args3) };
+    }
+    const args2 = [...baseArgs, "--", ...testFiles];
+    return { cmd, args: args2, display: formatScopedDisplay(cmd, args2) };
+  }
+  const args = [...baseArgs, ...testFiles];
+  return { cmd, args, display: formatScopedDisplay(cmd, args) };
+}
+function resolveScopedNodeTestInvocation(runner, testFiles, worktreePath) {
+  if (runner === "vitest" && hasPoeticVitestHarness(worktreePath)) {
+    const args2 = [
+      "scripts/dynamic-node-options.mjs",
+      "vitest",
+      "run",
+      ...testFiles,
+      "--reporter=verbose"
+    ];
+    return { cmd: "node", args: args2, display: formatScopedDisplay("node", args2), scope: "scoped" };
+  }
+  const resolverCommand = selectNodeScopedResolverCommand(worktreePath, runner);
+  if (resolverCommand) {
+    return { ...appendScopedFilesToCommand(resolverCommand, testFiles), scope: "scoped" };
+  }
+  const suiteCommand = selectNodeSuiteResolverCommand(worktreePath);
+  if (!suiteCommand) return void 0;
+  const [cmd, ...args] = splitCommand(suiteCommand);
+  if (!cmd) return void 0;
+  return { cmd, args, display: suiteCommand, scope: "full" };
+}
+function detectTestRunner(worktreePath) {
+  try {
+    const capabilities = detectProjectCapabilities(worktreePath);
+    const isNodeTarget = hasProjectLanguage(capabilities, "javascript") || hasProjectLanguage(capabilities, "typescript");
+    if (isNodeTarget) {
+      const pkgJsonPath = join(worktreePath, "package.json");
+      if (existsSync2(pkgJsonPath)) {
+        const pkgJsonContent = readFileSync(pkgJsonPath, "utf-8");
+        const pkgJson = JSON.parse(pkgJsonContent);
+        const allDeps = {
+          ...pkgJson.dependencies,
+          ...pkgJson.devDependencies
+        };
+        if (allDeps.vitest) {
+          return "vitest";
+        }
+        if (allDeps.jest || allDeps["@types/jest"]) {
+          return "jest";
+        }
+        if (allDeps.mocha) {
+          return "mocha";
+        }
+        if (allDeps.ava) {
+          return "ava";
+        }
+        const scripts = pkgJson.scripts ?? {};
+        const testScript = typeof scripts.test === "string" ? scripts.test : "";
+        if (/\bnode\s+(?:--[^\s]+\s+)*--test(?=\s|$)/.test(testScript)) {
+          return "node-test";
+        }
+      }
+    }
+    if (hasProjectLanguage(capabilities, "python")) {
+      return detectPythonUnittestCommand(capabilities) !== void 0 ? "unittest" : "pytest";
+    }
+    if (hasProjectLanguage(capabilities, "go")) return "go";
+    if (hasProjectLanguage(capabilities, "rust")) return "cargo";
+    if (capabilities.manifests.pomXml) return "maven";
+    if (capabilities.manifests.gradle) return "gradle";
+    if (detectPowerShellTestCommand(worktreePath)) return "powershell";
+    return null;
+  } catch {
+    return null;
+  }
+}
+function resolveArtifactMetricRunner(command, fallback) {
+  return isPythonStdlibUnittestCommand(command) ? "unittest" : fallback;
+}
+function detectPythonUnittestCommand(capabilities) {
+  const primary = capabilities.verification.test.find(
+    (command) => describeVerificationCommand(command).language === "python"
+  );
+  if (primary === void 0) return void 0;
+  return isPythonStdlibUnittestCommand(primary) ? primary : void 0;
+}
+function detectPowerShellTestCommand(worktreePath) {
+  return detectProjectCapabilities(worktreePath).verification.test.find(
+    (command) => /^(?:pwsh|powershell)(?:\.exe)?\b.*\bInvoke-Pester\b/i.test(command)
+  );
+}
+function commandMatchesLanguage(command, language) {
+  const normalized = command.trim();
+  const descriptor = describeVerificationCommand(normalized);
+  if (descriptor.language !== "unknown") {
+    if (descriptor.kind !== "test") return false;
+    switch (descriptor.language) {
+      case "node":
+        return language === "javascript" || language === "typescript";
+      case "jvm":
+        return language === "java" || language === "kotlin";
+      case "native":
+        return language === "c" || language === "cpp";
+      default:
+        return descriptor.language === language;
+    }
+  }
+  switch (language) {
+    case "javascript":
+    case "typescript":
+      return /^(?:npm|pnpm|yarn|bun)\b.*\btest\b|^bun\s+test\b/.test(normalized);
+    case "python":
+      return /\b(?:pytest|tox)\b/.test(normalized);
+    case "go":
+      return /^go\s+test\b/.test(normalized);
+    case "rust":
+      return /^cargo\s+test\b/.test(normalized);
+    case "java":
+    case "kotlin":
+      return /\b(?:gradle|mvn|mvnw|gradlew)\b.*\btest\b/.test(normalized);
+    case "dotnet":
+      return /^dotnet\s+test\b/.test(normalized);
+    case "swift":
+      return /^swift\s+test\b/.test(normalized);
+    case "dart":
+      return /^(?:dart|flutter)\s+test\b/.test(normalized);
+    case "ruby":
+      return /\b(?:rspec|rake\s+test)\b/.test(normalized);
+    case "php":
+      return /\b(?:phpunit|composer\s+exec\s+--\s+phpunit)\b/.test(normalized);
+    case "c":
+    case "cpp":
+      return /^(?:ctest|meson\s+test|make\s+(?:check|test))\b/.test(normalized);
+    case "r":
+      return /^R\s+CMD\s+check\b/.test(normalized);
+    case "sql":
+      return /^dbt\s+test\b/.test(normalized);
+    case "powershell":
+      return /^(?:pwsh|powershell)(?:\.exe)?\b.*\bInvoke-Pester\b/i.test(normalized);
+    default:
+      return false;
+  }
+}
+function selectCapabilityTestCommandsForChanges(worktreePath, changedFiles) {
+  const changedLanguages = changedProjectLanguages(changedFiles);
+  if (changedLanguages.size === 0) {
+    return detectProjectCapabilities(worktreePath).verification.test.slice(0, 1);
+  }
+  return selectCapabilityTestCommandsForLanguages(worktreePath, changedLanguages);
+}
+function selectCapabilityTestCommandsForLanguages(worktreePath, changedLanguages) {
+  const capabilities = detectProjectCapabilities(worktreePath);
+  if (capabilities.verification.test.length === 0) return [];
+  if (changedLanguages.size === 0) return [];
+  const selected = [];
+  for (const language of changedLanguages) {
+    const command = capabilities.verification.test.find(
+      (candidate) => commandMatchesLanguage(candidate, language)
+    );
+    if (command) selected.push(command);
+  }
+  const unique = Array.from(new Set(selected));
+  const uncovered = [...changedLanguages].filter(
+    (language) => !unique.some((command) => commandMatchesLanguage(command, language))
+  );
+  if (uncovered.length > 0) return [];
+  return unique;
+}
+function changedProjectLanguages(changedFiles) {
+  const languages = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    const inferred = languageForProjectPath(file);
+    const language = inferred && inferred !== "unknown" ? inferred : languageForProjectConfigPath(file);
+    if (language && language !== "unknown" && language !== "docs") languages.add(language);
+  }
+  return languages;
+}
+function languageForProjectConfigPath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  const base = normalized.split("/").pop() ?? normalized;
+  if (base === "package.json" || base.startsWith("tsconfig")) return "typescript";
+  if (base === "pyproject.toml" || base === "poetry.lock" || base === "pipfile" || base === "pipfile.lock" || base.startsWith("requirements") || base === "pytest.ini" || base === "tox.ini") {
+    return "python";
+  }
+  if (base === "go.mod" || base === "go.sum") return "go";
+  if (base === "cargo.toml" || base === "cargo.lock") return "rust";
+  if (base === "pom.xml" || base.startsWith("build.gradle") || base.startsWith("settings.gradle")) {
+    return "java";
+  }
+  if (/\.(?:csproj|fsproj|vbproj)$/.test(base) || base.endsWith(".sln")) return "dotnet";
+  if (base === "package.swift") return "swift";
+  if (base === "pubspec.yaml") return "dart";
+  if (base === "gemfile" || base === "rakefile" || base.endsWith(".gemspec")) return "ruby";
+  if (base === "composer.json" || base === "composer.lock") return "php";
+  if (base === "cmakelists.txt" || base === "cmakepresets.json" || base === "meson.build") {
+    return "cpp";
+  }
+  if (base === "pesterconfiguration.ps1") return "powershell";
+  if (base === "description" || base === "renv.lock" || base.endsWith(".rproj")) return "r";
+  if (base === "dbt_project.yml" || base === "dbt_project.yaml") return "sql";
+  return null;
+}
+function getChangedTestFiles(diff) {
+  const testFiles = /* @__PURE__ */ new Set();
+  const diffHeaderPattern = /^\+\+\+ b\/(.+)$/gm;
+  let match = diffHeaderPattern.exec(diff);
+  while (match !== null) {
+    const filePath = match[1];
+    if (filePath && isTestFile(filePath)) {
+      testFiles.add(filePath);
+    }
+    match = diffHeaderPattern.exec(diff);
+  }
+  return Array.from(testFiles);
+}
+function selectTestFilesForTouchedMode(worktreePath, changedFilesMeta, changedTestFiles) {
+  const selectedFiles = new Set(changedTestFiles);
+  const riskExpandedFiles = /* @__PURE__ */ new Set();
+  for (const file of changedFilesMeta) {
+    for (const mappedTest of getRiskExpandedTestFiles(worktreePath, file.path, file.category)) {
+      riskExpandedFiles.add(mappedTest);
+      selectedFiles.add(mappedTest);
+    }
+  }
+  const files = Array.from(selectedFiles);
+  if (files.length === 0) {
+    return { files: [], scope: "none" };
+  }
+  if (riskExpandedFiles.size > 0) {
+    return { files, scope: "targeted" };
+  }
+  return { files, scope: "touched" };
+}
+function selectTestFilesForAffectedMode(worktreePath, changedFilesMeta, changedTestFiles) {
+  const touchedSelection = selectTestFilesForTouchedMode(
+    worktreePath,
+    changedFilesMeta,
+    changedTestFiles
+  );
+  const selectedFiles = new Set(touchedSelection.files);
+  const reverseImportMatches = findAffectedImportingTests(worktreePath, changedFilesMeta);
+  for (const testFile of reverseImportMatches) {
+    selectedFiles.add(testFile);
+  }
+  const files = Array.from(selectedFiles).sort();
+  if (files.length === 0) {
+    return { files: [], scope: "none" };
+  }
+  if (reverseImportMatches.length > 0) {
+    return { files, scope: "affected" };
+  }
+  return { files, scope: touchedSelection.scope };
+}
+function shouldRunFullSuiteForUnmappedSourceChange(runner, changedFilesMeta) {
+  if (!runner || runner === "vitest" || runner === "jest") {
+    return false;
+  }
+  return changedFilesMeta.some((file) => file.category === "source" && !isTestFile(file.path));
+}
+function splitCommand(command) {
+  const args = [];
+  let current = "";
+  let quote = null;
+  let escaping = false;
+  for (const char of command.trim()) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (escaping) current += "\\";
+  if (current.length > 0) args.push(current);
+  return args;
+}
+function findAffectedImportingTests(worktreePath, changedFilesMeta) {
+  const capabilities = detectProjectCapabilities(worktreePath);
+  const isJsTsTarget = hasProjectLanguage(capabilities, "javascript") || hasProjectLanguage(capabilities, "typescript");
+  if (!isJsTsTarget) {
+    return [];
+  }
+  const changedSourceFiles = new Set(
+    changedFilesMeta.filter((file) => file.category === "source" && !isTestFile(file.path)).map((file) => normalizeRepoPath(file.path))
+  );
+  if (changedSourceFiles.size === 0) {
+    return [];
+  }
+  const affectedTests = /* @__PURE__ */ new Set();
+  for (const testFile of listRepoTestFiles(worktreePath)) {
+    const resolvedImports = resolveDirectRepoImportsForTest(testFile, worktreePath);
+    if (resolvedImports.some((importedPath) => changedSourceFiles.has(importedPath))) {
+      affectedTests.add(testFile);
+    }
+  }
+  return Array.from(affectedTests).sort();
+}
+function listRepoTestFiles(worktreePath) {
+  const discovered = /* @__PURE__ */ new Set();
+  for (const root of TEST_DISCOVERY_ROOTS) {
+    const absoluteRoot = join(worktreePath, root);
+    if (!existsSync2(absoluteRoot)) {
+      continue;
+    }
+    walkTestFiles(absoluteRoot, worktreePath, discovered);
+  }
+  return Array.from(discovered).sort();
+}
+function walkTestFiles(currentPath, worktreePath, discovered) {
+  let entries;
+  try {
+    entries = readdirSync(currentPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (SKIPPED_TEST_DISCOVERY_DIRS.has(entry.name)) {
+        continue;
+      }
+      walkTestFiles(join(currentPath, entry.name), worktreePath, discovered);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const repoRelative = normalizeRepoPath(relative(worktreePath, join(currentPath, entry.name)));
+    if (isTestFile(repoRelative)) {
+      discovered.add(repoRelative);
+    }
+  }
+}
+function resolveDirectRepoImportsForTest(testFile, worktreePath) {
+  const absolutePath = join(worktreePath, testFile);
+  let content;
+  try {
+    content = readFileSync(absolutePath, "utf8");
+  } catch {
+    return [];
+  }
+  const imports = /* @__PURE__ */ new Set();
+  const addMatches = (pattern, captureIndex) => {
+    let match = pattern.exec(content);
+    while (match !== null) {
+      const specifier = match[captureIndex]?.trim();
+      if (specifier) {
+        imports.add(specifier);
+      }
+      match = pattern.exec(content);
+    }
+  };
+  addMatches(/\b(?:from|import)\s+['"]([^'"]+)['"]/g, 1);
+  addMatches(/\brequire\(\s*['"]([^'"]+)['"]\s*\)/g, 1);
+  addMatches(/\bimport\(\s*['"]([^'"]+)['"]\s*\)/g, 1);
+  const resolvedImports = /* @__PURE__ */ new Set();
+  for (const specifier of imports) {
+    const resolvedImport = resolveRelativeRepoImport(testFile, specifier, worktreePath);
+    if (resolvedImport) {
+      resolvedImports.add(resolvedImport);
+    }
+  }
+  return Array.from(resolvedImports);
+}
+function resolveRelativeRepoImport(importerPath, specifier, worktreePath) {
+  if (!specifier.startsWith(".")) {
+    return null;
+  }
+  const baseTarget = resolve(worktreePath, dirname(importerPath), specifier);
+  for (const candidate of buildImportResolutionCandidates(baseTarget)) {
+    if (!existsSync2(candidate)) {
+      continue;
+    }
+    const repoRelative = normalizeRepoPath(relative(worktreePath, candidate));
+    if (repoRelative.startsWith("..")) {
+      continue;
+    }
+    return repoRelative;
+  }
+  return null;
+}
+function buildImportResolutionCandidates(baseTarget) {
+  const candidates = /* @__PURE__ */ new Set();
+  const addCandidate = (candidate) => {
+    candidates.add(candidate);
+  };
+  addCandidate(baseTarget);
+  const baseExtension = extname(baseTarget);
+  if (baseExtension) {
+    if (JS_LIKE_EXTENSIONS.has(baseExtension)) {
+      const stem = baseTarget.slice(0, -baseExtension.length);
+      for (const sourceExtension of SOURCE_FILE_EXTENSIONS) {
+        addCandidate(`${stem}${sourceExtension}`);
+      }
+    }
+  } else {
+    for (const extension of SOURCE_FILE_EXTENSIONS) {
+      addCandidate(`${baseTarget}${extension}`);
+      addCandidate(join(baseTarget, `index${extension}`));
+    }
+  }
+  return Array.from(candidates);
+}
+function normalizeRepoPath(filePath) {
+  return filePath.split(sep).join("/");
+}
+function getRiskExpandedTestFiles(worktreePath, filePath, category) {
+  if (!hasPoeticVitestHarness(worktreePath)) {
+    return [];
+  }
+  if (filePath === "schemas/judge-scoring.schema.json") {
+    return ["tests/unit/core/config/judge-scoring-schema.test.ts"];
+  }
+  if (category === "config" || category === "lockfile") {
+    if (filePath === ".poetic/config/providers.yaml") {
+      return ["src/core/providers/model-update/__tests__/pricing/passthrough-resolver.test.ts"];
+    }
+  }
+  return [];
+}
+function isTestFile(filePath) {
+  if (DEFAULT_CONFIG.testFilePatterns.some((pattern) => pattern.test(filePath))) return true;
+  const base = pathPosix.basename(filePath.replace(/\\/g, "/"));
+  return isProjectTestPath(base);
+}
+async function executeTests(runner, testFiles, worktreePath, abortSignal, scopedNodeInvocation) {
+  if (!runner) {
+    return {
+      status: "error",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      metricsMeasured: false,
+      duration: 0,
+      exitCode: 1,
+      outputTail: "",
+      failingTests: []
+    };
+  }
+  const startTime = Date.now();
+  if (runner === "powershell") {
+    const command = detectPowerShellTestCommand(worktreePath) ?? "pwsh -NoProfile -Command Invoke-Pester";
+    const result = await runVerificationCommand(command, {
+      cwd: worktreePath,
+      timeoutMs: DEFAULT_CONFIG.timeout,
+      abortSignal
+    });
+    const output = String(result.all ?? result.stdout ?? result.stderr ?? "");
+    const { exitCode } = resolveVerificationExitCode(command, result);
+    const metrics = parseTestOutput(runner, output);
+    const duration = Date.now() - startTime;
+    const inferredStatus = exitCode === 0 ? inferSuccessStatusFromMetrics(metrics) : "failed";
+    return {
+      status: exitCode === 0 && !metrics.metricsMeasured && inferredStatus !== "failed" ? "unavailable" : inferredStatus,
+      testsRun: metrics.testsRun,
+      testsPassed: metrics.testsPassed,
+      testsFailed: metrics.testsFailed,
+      metricsMeasured: metrics.metricsMeasured,
+      duration,
+      exitCode,
+      outputTail: truncateToByteLimit(tailLines(output, 200), 1e5),
+      failingTests: exitCode === 0 ? [] : extractGenericFailures(output)
+    };
+  }
+  const execaCommand = runner === "vitest" || runner === "jest" || runner === "mocha" || runner === "ava" || runner === "node-test" ? scopedNodeInvocation : runner === "unittest" ? (
+    // `python -m unittest discover` takes a start DIRECTORY; appending test
+    // file paths makes it abort with "Start directory is not importable"
+    // (verified on CPython 3.14). So the resolved command runs UNSCOPED,
+    // like the maven/gradle full-suite runners; the caller reports honest
+    // `full` scope rather than claiming the touched file was executed.
+    (() => {
+      const capabilities = detectProjectCapabilities(worktreePath);
+      const [cmd, ...args] = splitCommand(
+        detectPythonUnittestCommand(capabilities) ?? capabilities.verification.test[0] ?? "python3 -m unittest discover"
+      );
+      return { cmd: cmd ?? "python3", args };
+    })()
+  ) : runner === "pytest" ? (() => {
+    const [cmd, ...baseArgs] = splitCommand(
+      detectProjectCapabilities(worktreePath).verification.test[0] ?? "pytest"
+    );
+    return {
+      cmd: cmd ?? "pytest",
+      args: [...baseArgs, ...testFiles]
+    };
+  })() : runner === "go" || runner === "cargo" ? (
+    // Resolver-first (same contract as maven/gradle/pytest below):
+    // honor the target's OWN declared test command (Makefile
+    // `test:` target, poetic.config `verification.test` override)
+    // instead of a hardcoded default. The cargo `--locked`
+    // fallback matches the resolver's lockfile-safe policy
+    // (capabilities.ts) — never mutate the target's Cargo.lock. [B6]
+    (() => {
+      const fallback = runner === "go" ? "go test ./..." : "cargo test --locked";
+      const [cmd, ...args] = splitCommand(
+        selectRunnerLanguageResolverCommand(
+          detectProjectCapabilities(worktreePath).verification.test,
+          runner
+        ) ?? fallback
+      );
+      return { cmd: cmd ?? fallback.split(" ")[0], args };
+    })()
+  ) : runner === "maven" || runner === "gradle" ? (() => {
+    const fallback = runner === "maven" ? "mvn test" : "gradle test";
+    const [cmd, ...args] = splitCommand(
+      selectRunnerLanguageResolverCommand(
+        detectProjectCapabilities(worktreePath).verification.test,
+        runner
+      ) ?? fallback
+    );
+    return { cmd: cmd ?? fallback.split(" ")[0], args };
+  })() : { cmd: "gradle", args: ["test"] };
+  if (!execaCommand) {
+    return {
+      status: "error",
+      testsRun: 0,
+      testsPassed: 0,
+      testsFailed: 0,
+      metricsMeasured: false,
+      duration: Date.now() - startTime,
+      exitCode: 1,
+      outputTail: "No safely scoped or declared project test command is available.",
+      failingTests: []
+    };
+  }
+  try {
+    const result = await execa(execaCommand.cmd, execaCommand.args, {
+      cwd: worktreePath,
+      stdio: "pipe",
+      all: true,
+      reject: false,
+      timeout: DEFAULT_CONFIG.timeout,
+      env: createVerificationTestEnv(),
+      extendEnv: false,
+      cancelSignal: abortSignal
+    });
+    const output = String(result.all ?? "");
+    const commandDisplay = `${execaCommand.cmd} ${execaCommand.args.join(" ")}`.trim();
+    const { exitCode } = resolveVerificationExitCode(commandDisplay, result);
+    const duration = Date.now() - startTime;
+    const outputTail = truncateToByteLimit(tailLines(output, 200), 1e5);
+    if (exitCode === 0 && detectZeroCollectedTests(
+      runner === "maven" ? "mvn test" : runner === "gradle" ? "gradle test" : commandDisplay,
+      output
+    )) {
+      return {
+        status: "unavailable",
+        testsRun: 0,
+        testsPassed: 0,
+        testsFailed: 0,
+        metricsMeasured: false,
+        duration,
+        exitCode,
+        outputTail,
+        failingTests: []
+      };
+    }
+    const metrics = parseTestOutput(runner, output);
+    const failingTests = runner === "vitest" ? extractFailingTestsFromVitestOutput(output) : extractGenericFailures(output);
+    if (exitCode === 124) {
+      return {
+        status: "timeout",
+        testsRun: metrics.testsRun,
+        testsPassed: metrics.testsPassed,
+        testsFailed: metrics.testsFailed,
+        metricsMeasured: metrics.metricsMeasured,
+        duration,
+        exitCode,
+        outputTail,
+        failingTests
+      };
+    }
+    if (exitCode !== 0) {
+      return {
+        status: metrics.testsRun > 0 ? "failed" : "error",
+        testsRun: metrics.testsRun,
+        testsPassed: metrics.testsPassed,
+        testsFailed: metrics.testsFailed,
+        metricsMeasured: metrics.metricsMeasured,
+        duration,
+        exitCode,
+        outputTail,
+        failingTests
+      };
+    }
+    const inferredStatus = inferSuccessStatusForRunner(runner, metrics);
+    return {
+      status: !metrics.metricsMeasured && inferredStatus !== "failed" ? "unavailable" : inferredStatus,
+      testsRun: metrics.testsRun,
+      testsPassed: metrics.testsPassed,
+      testsFailed: metrics.testsFailed,
+      metricsMeasured: metrics.metricsMeasured,
+      duration,
+      exitCode,
+      outputTail,
+      failingTests
+    };
+  } catch (error) {
+    const err = error;
+    const duration = Date.now() - startTime;
+    const output = String(err?.all ?? err?.stdout ?? err?.stderr ?? err?.message ?? "");
+    const isAborted = err?.name === "AbortError" || err?.code === "ABORT_ERR" || err?.code === "ERR_ABORTED";
+    const isTimedOut = Boolean(err?.timedOut) || err?.killed && err?.signal === "SIGTERM";
+    if (isAborted || isTimedOut) {
+      return {
+        status: "timeout",
+        testsRun: 0,
+        testsPassed: 0,
+        testsFailed: 0,
+        metricsMeasured: false,
+        duration,
+        exitCode: 124,
+        outputTail: truncateToByteLimit(tailLines(output, 200), 1e5),
+        failingTests: []
+      };
+    }
+    const metrics = parseTestOutput(runner, output);
+    const failingTests = runner === "vitest" ? extractFailingTestsFromVitestOutput(output) : extractGenericFailures(output);
+    const isNotFound = err?.code === "ENOENT" || /\b(?:ENOENT|command not found)\b/i.test(output);
+    const exitCode = isNotFound ? 127 : typeof err.status === "number" ? err.status : 1;
+    return {
+      status: metrics.testsRun > 0 ? "failed" : "error",
+      testsRun: metrics.testsRun,
+      testsPassed: metrics.testsPassed,
+      testsFailed: metrics.testsFailed,
+      metricsMeasured: metrics.metricsMeasured,
+      duration,
+      exitCode,
+      outputTail: truncateToByteLimit(tailLines(output, 200), 1e5),
+      failingTests
+    };
+  }
+}
+async function getChangedFilesSinceRef(worktreePath, baseRef) {
+  if (!baseRef) return [];
+  const result = await execa("git", ["diff", "--name-only", baseRef, "--"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    reject: false
+  });
+  return String(result.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).sort();
+}
+function shellDisplayArg(value) {
+  return /[\s"'\\]/.test(value) ? JSON.stringify(value) : value;
+}
+async function runVitestPlanStep(worktreePath, step, options) {
+  const start = Date.now();
+  const command = `node scripts/dynamic-node-options.mjs vitest run ${step.displayArgs} --reporter=verbose`;
+  try {
+    const result = await execa(
+      "node",
+      ["scripts/dynamic-node-options.mjs", "vitest", "run", ...step.args, "--reporter=verbose"],
+      {
+        cwd: worktreePath,
+        stdio: "pipe",
+        all: true,
+        reject: false,
+        timeout: options.timeoutMs,
+        env: createVerificationTestEnv(),
+        extendEnv: false
+      }
+    );
+    const durationMs = Date.now() - start;
+    const { exitCode } = resolveVerificationExitCode(command, result);
+    const all = String(result.all ?? "");
+    const outputTail = truncateToByteLimit(tailLines(all, options.tailLines), 1e5);
+    const failingTests = exitCode === 0 ? [] : extractFailingTestsFromVitestOutput(all);
+    if (exitCode === 1 && /No test files found/i.test(all)) {
+      return {
+        command,
+        exitCode: -1,
+        durationMs,
+        outputTail,
+        status: "unavailable",
+        skipReason: "no-matching-tests",
+        failingTests: [],
+        language: "node"
+      };
+    }
+    const exitZeroFailure = exitCode === 0 ? detectExitZeroVerifyFailure(command, all) : void 0;
+    if (exitZeroFailure) {
+      return {
+        command,
+        exitCode: 1,
+        durationMs,
+        outputTail: truncateToByteLimit(
+          [outputTail, exitZeroFailure.message].filter(Boolean).join("\n"),
+          1e5
+        ),
+        status: "failed",
+        failingTests: [exitZeroFailure.message],
+        language: "node"
+      };
+    }
+    if (exitCode === 0) {
+      return {
+        command,
+        exitCode,
+        durationMs,
+        outputTail,
+        status: "passed",
+        failingTests,
+        language: "node"
+      };
+    }
+    if (exitCode === 124) {
+      return {
+        command,
+        exitCode,
+        durationMs,
+        outputTail,
+        status: "timeout",
+        failingTests,
+        language: "node"
+      };
+    }
+    return {
+      command,
+      exitCode,
+      durationMs,
+      outputTail,
+      status: "failed",
+      failingTests,
+      language: "node"
+    };
+  } catch (error) {
+    const durationMs = Date.now() - start;
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      command,
+      exitCode: 1,
+      durationMs,
+      outputTail: truncateToByteLimit(tailLines(message, options.tailLines), 1e5),
+      status: "error",
+      failingTests: [],
+      language: "node"
+    };
+  }
+}
+async function runExternalVitestPlanStep(worktreePath, step, options) {
+  const start = Date.now();
+  const invocation = buildExternalVitestRunInvocation(step.args);
+  const command = invocation.display;
+  try {
+    const result = await execa(invocation.cmd, invocation.args, {
+      cwd: worktreePath,
+      stdio: "pipe",
+      all: true,
+      reject: false,
+      timeout: options.timeoutMs,
+      env: createVerificationTestEnv(),
+      extendEnv: false
+    });
+    const durationMs = Date.now() - start;
+    const { exitCode } = resolveVerificationExitCode(command, result);
+    const all = String(result.all ?? "");
+    const outputTail = truncateToByteLimit(tailLines(all, options.tailLines), 1e5);
+    const failingTests = exitCode === 0 ? [] : extractFailingTestsFromVitestOutput(all);
+    if (exitCode === 1 && /No test files found/i.test(all)) {
+      return {
+        command,
+        exitCode: -1,
+        durationMs,
+        outputTail,
+        status: "unavailable",
+        skipReason: "no-matching-tests",
+        failingTests: [],
+        language: "node"
+      };
+    }
+    const unavailableSignal = detectVerificationToolUnavailable(command, all);
+    if (unavailableSignal) {
+      return {
+        command,
+        exitCode,
+        durationMs,
+        outputTail: truncateToByteLimit(
+          [outputTail, unavailableSignal.message].filter(Boolean).join("\n"),
+          1e5
+        ),
+        status: "unavailable",
+        failingTests: [],
+        language: "node"
+      };
+    }
+    const exitZeroFailure = exitCode === 0 ? detectExitZeroVerifyFailure(command, all) : void 0;
+    if (exitZeroFailure) {
+      return {
+        command,
+        exitCode: 1,
+        durationMs,
+        outputTail: truncateToByteLimit(
+          [outputTail, exitZeroFailure.message].filter(Boolean).join("\n"),
+          1e5
+        ),
+        status: "failed",
+        failingTests: [exitZeroFailure.message],
+        language: "node"
+      };
+    }
+    if (exitCode === 0) {
+      return {
+        command,
+        exitCode,
+        durationMs,
+        outputTail,
+        status: "passed",
+        failingTests,
+        language: "node"
+      };
+    }
+    if (exitCode === 124) {
+      return {
+        command,
+        exitCode,
+        durationMs,
+        outputTail,
+        status: "timeout",
+        failingTests,
+        language: "node"
+      };
+    }
+    return {
+      command,
+      exitCode,
+      durationMs,
+      outputTail,
+      status: "failed",
+      failingTests,
+      language: "node"
+    };
+  } catch (error) {
+    const durationMs = Date.now() - start;
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      command,
+      exitCode: 1,
+      durationMs,
+      outputTail: truncateToByteLimit(tailLines(message, options.tailLines), 1e5),
+      status: "error",
+      failingTests: [],
+      language: "node"
+    };
+  }
+}
+async function runCapabilityTestCommand(worktreePath, capabilityCommand, options) {
+  const language = describeVerificationCommand(capabilityCommand).language;
+  try {
+    const result = await runVerificationCommand(capabilityCommand, {
+      cwd: worktreePath,
+      timeoutMs: options.timeoutMs,
+      abortSignal: options.abortSignal
+    });
+    const durationMs = Date.now() - options.start;
+    const { exitCode } = resolveVerificationExitCode(capabilityCommand, result);
+    const all = String(result.all ?? "");
+    const outputTail = truncateToByteLimit(tailLines(all, options.tailLines), 1e5);
+    const failingTests = exitCode === 0 ? [] : extractGenericFailures(all);
+    const exitZeroFailure = exitCode === 0 ? detectExitZeroVerifyFailure(capabilityCommand, all) : void 0;
+    if (exitZeroFailure) {
+      return {
+        command: capabilityCommand,
+        language,
+        exitCode: 1,
+        durationMs,
+        outputTail: truncateToByteLimit(
+          [outputTail, exitZeroFailure.message].filter(Boolean).join("\n"),
+          1e5
+        ),
+        status: "failed",
+        failingTests: [exitZeroFailure.message]
+      };
+    }
+    if (exitCode === 0 && detectZeroCollectedTests(capabilityCommand, all)) {
+      return {
+        command: capabilityCommand,
+        language,
+        exitCode,
+        durationMs,
+        outputTail,
+        status: "unavailable",
+        failingTests: []
+      };
+    }
+    if (exitCode === 0) {
+      return {
+        command: capabilityCommand,
+        language,
+        exitCode,
+        durationMs,
+        outputTail,
+        status: "passed",
+        failingTests
+      };
+    }
+    if (exitCode === 124) {
+      return {
+        command: capabilityCommand,
+        language,
+        exitCode,
+        durationMs,
+        outputTail,
+        status: "timeout",
+        failingTests
+      };
+    }
+    if (detectVerificationToolUnavailable(capabilityCommand, all) !== void 0) {
+      return {
+        command: capabilityCommand,
+        language,
+        exitCode,
+        durationMs,
+        outputTail,
+        status: "unavailable",
+        failingTests: []
+      };
+    }
+    if (exitCode === 5 && isPythonStdlibUnittestCommand(capabilityCommand) && detectZeroCollectedTests(capabilityCommand, all)) {
+      return {
+        command: capabilityCommand,
+        language,
+        exitCode,
+        durationMs,
+        outputTail,
+        status: "unavailable",
+        failingTests: []
+      };
+    }
+    return {
+      command: capabilityCommand,
+      language,
+      exitCode,
+      durationMs,
+      outputTail,
+      status: "failed",
+      failingTests
+    };
+  } catch (error) {
+    const durationMs = Date.now() - options.start;
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      command: capabilityCommand,
+      language,
+      exitCode: 1,
+      durationMs,
+      outputTail: truncateToByteLimit(tailLines(message, options.tailLines), 1e5),
+      status: "error",
+      failingTests: []
+    };
+  }
+}
+async function runCapabilityTestCommandWithFallback(worktreePath, capabilityCommand, fallbackCommands, options) {
+  let result = await runCapabilityTestCommand(worktreePath, capabilityCommand, options);
+  const scopedFallbacks = selectFallbacksForCommand(capabilityCommand, fallbackCommands);
+  for (const fallbackCommand of scopedFallbacks) {
+    if (result.status !== "unavailable" || options.abortSignal?.aborted) break;
+    let fallbackOptions = options;
+    if (options.timeoutMs !== void 0) {
+      const remainingMs = Math.max(0, options.timeoutMs - (Date.now() - options.start));
+      if (remainingMs <= 0) {
+        return {
+          command: result.command,
+          language: result.language,
+          exitCode: 124,
+          durationMs: Date.now() - options.start,
+          outputTail: truncateToByteLimit(
+            [result.outputTail, "Fallback skipped: per-step timeout budget exhausted."].filter(Boolean).join("\n"),
+            1e5
+          ),
+          status: "timeout",
+          failingTests: []
+        };
+      }
+      fallbackOptions = { ...options, timeoutMs: remainingMs };
+    }
+    result = await runCapabilityTestCommand(worktreePath, fallbackCommand, fallbackOptions);
+  }
+  return result;
+}
+function combineVitestPlanResults(results) {
+  if (results.length === 0) {
+    return {
+      command: "",
+      exitCode: 130,
+      durationMs: 0,
+      outputTail: "Verification plan completed no commands.",
+      status: "error",
+      failingTests: []
+    };
+  }
+  if (results.length === 1) return results[0];
+  const representative = results.find((result) => result.status === "failed") ?? results.find((result) => result.status === "error") ?? results.find((result) => result.status === "timeout") ?? results.find((result) => result.status === "unavailable") ?? results.find((result) => result.status !== "passed") ?? results[0];
+  const exitCode = representative.exitCode ?? 0;
+  const status = representative.status ?? "passed";
+  const languages = new Set(results.map((result) => result.language).filter(Boolean));
+  const outputTail = truncateToByteLimit(
+    results.map((result) => [`$ ${result.command}`, result.outputTail].filter(Boolean).join("\n")).join("\n\n"),
+    1e5
+  );
+  return {
+    // Full ordered audit provenance of every executed plan-step command.
+    command: results.map((result) => result.command).filter(Boolean).join("\n"),
+    exitCode,
+    durationMs: results.reduce((sum, result) => sum + result.durationMs, 0),
+    outputTail,
+    status,
+    failingTests: Array.from(new Set(results.flatMap((result) => result.failingTests))),
+    // Preserve language only when every step agrees; otherwise leave unset so
+    // consumers do not re-tag multi-language output under one language.
+    language: languages.size === 1 ? results[0]?.language : void 0
+  };
+}
+async function runDeterministicTestGateWithArtifacts(worktreePath, options) {
+  const start = Date.now();
+  const timeoutMs = options.timeoutMs;
+  const maxTailLines = options.tailLines ?? 200;
+  if (options.command && options.command.trim().length > 0) {
+    const fallbackCommands = detectProjectCapabilities(worktreePath).verification.testFallback ?? [];
+    return runCapabilityTestCommandWithFallback(worktreePath, options.command, fallbackCommands, {
+      timeoutMs,
+      tailLines: maxTailLines,
+      start
+    });
+  }
+  const hasHarness = hasPoeticVitestHarness(worktreePath);
+  let changedFiles = [];
+  let changedTestFiles = [];
+  try {
+    changedFiles = await getChangedFilesSinceRef(worktreePath, options.baseRef);
+    changedTestFiles = hasHarness ? changedFiles.filter(isTestFile) : [];
+  } catch {
+    changedFiles = [];
+    changedTestFiles = [];
+  }
+  const changedArgs = options.baseRef ? ["--changed", options.baseRef] : ["--changed"];
+  const changedDisplayArgs = options.baseRef ? `--changed ${options.baseRef}` : "--changed";
+  const hasNonTestChanges = changedFiles.some((file) => !isTestFile(file));
+  const skippedAffectedGraphReason = changedTestFiles.length > 0 && hasNonTestChanges ? `Skipped Vitest affected graph: touched tests already ran; skipped broad --changed sweep for ${changedFiles.length} changed files.` : void 0;
+  const planSteps = changedTestFiles.length > 0 ? [
+    {
+      args: changedTestFiles,
+      displayArgs: changedTestFiles.map(shellDisplayArg).join(" ")
+    }
+  ] : [{ args: changedArgs, displayArgs: changedDisplayArgs }];
+  const command = planSteps.map(
+    (step) => hasHarness ? `node scripts/dynamic-node-options.mjs vitest run ${step.displayArgs} --reporter=verbose` : buildExternalVitestRunInvocation(step.args).display
+  ).join(" && ");
+  if (!hasHarness) {
+    const capabilityCommands = selectCapabilityTestCommandsForChanges(worktreePath, changedFiles);
+    if (capabilityCommands.length > 0) {
+      const fallbackCommands = detectProjectCapabilities(worktreePath).verification.testFallback ?? [];
+      const results2 = [];
+      for (const capabilityCommand of capabilityCommands) {
+        const result = await runCapabilityTestCommandWithFallback(
+          worktreePath,
+          capabilityCommand,
+          fallbackCommands,
+          { timeoutMs, tailLines: maxTailLines, start }
+        );
+        results2.push(result);
+        if (result.status !== "passed") break;
+      }
+      return combineVitestPlanResults(results2);
+    }
+    if (changedProjectLanguages(changedFiles).size > 0) {
+      return {
+        command,
+        exitCode: -1,
+        durationMs: Date.now() - start,
+        outputTail: "Skipped deterministic test gate: no matching project test command detected.",
+        status: "unavailable",
+        skipReason: "no-project-test-command",
+        failingTests: []
+      };
+    }
+    if (detectTestRunner(worktreePath) === "vitest") {
+      const results2 = [];
+      for (const step of planSteps) {
+        const result = await runExternalVitestPlanStep(worktreePath, step, {
+          timeoutMs,
+          tailLines: maxTailLines
+        });
+        results2.push(result);
+        if (result.status !== "passed") break;
+      }
+      return combineVitestPlanResults(results2);
+    }
+    const outputTail = "Skipped Vitest gate: no project test command detected.";
+    return {
+      command,
+      exitCode: -1,
+      durationMs: Date.now() - start,
+      outputTail,
+      status: "unavailable",
+      skipReason: "no-project-test-command",
+      failingTests: [],
+      language: "node"
+    };
+  }
+  const results = [];
+  const changedLanguages = changedProjectLanguages(changedFiles);
+  const shouldRunVitest = changedLanguages.size === 0 || changedLanguages.has("javascript") || changedLanguages.has("typescript");
+  const hasNonNodeChangedLanguage = [...changedLanguages].some(
+    (language) => language !== "javascript" && language !== "typescript" && language !== "node"
+  );
+  for (const step of planSteps) {
+    if (!shouldRunVitest) break;
+    const result = await runVitestPlanStep(worktreePath, step, {
+      timeoutMs,
+      tailLines: maxTailLines
+    });
+    results.push(result);
+    if (result.status !== "passed") break;
+  }
+  if (results.every((result) => result.status === "passed")) {
+    const nonNodeLanguages = new Set(
+      [...changedLanguages].filter(
+        (language) => language !== "javascript" && language !== "typescript" && language !== "node"
+      )
+    );
+    const nonNodeCommands = selectCapabilityTestCommandsForLanguages(
+      worktreePath,
+      nonNodeLanguages
+    );
+    if (hasNonNodeChangedLanguage && nonNodeCommands.length === 0) {
+      return {
+        command,
+        exitCode: -1,
+        durationMs: Date.now() - start,
+        outputTail: "Skipped deterministic test gate: no matching project test command detected.",
+        status: "unavailable",
+        skipReason: "no-project-test-command",
+        failingTests: []
+      };
+    }
+    const fallbackCommands = detectProjectCapabilities(worktreePath).verification.testFallback ?? [];
+    for (const capabilityCommand of nonNodeCommands) {
+      const result = await runCapabilityTestCommandWithFallback(
+        worktreePath,
+        capabilityCommand,
+        fallbackCommands,
+        { timeoutMs, tailLines: maxTailLines, start }
+      );
+      results.push(result);
+      if (result.status !== "passed") break;
+    }
+  }
+  if (results.length === 0) {
+    return {
+      command,
+      exitCode: -1,
+      durationMs: Date.now() - start,
+      outputTail: "Skipped deterministic test gate: no matching project test command detected.",
+      status: "unavailable",
+      skipReason: "no-project-test-command",
+      failingTests: [],
+      language: "node"
+    };
+  }
+  const combined = combineVitestPlanResults(results);
+  if (skippedAffectedGraphReason) {
+    combined.outputTail = truncateToByteLimit(
+      [combined.outputTail, skippedAffectedGraphReason].filter(Boolean).join("\n\n"),
+      1e5
+    );
+  }
+  return combined;
+}
+function buildTestCommand(runner, testFiles, worktreePath) {
+  const filesArg = testFiles.map((f) => `"${f}"`).join(" ");
+  const root = worktreePath ?? "";
+  switch (runner) {
+    case "vitest":
+    case "jest":
+    case "mocha":
+    case "ava":
+    case "node-test":
+      return resolveScopedNodeTestInvocation(runner, testFiles, root)?.display ?? "";
+    case "pytest":
+      return `pytest ${filesArg}`.trim();
+    case "unittest":
+      return detectPythonUnittestCommand(detectProjectCapabilities(root)) ?? "python3 -m unittest discover";
+    case "go":
+      return selectRunnerLanguageResolverCommand(
+        detectProjectCapabilities(root).verification.test,
+        "go"
+      ) ?? "go test ./...";
+    case "cargo":
+      return selectRunnerLanguageResolverCommand(
+        detectProjectCapabilities(root).verification.test,
+        "cargo"
+      ) ?? "cargo test --locked";
+    case "maven":
+      return selectRunnerLanguageResolverCommand(
+        detectProjectCapabilities(root).verification.test,
+        "maven"
+      ) ?? "mvn test";
+    case "gradle":
+      return selectRunnerLanguageResolverCommand(
+        detectProjectCapabilities(root).verification.test,
+        "gradle"
+      ) ?? "gradle test";
+    case "powershell":
+      return "pwsh -NoProfile -Command Invoke-Pester";
+    default:
+      throw new Error(`Unknown test runner: ${runner}`);
+  }
+}
+function parseTestOutput(runner, output) {
+  const fallback = {
+    testsRun: 0,
+    testsPassed: 0,
+    testsFailed: 0,
+    metricsMeasured: false
+  };
+  if (!output) {
+    return fallback;
+  }
+  try {
+    if (runner === "vitest") {
+      return asMeasuredMetrics(parseVitestOutput(output));
+    } else if (runner === "jest") {
+      return asMeasuredMetrics(parseJestOutput(output));
+    } else if (runner === "mocha" || runner === "ava") {
+      return asMeasuredMetrics(parseMochaStyleOutput(output));
+    } else if (runner === "pytest") {
+      return asMeasuredMetrics(parsePytestOutput(output));
+    } else if (runner === "unittest") {
+      return asMeasuredMetrics(parseUnittestOutput(output));
+    } else if (
+      // node:test emits TAP or (Node 24 default) spec; the generic parser
+      // reads both the TAP plan/trailer and the spec tests/pass/fail footer.
+      runner === "node-test" || runner === "go" || runner === "cargo" || runner === "maven" || runner === "gradle" || runner === "powershell" || runner === "generic"
+    ) {
+      return parseGenericPassFailOutput(output);
+    }
+  } catch {
+    return fallback;
+  }
+  return fallback;
+}
+function extractGenericFailures(output) {
+  return output.split(/\r?\n/).filter((line) => /\b(fail|failed|error)\b/i.test(line)).map((line) => line.trim()).filter(Boolean).slice(0, 20);
+}
+function parseVitestOutput(output) {
+  const testMatch = output.match(/Tests\s+(.+?)(?:\n|$)/);
+  if (testMatch) {
+    const summary = testMatch[1] ?? "";
+    const passed = parseInt(summary.match(/(\d+)\s+passed/)?.[1] || "0", 10);
+    const failed = parseInt(summary.match(/(\d+)\s+failed/)?.[1] || "0", 10);
+    return {
+      testsRun: passed + failed,
+      testsPassed: passed,
+      testsFailed: failed
+    };
+  }
+  return { testsRun: 0, testsPassed: 0, testsFailed: 0 };
+}
+function parseJestOutput(output) {
+  const testMatch = output.match(/Tests:\s+(?:(\d+)\s+failed,\s+)?(\d+)\s+passed,\s+(\d+)\s+total/);
+  if (testMatch) {
+    const failed = parseInt(testMatch[1] || "0", 10);
+    const passed = parseInt(testMatch[2] || "0", 10);
+    const total = parseInt(testMatch[3] || "0", 10);
+    return {
+      testsRun: total,
+      testsPassed: passed,
+      testsFailed: failed
+    };
+  }
+  return { testsRun: 0, testsPassed: 0, testsFailed: 0 };
+}
+function parseMochaStyleOutput(output) {
+  const mochaPassing = output.match(/^\s*(\d+)\s+passing\b/m);
+  const mochaFailing = output.match(/^\s*(\d+)\s+failing\b/m);
+  if (mochaPassing || mochaFailing) {
+    const passed = Number(mochaPassing?.[1] ?? 0);
+    const failed = Number(mochaFailing?.[1] ?? 0);
+    return { testsRun: passed + failed, testsPassed: passed, testsFailed: failed };
+  }
+  const avaPassed = output.match(/^\s*(\d+)\s+tests?\s+passed\b/m);
+  const avaFailed = output.match(/^\s*(\d+)\s+tests?\s+failed\b/m);
+  if (avaPassed || avaFailed) {
+    const passed = Number(avaPassed?.[1] ?? 0);
+    const failed = Number(avaFailed?.[1] ?? 0);
+    return { testsRun: passed + failed, testsPassed: passed, testsFailed: failed };
+  }
+  const tap = parseTapSummary(output);
+  if (tap) return tap;
+  return { testsRun: 0, testsPassed: 0, testsFailed: 0 };
+}
+function parseTapSummary(output) {
+  const tapTests = Number(output.match(/^#\s+tests\s+(\d+)\s*$/im)?.[1] ?? NaN);
+  if (Number.isFinite(tapTests)) {
+    const tapPassed = Number(output.match(/^#\s+pass\s+(\d+)\s*$/im)?.[1] ?? 0);
+    const tapFailed = Number(output.match(/^#\s+fail\s+(\d+)\s*$/im)?.[1] ?? 0);
+    const tapCancelled = Number(output.match(/^#\s+cancelled\s+(\d+)\s*$/im)?.[1] ?? 0);
+    return {
+      testsRun: tapTests,
+      testsPassed: tapPassed,
+      testsFailed: tapFailed + tapCancelled
+    };
+  }
+  const resultLines = output.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^(?:not\s+ok|ok)\s+\d+\b/i.test(line));
+  if (resultLines.length > 0) {
+    const failed = resultLines.filter((line) => /^not\s+ok\b/i.test(line)).length;
+    const passed = resultLines.length - failed;
+    return { testsRun: resultLines.length, testsPassed: passed, testsFailed: failed };
+  }
+  return void 0;
+}
+function parseUnittestOutput(output) {
+  const sumMatches = (pattern) => {
+    let total = 0;
+    for (const match of output.matchAll(pattern)) {
+      total += Number(match[1] ?? 0);
+    }
+    return total;
+  };
+  const testsRun = sumMatches(/^[ \t]*Ran[ \t]+(\d+)[ \t]+tests?\b/gim);
+  if (testsRun === 0) {
+    return { testsRun: 0, testsPassed: 0, testsFailed: 0 };
+  }
+  const outcomeLines = Array.from(
+    output.matchAll(/^[ \t]*(?:OK|FAILED)\b[ \t]*(?:\(([^)]*)\))?[ \t]*$/gim)
+  ).map((match) => match[1] ?? "").join(", ");
+  const countIn = (pattern) => {
+    let total = 0;
+    for (const match of outcomeLines.matchAll(pattern)) {
+      total += Number(match[1] ?? 0);
+    }
+    return total;
+  };
+  const failures = countIn(/\bfailures=(\d+)/gi);
+  const errors = countIn(/\berrors=(\d+)/gi);
+  const unexpectedSuccesses = countIn(/\bunexpected\s+successes=(\d+)/gi);
+  const skipped = countIn(/\bskipped=(\d+)/gi);
+  const testsFailed = failures + errors + unexpectedSuccesses;
+  const testsPassed = Math.max(0, testsRun - testsFailed - skipped);
+  return { testsRun, testsPassed, testsFailed };
+}
+function parsePytestOutput(output) {
+  const summary = output.match(/=+\s*(.+?)\s*=+\s*$/m)?.[1] ?? output;
+  const passed = Number(summary.match(/(\d+)\s+passed/)?.[1] ?? 0);
+  const failed = Number(summary.match(/(\d+)\s+failed/)?.[1] ?? 0);
+  const errors = Number(summary.match(/(\d+)\s+error/)?.[1] ?? 0);
+  return {
+    testsRun: passed + failed + errors,
+    testsPassed: passed,
+    testsFailed: failed + errors
+  };
+}
+function parseNodeSpecSummary(output) {
+  const cleaned = stripAnsiSequences(output);
+  const count = (label) => {
+    const match = cleaned.match(
+      new RegExp(String.raw`^\s*(?:\u2139\s+)?${label}\s+(\d+)\s*$`, "im")
+    )?.[1];
+    return match === void 0 ? void 0 : Number(match);
+  };
+  const tests = count("tests");
+  const pass = count("pass");
+  const fail = count("fail");
+  if (tests === void 0 || pass === void 0 || fail === void 0) {
+    return void 0;
+  }
+  if (!Number.isFinite(tests) || !Number.isFinite(pass) || !Number.isFinite(fail)) {
+    return void 0;
+  }
+  const cancelled = count("cancelled") ?? 0;
+  const skipped = count("skipped") ?? 0;
+  const todo = count("todo") ?? 0;
+  const testsFailed = fail + cancelled;
+  const accounted = pass + fail + cancelled + skipped + todo;
+  return {
+    testsRun: tests,
+    testsPassed: pass,
+    testsFailed,
+    metricsMeasured: tests > 0 && accounted === tests
+  };
+}
+function parseGenericPassFailOutput(output) {
+  const tap = parseTapSummary(output);
+  if (tap) {
+    return { ...tap, metricsMeasured: tap.testsRun > 0 };
+  }
+  const spec = parseNodeSpecSummary(output);
+  if (spec) {
+    return spec;
+  }
+  const pester = output.match(
+    /Tests\s+Passed:\s*(\d+)\s*,\s*Failed:\s*(\d+)\s*,\s*Skipped:\s*(\d+)/i
+  );
+  if (pester) {
+    const passed = Number(pester[1] ?? 0);
+    const failed = Number(pester[2] ?? 0);
+    const skipped = Number(pester[3] ?? 0);
+    return {
+      testsRun: passed + failed + skipped,
+      testsPassed: passed,
+      testsFailed: failed,
+      metricsMeasured: passed + failed + skipped > 0
+    };
+  }
+  const surefireMatches = Array.from(
+    output.matchAll(
+      /^\s*(?:\[INFO\]\s*)?Tests run:\s*(\d+),\s*Failures:\s*(\d+),\s*Errors:\s*(\d+)(?:,\s*Skipped:\s*(\d+))?/gim
+    )
+  );
+  if (surefireMatches.length > 0) {
+    let testsRun = 0;
+    let testsFailed = 0;
+    let skipped = 0;
+    for (const match of surefireMatches) {
+      testsRun += Number(match[1] ?? 0);
+      testsFailed += Number(match[2] ?? 0) + Number(match[3] ?? 0);
+      skipped += Number(match[4] ?? 0);
+    }
+    return {
+      testsRun,
+      testsPassed: Math.max(0, testsRun - testsFailed - skipped),
+      testsFailed,
+      metricsMeasured: testsRun > 0
+    };
+  }
+  const gradleCompleted = output.match(/(\d+)\s+tests?\s+completed\b/i);
+  if (gradleCompleted) {
+    const testsRun = Number(gradleCompleted[1] ?? 0);
+    const failedMatch = output.match(/(\d+)\s+failed\b/i);
+    const testsFailed = Number(failedMatch?.[1] ?? 0);
+    return {
+      testsRun,
+      testsPassed: Math.max(0, testsRun - testsFailed),
+      testsFailed,
+      metricsMeasured: testsRun > 0
+    };
+  }
+  const failureZeroStripped = output.replace(/\b(?:failures?|failed|errors?):\s*0\b/gi, "").replace(/\b0\s+(?:failures?|failed|errors?)\b/gi, "").replace(/\u2139\s+fail\s+0\b/gi, "").replace(/\bfail\s+0\b/gi, "");
+  if (/\b(fail|failed|error)\b/i.test(failureZeroStripped)) {
+    return { testsRun: 1, testsPassed: 0, testsFailed: 1, metricsMeasured: false };
+  }
+  const successProse = /\b(ok|pass|passed|test result: ok|BUILD SUCCESS|BUILD SUCCESSFUL)\b/i.test(
+    output
+  );
+  return {
+    testsRun: 0,
+    testsPassed: 0,
+    testsFailed: 0,
+    metricsMeasured: false,
+    successProse
+  };
+}
+
+export {
+  runLintOnDiffWithArtifacts,
+  hasPoeticVitestHarness,
+  runTestGate,
+  runDeterministicTestGateWithArtifacts
+};
+//# sourceMappingURL=chunk-3ZPQLGV7.js.map