@outcomeeng/spx 0.6.18 → 0.6.19

package/dist/cli.js

@@ -1,5 +1,5 @@
 // src/cli.ts
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 
 // src/interfaces/cli/program.ts
 import { Command } from "commander";
@@ -14647,6 +14647,9 @@ function formatMissingCitedDecisionError(citedPath, citingPath) {
 function specContextBootstrap(nodeCount) {
   return nodeCount === 0;
 }
+function compareSpecContextOrdinal(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
 var SPEC_CONTEXT_DIGEST_ALGORITHM = "sha256";
 function specContextDigest(rawBytes) {
   return `${SPEC_CONTEXT_DIGEST_ALGORITHM}:${createHash4(SPEC_CONTEXT_DIGEST_ALGORITHM).update(rawBytes).digest("hex")}`;
@@ -14661,9 +14664,6 @@ function formatUnreadableContextDocumentError(path4) {
   return `Spec context document unreadable: ${path4}`;
 }
 
-// src/lib/node-status/ci-projection.ts
-import { parse as parseYaml3 } from "yaml";
-
 // src/lib/node-status/classify.ts
 var NODE_STATUS_SCHEMA_VERSION = 1;
 var NODE_STATUS_JSON_INDENT = 2;
@@ -14739,9 +14739,11 @@ function verificationPassed(verification) {
 import { readFileSync } from "fs";
 import { join as join19 } from "path";
 var NODE_STATUS_EXCLUDE_FILENAME = "EXCLUDE";
-var PATH_SEGMENT_SEPARATOR2 = "/";
-var CURRENT_DIRECTORY_SEGMENT = ".";
-var PARENT_DIRECTORY_SEGMENT = "..";
+var NODE_STATUS_EXCLUDE_PATH_GRAMMAR = {
+  SEGMENT_SEPARATOR: "/",
+  CURRENT_DIRECTORY_SEGMENT: ".",
+  PARENT_DIRECTORY_SEGMENT: ".."
+};
 function isNodeError(err) {
   return err instanceof Error && "code" in err;
 }
@@ -14752,14 +14754,17 @@ function parseExcludeEntries(content) {
   return content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).map(validateExcludeEntry);
 }
 function validateExcludeEntry(entry) {
-  const segments = entry.split(PATH_SEGMENT_SEPARATOR2);
-  if (entry.startsWith(PATH_SEGMENT_SEPARATOR2) || segments.some(
-    (segment) => segment.length === 0 || segment === CURRENT_DIRECTORY_SEGMENT || segment === PARENT_DIRECTORY_SEGMENT
+  const segments = entry.split(NODE_STATUS_EXCLUDE_PATH_GRAMMAR.SEGMENT_SEPARATOR);
+  if (entry.startsWith(NODE_STATUS_EXCLUDE_PATH_GRAMMAR.SEGMENT_SEPARATOR) || segments.some(
+    (segment) => segment.length === 0 || segment === NODE_STATUS_EXCLUDE_PATH_GRAMMAR.CURRENT_DIRECTORY_SEGMENT || segment === NODE_STATUS_EXCLUDE_PATH_GRAMMAR.PARENT_DIRECTORY_SEGMENT
   )) {
-    throw new Error(`Invalid ${SPEC_TREE_CONFIG.ROOT_DIRECTORY}/${NODE_STATUS_EXCLUDE_FILENAME} entry: ${entry}`);
+    throw new Error(nodeStatusInvalidExcludeEntryMessage(entry));
   }
   return entry;
 }
+function nodeStatusInvalidExcludeEntryMessage(entry) {
+  return `Invalid ${SPEC_TREE_CONFIG.ROOT_DIRECTORY}/${NODE_STATUS_EXCLUDE_FILENAME} entry: ${entry}`;
+}
 function createNodeStatusExcludeReader(productDir) {
   let content;
   try {
@@ -14961,12 +14966,14 @@ async function updateNodeStatus(options) {
       continue;
     }
     const evidence = evidenceByNode.get(node.id) ?? [];
+    const statusPath = nodeStatusPath(productDir, node.id);
+    const committedVerification = readNodeStatus(dirname11(statusPath))?.[NODE_STATUS_FIELD.VERIFICATION];
     const verification = await resolveVerification(node, {
       evidence,
       isExcluded: excludeReader.isExcluded(node),
-      resolveOutcome
+      resolveOutcome,
+      committedOutcomes: testOutcomes(committedVerification)
     });
-    const statusPath = nodeStatusPath(productDir, node.id);
     liveStatusPaths.add(statusPath);
     await writeNodeStatus(statusPath, verification);
   }
@@ -14977,7 +14984,8 @@ async function resolveVerification(node, input) {
   if (input.isExcluded) return createTestVerification(input.evidence, NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN);
   return createTestVerificationFromOutcomes(
     input.evidence,
-    await input.resolveOutcome(node.id, evidencePaths(input.evidence))
+    await input.resolveOutcome(node.id, evidencePaths(input.evidence)),
+    input.committedOutcomes
   );
 }
 function collectEvidenceByNode(snapshot) {
@@ -14993,16 +15001,23 @@ function collectEvidenceByNode(snapshot) {
 }
 function createTestVerification(evidence, outcome) {
   const outcomes = Object.fromEntries(evidence.map((entry) => [evidencePath(entry), outcome]));
-  return createTestVerificationFromOutcomes(evidence, outcomes);
+  return createTestVerificationFromOutcomes(evidence, outcomes, {});
 }
-function createTestVerificationFromOutcomes(evidence, resolvedOutcomes) {
+function createTestVerificationFromOutcomes(evidence, resolvedOutcomes, committedOutcomes) {
   const outcomes = {};
   for (const entry of evidence) {
     const path4 = evidencePath(entry);
-    outcomes[path4] = resolvedOutcomes[path4] ?? NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN;
+    outcomes[path4] = resolvedOutcomes[path4] ?? committedOutcomes[path4] ?? NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN;
   }
   return { [NODE_STATUS_VERIFICATION_MECHANISM.TEST]: createNodeStatusMechanismRecord(outcomes) };
 }
+function testOutcomes(verification) {
+  const record7 = verification?.[NODE_STATUS_VERIFICATION_MECHANISM.TEST];
+  if (record7 === void 0) return {};
+  return Object.fromEntries(
+    Object.entries(record7).filter(([reference]) => reference !== NODE_STATUS_FIELD.OVERALL)
+  );
+}
 function evidencePaths(evidence) {
   return evidence.map(evidencePath);
 }
@@ -15152,7 +15167,7 @@ function resolveSpecContextTarget(snapshot, input) {
     if (candidates.length > 1) {
       return {
         failure: {
-          candidates: candidates.map(nodeSegment).sort((left, right) => left.localeCompare(right)),
+          candidates: candidates.map(nodeSegment).sort(compareSpecContextOrdinal),
           input,
           kind: SPEC_CONTEXT_TARGET_FAILURE_KIND.AMBIGUOUS_SEGMENT,
           segment
@@ -15201,7 +15216,7 @@ function refPath(ref) {
   return ref?.path;
 }
 function sortPaths(paths) {
-  return [...paths].sort((left, right) => left.localeCompare(right));
+  return [...paths].sort(compareSpecContextOrdinal);
 }
 function fullSpecPath(path4) {
   return path4.startsWith(SPEC_TREE_ROOT_PREFIX) ? path4 : `${SPEC_TREE_ROOT_PREFIX}${path4}`;
@@ -15247,11 +15262,11 @@ function lowerIndexSiblingsForContextNodes(snapshot, contextNodes) {
     }
   }
   lowerSiblings.sort((left, right) => {
-    const parentComparison = (left.parentId ?? "").localeCompare(right.parentId ?? "");
+    const parentComparison = compareSpecContextOrdinal(left.parentId ?? "", right.parentId ?? "");
     if (parentComparison !== 0) return parentComparison;
     const orderComparison = left.order - right.order;
     if (orderComparison !== 0) return orderComparison;
-    return left.id.localeCompare(right.id);
+    return compareSpecContextOrdinal(left.id, right.id);
   });
   return lowerSiblings;
 }
@@ -15386,9 +15401,7 @@ async function citedDecisionDocuments(productDir, sources, knownPaths, includePa
 }
 async function localOverlayPaths(productDir, trackedPaths) {
   if (trackedPaths !== void 0) {
-    return [...trackedPaths].filter((path4) => isLocalOverlayPath(path4)).sort(
-      (left, right) => left.localeCompare(right)
-    );
+    return [...trackedPaths].filter((path4) => isLocalOverlayPath(path4)).sort(compareSpecContextOrdinal);
   }
   let entries;
   try {
@@ -15396,7 +15409,7 @@ async function localOverlayPaths(productDir, trackedPaths) {
   } catch {
     return [];
   }
-  return entries.filter((name) => name.endsWith(SPEC_TREE_GRAMMAR.LOCAL_OVERLAYS.EXTENSION)).sort((left, right) => left.localeCompare(right)).map((name) => childSpecPath(SPEC_CONTEXT_LOCAL_OVERLAY_DIRECTORY, name));
+  return entries.filter((name) => name.endsWith(SPEC_TREE_GRAMMAR.LOCAL_OVERLAYS.EXTENSION)).sort(compareSpecContextOrdinal).map((name) => childSpecPath(SPEC_CONTEXT_LOCAL_OVERLAY_DIRECTORY, name));
 }
 async function withDocumentContent(productDir, read, scannedDocuments) {
   const enriched = [];
@@ -15789,7 +15802,7 @@ function groupTestFiles(testFiles, languages) {
 
 // src/domains/test/targeting.ts
 var TESTS_DIRECTORY_NAME3 = SPEC_TREE_EVIDENCE_FILE.DIRECTORY_NAME;
-var PATH_SEGMENT_SEPARATOR3 = "/";
+var PATH_SEGMENT_SEPARATOR2 = "/";
 function normalizeTargetOperand(operand) {
   return normalizePathPrefix(operand);
 }
@@ -15799,7 +15812,7 @@ function matchOperand(discovered, operand, recursive) {
     return applyPathFilter(discovered, { include: [normalized] });
   }
   return applyPathFilter(discovered, {
-    include: [`${normalized}${PATH_SEGMENT_SEPARATOR3}${TESTS_DIRECTORY_NAME3}`]
+    include: [`${normalized}${PATH_SEGMENT_SEPARATOR2}${TESTS_DIRECTORY_NAME3}`]
   });
 }
 function resolveTargetedTestFiles(discovered, selection) {
@@ -15842,7 +15855,7 @@ async function runTests(options, deps) {
   for (const group of groups) {
     const invocation = await group.language.runTests(
       {
-        projectRoot: options.productDir,
+        productDir: options.productDir,
         testPaths: group.testPaths,
         excludedNodePaths: runnerExcludedNodePaths
       },
@@ -16470,7 +16483,7 @@ async function relatedTestPaths(sourceFiles, options, baseRef, candidateTestPath
     if (language.relatedTestPaths === void 0) continue;
     const relatedDeps = deps.relatedDepsFor(language.name);
     const languageResolution = await language.relatedTestPaths(
-      { projectRoot: options.productDir, sourcePaths: sourceFiles, candidateTestPaths: candidateTestPaths2, baseRef },
+      { productDir: options.productDir, sourcePaths: sourceFiles, candidateTestPaths: candidateTestPaths2, baseRef },
       options.staged === true ? { ...relatedDeps, readFile: (path4) => readStagedFile(options.productDir, path4, deps.git) } : relatedDeps
     );
     for (const sourceFile of languageResolution.resolvedSourcePaths) resolved.add(sourceFile);
@@ -16877,16 +16890,6 @@ async function runTestsCommand(options, deps) {
   );
   return { dispatch, runFile, recorded };
 }
-async function runNodeCommand(options, deps) {
-  const recording = resolveRecordingDependencies(deps);
-  const runFile = await reserveRunFile(options.productDir, recording);
-  const dispatch = await runTests(
-    { productDir: options.productDir, registry: deps.registry, passingScope: { include: [options.nodePath] } },
-    { runnerDepsFor: deps.runnerDepsFor }
-  );
-  const recorded = await recordRun(runFile, options.productDir, dispatch, recording, deps.registry);
-  return { dispatch, runFile, recorded };
-}
 
 // src/commands/spec/node-outcome-resolver.ts
 var PATH_SEPARATOR3 = "/";
@@ -16895,9 +16898,6 @@ function createNodeOutcomeResolver(deps) {
   let evidence;
   const currentInputsByCoveredPaths = /* @__PURE__ */ new Map();
   const sharedEvidence = () => evidence ??= loadResolverEvidence(deps);
-  const refreshEvidence = () => {
-    evidence = loadResolverEvidence(deps);
-  };
   const currentInputsFor = (coveredPaths) => {
     const cacheKey = coveredPathCollectionKey(coveredPaths);
     const cached = currentInputsByCoveredPaths.get(cacheKey);
@@ -16912,13 +16912,13 @@ function createNodeOutcomeResolver(deps) {
     const { discoveredTestPaths, terminalRuns } = await sharedEvidence();
     const nodePath = `${SPEC_TREE_CONFIG.ROOT_DIRECTORY}${PATH_SEPARATOR3}${nodeId}`;
     const nodeTestPaths = filterNodeTestPaths(discoveredTestPaths, nodePath, evidencePaths2);
-    const usable = await usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor);
-    if (usable !== void 0) {
-      return usable;
-    }
-    const { dispatch } = await runNodeCommand({ productDir: deps.productDir, nodePath }, deps);
-    refreshEvidence();
-    return outcomesForPaths(dispatch.outcomes, nodeTestPaths);
+    return recordedOutcomes(
+      discoveredTestPaths,
+      terminalRuns,
+      evidencePaths2,
+      nodeTestPaths,
+      currentInputsFor
+    );
   };
 }
 function coveredPathCollectionKey(coveredPaths) {
@@ -16934,24 +16934,27 @@ function filterNodeTestPaths(discoveredTestPaths, nodePath, evidencePaths2) {
   const discovered = new Set(discoveredTestPaths.filter((path4) => path4.startsWith(prefix)));
   return evidencePaths2.filter((path4) => discovered.has(path4));
 }
-async function usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor) {
-  const latest = selectLatestTerminalTestRunForNode(terminalRuns, nodeTestPaths);
-  if (latest === void 0) {
-    return void 0;
-  }
-  const runCoveredPaths = latest.state.runnerOutcomes.flatMap((outcome) => outcome.testPaths);
+async function recordedOutcomes(discoveredTestPaths, terminalRuns, evidencePaths2, nodeTestPaths, currentInputsFor) {
+  const resolved = Object.fromEntries(
+    evidencePaths2.map((path4) => [path4, NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN])
+  );
   const presentTestPaths = new Set(discoveredTestPaths);
-  if (!runCoveredPaths.every((path4) => presentTestPaths.has(path4))) {
-    return void 0;
+  for (const path4 of nodeTestPaths) {
+    const latest = selectLatestTerminalTestRunForNode(terminalRuns, [path4]);
+    if (latest === void 0) continue;
+    const runCoveredPaths = latest.state.runnerOutcomes.flatMap((outcome) => outcome.testPaths);
+    if (!runCoveredPaths.every((coveredPath) => presentTestPaths.has(coveredPath))) {
+      delete resolved[path4];
+      continue;
+    }
+    const current = await currentInputsFor(runCoveredPaths);
+    if (!isStalenessMatch(extractStalenessInputs(latest.state), current)) {
+      delete resolved[path4];
+      continue;
+    }
+    resolved[path4] = outcomeForPath(latest.state.runnerOutcomes, path4);
   }
-  const current = await currentInputsFor(runCoveredPaths);
-  const fresh = isStalenessMatch(extractStalenessInputs(latest.state), current);
-  return fresh && latest.state.status === TEST_RUN_STATE_STATUS.PASSED ? outcomesForPaths(latest.state.runnerOutcomes, nodeTestPaths) : void 0;
-}
-function outcomesForPaths(outcomes, nodeTestPaths) {
-  return Object.fromEntries(
-    nodeTestPaths.map((path4) => [path4, outcomeForPath(outcomes, path4)])
-  );
+  return resolved;
 }
 function outcomeForPath(outcomes, path4) {
   const covering = outcomes.filter((outcome) => outcome.testPaths.includes(path4));
@@ -17173,11 +17176,11 @@ function coveredProductInputPaths(coveredTestPaths2) {
 function excludeFlag(nodePath) {
   return `${PYTHON_PYTEST_IGNORE_FLAG_PREFIX}${nodePath}${PYTHON_PYTEST_IGNORE_FLAG_SUFFIX}`;
 }
-function detect(projectRoot, deps) {
-  return deps?.isLanguagePresent?.(projectRoot) ?? detectPython(projectRoot).present;
+function detect(productDir, deps) {
+  return deps?.isLanguagePresent?.(productDir) ?? detectPython(productDir).present;
 }
 async function runTests2(request, deps) {
-  if (!detect(request.projectRoot, deps)) {
+  if (!detect(request.productDir, deps)) {
     return { invoked: false };
   }
   const args = [
@@ -17248,7 +17251,7 @@ function createJournalReporter(sink) {
 async function runTestsStreaming(request, deps) {
   const reporter = createJournalReporter(deps.sink);
   await deps.starter.start({
-    projectRoot: request.projectRoot,
+    productDir: request.productDir,
     testPaths: request.testPaths,
     reporters: [reporter]
   });
@@ -17261,7 +17264,7 @@ function createVitestRunStarter() {
       const priorExitCode = process.exitCode;
       try {
         const vitest = await startVitest("test", [...options.testPaths], {
-          root: options.projectRoot,
+          root: options.productDir,
           watch: false,
           reporters: [...options.reporters]
         });
@@ -17310,17 +17313,17 @@ function matchesTestFile2(filePath) {
 function excludeFlag2(nodePath) {
   return `${TYPESCRIPT_VITEST_EXCLUDE_FLAG_PREFIX}${nodePath}${TYPESCRIPT_VITEST_EXCLUDE_FLAG_SUFFIX}`;
 }
-function detect2(projectRoot, deps) {
-  return deps?.isLanguagePresent?.(projectRoot) ?? detectTypeScript(projectRoot).present;
+function detect2(productDir, deps) {
+  return deps?.isLanguagePresent?.(productDir) ?? detectTypeScript(productDir).present;
 }
 async function runTests3(request, deps) {
-  if (!detect2(request.projectRoot, deps)) {
+  if (!detect2(request.productDir, deps)) {
     return { invoked: false };
   }
   const args = [
     ...VITEST_INVOKE_ARGS,
     VITEST_ROOT_FLAG,
-    request.projectRoot,
+    request.productDir,
     ...request.testPaths,
     ...request.excludedNodePaths.map(excludeFlag2)
   ];
@@ -17515,7 +17518,7 @@ async function readCandidateTest(path4, deps, moduleTextCache) {
   return loaded;
 }
 async function relatedTestPaths2(request, deps) {
-  if (!detect2(request.projectRoot, deps)) {
+  if (!detect2(request.productDir, deps)) {
     return { testPaths: [], resolvedSourcePaths: [] };
   }
   const sourcePaths = new Set(request.sourcePaths);
@@ -17545,7 +17548,7 @@ async function relatedTestPaths2(request, deps) {
   return { testPaths, resolvedSourcePaths: [...resolvedSourcePaths] };
 }
 async function runTestsStreaming2(request, deps) {
-  if (!detect2(request.projectRoot, deps)) {
+  if (!detect2(request.productDir, deps)) {
     return { invoked: false };
   }
   const terminalStatus = await runTestsStreaming(request, {
@@ -17571,141 +17574,13 @@ var testingRegistry = {
   languages: [typescriptTestingLanguage, pythonTestingLanguage]
 };
 
-// src/interfaces/cli/test-runner-deps.ts
-import { createWriteStream } from "fs";
-import { mkdtemp as mkdtemp3, readFile as readFile12 } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join28 } from "path";
-import { finished } from "stream/promises";
-var PROCESS_FAILURE_EXIT_CODE = 1;
-var AGENT_ARTIFACT_DIR_PREFIX = "spx-test-agent-";
-var STDOUT_FILE_SUFFIX = "stdout.log";
-var STDERR_FILE_SUFFIX = "stderr.log";
-var ARTIFACT_INDEX_WIDTH = 3;
-var ARTIFACT_INDEX_RADIX = 10;
-var ARTIFACT_FILE_FLAGS = "wx";
-var EMPTY_RUNNER_ARGS = [];
-function createCommandRunner(productDir, outStream) {
-  return (command, args) => new Promise((resolveResult) => {
-    const child = spawnManagedSubprocess(lifecycleProcessRunner, command, args, {
-      cwd: productDir
-    });
-    child.stdout?.pipe(outStream);
-    child.stderr?.pipe(process.stderr);
-    child.on("close", (code) => resolveResult({ exitCode: code ?? PROCESS_FAILURE_EXIT_CODE }));
-    child.on("error", () => resolveResult({ exitCode: PROCESS_FAILURE_EXIT_CODE }));
-  });
-}
-function createRelatedCommandRunner(productDir) {
-  return (command, args) => new Promise((resolveResult) => {
-    const stdout = [];
-    const stderr = [];
-    const child = spawnManagedSubprocess(lifecycleProcessRunner, command, args, {
-      cwd: productDir
-    });
-    child.stdout?.on("data", (chunk) => stdout.push(String(chunk)));
-    child.stderr?.on("data", (chunk) => stderr.push(String(chunk)));
-    child.on("close", (code) => resolveResult({
-      exitCode: code ?? PROCESS_FAILURE_EXIT_CODE,
-      stdout: stdout.join(""),
-      stderr: stderr.join("")
-    }));
-    child.on("error", (error) => resolveResult({
-      exitCode: PROCESS_FAILURE_EXIT_CODE,
-      stdout: stdout.join(""),
-      stderr: error.message
-    }));
-  });
-}
-function createRunnerDepsFor(productDir, outStream = process.stdout) {
-  const runCommand = createCommandRunner(productDir, outStream);
-  return () => ({ runCommand });
-}
-function createRelatedDepsFor(productDir) {
-  const runCommand = createRelatedCommandRunner(productDir);
-  return () => ({ runCommand, readFile: (path4) => readFile12(join28(productDir, path4), "utf8") });
-}
-function artifactFileName(index, suffix) {
-  return `${index.toString(ARTIFACT_INDEX_RADIX).padStart(ARTIFACT_INDEX_WIDTH, "0")}-${suffix}`;
-}
-function createArtifactWriters(root, index, createArtifactWriteStream) {
-  const stdoutPath = join28(root, artifactFileName(index, STDOUT_FILE_SUFFIX));
-  const stderrPath = join28(root, artifactFileName(index, STDERR_FILE_SUFFIX));
-  const stdoutFile = createArtifactWriteStream(stdoutPath);
-  const stderrFile = createArtifactWriteStream(stderrPath);
-  return {
-    stdoutPath,
-    stderrPath,
-    stdoutFile,
-    stderrFile,
-    completion: Promise.all([finished(stdoutFile), finished(stderrFile)])
-  };
-}
-async function finishArtifactWriters(writers) {
-  writers.stdoutFile.end();
-  writers.stderrFile.end();
-  await writers.completion;
-  return {
-    stdoutPath: writers.stdoutPath,
-    stderrPath: writers.stderrPath
-  };
-}
-function runCapturedCommand(request) {
-  return new Promise((resolveResult) => {
-    let settled = false;
-    const resolveOnce = (result) => {
-      if (settled) return;
-      settled = true;
-      resolveResult(result);
-    };
-    const child = spawnManagedSubprocess(request.processRunner, request.command, request.args, {
-      cwd: request.productDir,
-      env: request.inheritedEnv
-    });
-    child.stdout?.pipe(request.writers.stdoutFile);
-    child.stderr?.pipe(request.writers.stderrFile);
-    const resolveWithExitCode = (exitCode) => {
-      finishArtifactWriters(request.writers).then((output) => resolveOnce({ exitCode, output })).catch(() => resolveOnce({ exitCode: PROCESS_FAILURE_EXIT_CODE }));
-    };
-    request.writers.completion.catch(() => {
-      child.kill();
-      resolveOnce({ exitCode: PROCESS_FAILURE_EXIT_CODE });
-    });
-    child.on("close", (code) => resolveWithExitCode(code ?? PROCESS_FAILURE_EXIT_CODE));
-    child.on("error", () => resolveWithExitCode(PROCESS_FAILURE_EXIT_CODE));
-  });
-}
-function createAgentOutputCommandRunner(productDir, options = {}) {
-  let artifactRoot;
-  const processRunner = options.processRunner ?? lifecycleProcessRunner;
-  const inheritedEnv = options.env ?? process.env;
-  const createArtifactWriteStream = options.createArtifactWriteStream ?? ((path4) => createWriteStream(path4, { flags: ARTIFACT_FILE_FLAGS }));
-  let nextArtifactIndex = 0;
-  return async (command, args = EMPTY_RUNNER_ARGS) => {
-    nextArtifactIndex += 1;
-    artifactRoot ??= mkdtemp3(join28(options.tmpDir ?? tmpdir3(), AGENT_ARTIFACT_DIR_PREFIX));
-    const root = await artifactRoot;
-    return runCapturedCommand({
-      productDir,
-      command,
-      args,
-      processRunner,
-      inheritedEnv,
-      writers: createArtifactWriters(root, nextArtifactIndex, createArtifactWriteStream)
-    });
-  };
-}
-function createAgentRunnerDepsFor(productDir, options = {}) {
-  const runCommand = createAgentOutputCommandRunner(productDir, options);
-  return () => ({ runCommand });
-}
-
 // src/interfaces/cli/spec.ts
 var SPEC_DOMAIN_CLI = {
   COMMAND: "spec",
   STATUS_COMMAND: "status",
   NEXT_COMMAND: "next",
   CONTEXT_COMMAND: "context",
+  RETIRED_APPLY_COMMAND: "apply",
   JSON_OPTION: "--json",
   CONTENT_OPTION: "--content",
   FORMAT_OPTION_FLAG: "--format",
@@ -17826,8 +17701,7 @@ function registerSpecCommands(specCmd, invocation) {
         update: true,
         resolveOutcomeFor: (productDir2) => createNodeOutcomeResolver({
           productDir: productDir2,
-          registry: testingRegistry,
-          runnerDepsFor: createRunnerDepsFor(productDir2, process.stderr)
+          registry: testingRegistry
         })
       }) : await statusCommand({ cwd: productDir(), format: format2, onWarning });
       writeOutput3(invocation.io, output);
@@ -17951,68 +17825,197 @@ function formatAgentTestOutput(run) {
   return `${lines.join(NEWLINE2)}${NEWLINE2}`;
 }
 
-// src/interfaces/cli/test.ts
-var TESTING_CLI = {
-  commandName: "test",
-  description: "Run spec-tree tests across product languages",
-  agentOption: "--agent",
-  agentDescription: "Capture raw runner output and print a compact agent summary",
-  recursiveShortFlag: "-r",
-  recursiveLongFlag: "--recursive",
-  recursiveDescription: "Extend a node-path operand to its descendant nodes' tests",
-  changedLongFlag: "--changed",
-  changedDescription: "Run only tests affected by changes against the selected base",
-  stagedLongFlag: "--staged",
-  stagedDescription: "With --changed, diff the staged snapshot instead of the worktree",
-  baseLongFlag: "--base",
-  baseOperand: "<ref>",
-  baseDescription: "Base ref for --changed; defaults to origin of the default branch",
-  targetsArgument: "[targets...]",
-  targetsDescription: "Node paths or test-file paths to run; omit to run the full discovered suite",
-  passingSubcommand: "passing",
-  passingDescription: "Run only the tests within the configured passing scope"
-};
-var UNMATCHED_TEST_FILES_WARNING = "Skipped test files with no registered runner";
-var GATED_TEST_RUNNERS_WARNING = "Skipped test files because their registered runner was gated out";
-var UNRESOLVED_TARGETS_WARNING = "No tests matched these operands";
-var UNRESOLVED_CHANGED_SOURCE_WARNING = "No related-test capability resolved these changed source files";
-var TESTING_PRODUCT_DIR_WARNING = {
-  NOT_GIT_REPOSITORY: `Warning: Not in a git repository. Reading ${SPEC_TREE_CONFIG.ROOT_DIRECTORY} tests relative to the current working directory.`
-};
-async function resolveTestProductDir(cwd, writeWarning) {
-  const { productDir, isGitRepo } = await detectWorktreeProductRoot(cwd);
-  writeWarning(isGitRepo ? void 0 : TESTING_PRODUCT_DIR_WARNING.NOT_GIT_REPOSITORY);
-  return productDir;
+// src/interfaces/cli/test-runner-deps.ts
+import { createWriteStream } from "fs";
+import { mkdtemp as mkdtemp3, readFile as readFile12 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join28 } from "path";
+import { finished } from "stream/promises";
+var PROCESS_FAILURE_EXIT_CODE = 1;
+var AGENT_ARTIFACT_DIR_PREFIX = "spx-test-agent-";
+var STDOUT_FILE_SUFFIX = "stdout.log";
+var STDERR_FILE_SUFFIX = "stderr.log";
+var ARTIFACT_INDEX_WIDTH = 3;
+var ARTIFACT_INDEX_RADIX = 10;
+var ARTIFACT_FILE_FLAGS = "wx";
+var EMPTY_RUNNER_ARGS = [];
+function createCommandRunner(productDir, outStream, errStream, processRunner) {
+  return (command, args) => new Promise((resolveResult) => {
+    const child = spawnManagedSubprocess(processRunner, command, args, {
+      cwd: productDir
+    });
+    child.stdout?.pipe(outStream);
+    child.stderr?.pipe(errStream);
+    child.on("close", (code) => resolveResult({ exitCode: code ?? PROCESS_FAILURE_EXIT_CODE }));
+    child.on("error", () => resolveResult({ exitCode: PROCESS_FAILURE_EXIT_CODE }));
+  });
 }
-async function runTestsThroughCommand(productDir, passing, io, targets, changed) {
-  try {
-    return await runTestsCommand(
-      { productDir, passing, targets, changed },
-      {
-        registry: testingRegistry,
-        runnerDepsFor: createRunnerDepsFor(productDir),
-        relatedDepsFor: createRelatedDepsFor(productDir)
-      }
-    );
-  } catch (error) {
-    io.writeStderr(`${error instanceof Error ? error.message : String(error)}
-`);
-    io.exit(PROCESS_FAILURE_EXIT_CODE);
-  }
+function createRelatedCommandRunner(productDir, processRunner) {
+  return (command, args) => new Promise((resolveResult) => {
+    const stdout = [];
+    const stderr = [];
+    const child = spawnManagedSubprocess(processRunner, command, args, {
+      cwd: productDir
+    });
+    child.stdout?.on("data", (chunk) => stdout.push(String(chunk)));
+    child.stderr?.on("data", (chunk) => stderr.push(String(chunk)));
+    child.on("close", (code) => resolveResult({
+      exitCode: code ?? PROCESS_FAILURE_EXIT_CODE,
+      stdout: stdout.join(""),
+      stderr: stderr.join("")
+    }));
+    child.on("error", (error) => resolveResult({
+      exitCode: PROCESS_FAILURE_EXIT_CODE,
+      stdout: stdout.join(""),
+      stderr: error.message
+    }));
+  });
 }
-async function runAgentTestsThroughCommand(productDir, passing, io, targets, changed) {
-  try {
-    return await runTestsCommand(
-      { productDir, passing, targets, changed },
-      {
-        registry: testingRegistry,
-        runnerDepsFor: createAgentRunnerDepsFor(productDir),
-        relatedDepsFor: createRelatedDepsFor(productDir)
-      }
-    );
-  } catch (error) {
-    io.writeStderr(`${error instanceof Error ? error.message : String(error)}
-`);
+function createRunnerDepsFor(productDir, outStream = process.stdout, processRunner = lifecycleProcessRunner, errStream = process.stderr) {
+  const runCommand = createCommandRunner(productDir, outStream, errStream, processRunner);
+  return () => ({ runCommand });
+}
+function createRelatedDepsFor(productDir, processRunner = lifecycleProcessRunner) {
+  const runCommand = createRelatedCommandRunner(productDir, processRunner);
+  return () => ({ runCommand, readFile: (path4) => readFile12(join28(productDir, path4), "utf8") });
+}
+function artifactFileName(index, suffix) {
+  return `${index.toString(ARTIFACT_INDEX_RADIX).padStart(ARTIFACT_INDEX_WIDTH, "0")}-${suffix}`;
+}
+function createArtifactWriters(root, index, createArtifactWriteStream) {
+  const stdoutPath = join28(root, artifactFileName(index, STDOUT_FILE_SUFFIX));
+  const stderrPath = join28(root, artifactFileName(index, STDERR_FILE_SUFFIX));
+  const stdoutFile = createArtifactWriteStream(stdoutPath);
+  const stderrFile = createArtifactWriteStream(stderrPath);
+  return {
+    stdoutPath,
+    stderrPath,
+    stdoutFile,
+    stderrFile,
+    completion: Promise.all([finished(stdoutFile), finished(stderrFile)])
+  };
+}
+async function finishArtifactWriters(writers) {
+  writers.stdoutFile.end();
+  writers.stderrFile.end();
+  await writers.completion;
+  return {
+    stdoutPath: writers.stdoutPath,
+    stderrPath: writers.stderrPath
+  };
+}
+function runCapturedCommand(request) {
+  return new Promise((resolveResult) => {
+    let settled = false;
+    const resolveOnce = (result) => {
+      if (settled) return;
+      settled = true;
+      resolveResult(result);
+    };
+    const child = spawnManagedSubprocess(request.processRunner, request.command, request.args, {
+      cwd: request.productDir,
+      env: request.inheritedEnv
+    });
+    child.stdout?.pipe(request.writers.stdoutFile);
+    child.stderr?.pipe(request.writers.stderrFile);
+    const resolveWithExitCode = (exitCode) => {
+      finishArtifactWriters(request.writers).then((output) => resolveOnce({ exitCode, output })).catch(() => resolveOnce({ exitCode: PROCESS_FAILURE_EXIT_CODE }));
+    };
+    request.writers.completion.catch(() => {
+      child.kill();
+      resolveOnce({ exitCode: PROCESS_FAILURE_EXIT_CODE });
+    });
+    child.on("close", (code) => resolveWithExitCode(code ?? PROCESS_FAILURE_EXIT_CODE));
+    child.on("error", () => resolveWithExitCode(PROCESS_FAILURE_EXIT_CODE));
+  });
+}
+function createAgentOutputCommandRunner(productDir, options = {}) {
+  let artifactRoot;
+  const processRunner = options.processRunner ?? lifecycleProcessRunner;
+  const inheritedEnv = options.env ?? process.env;
+  const createArtifactWriteStream = options.createArtifactWriteStream ?? ((path4) => createWriteStream(path4, { flags: ARTIFACT_FILE_FLAGS }));
+  let nextArtifactIndex = 0;
+  return async (command, args = EMPTY_RUNNER_ARGS) => {
+    nextArtifactIndex += 1;
+    artifactRoot ??= mkdtemp3(join28(options.tmpDir ?? tmpdir3(), AGENT_ARTIFACT_DIR_PREFIX));
+    const root = await artifactRoot;
+    return runCapturedCommand({
+      productDir,
+      command,
+      args,
+      processRunner,
+      inheritedEnv,
+      writers: createArtifactWriters(root, nextArtifactIndex, createArtifactWriteStream)
+    });
+  };
+}
+function createAgentRunnerDepsFor(productDir, options = {}) {
+  const runCommand = createAgentOutputCommandRunner(productDir, options);
+  return () => ({ runCommand });
+}
+
+// src/interfaces/cli/test.ts
+var TESTING_CLI = {
+  commandName: "test",
+  description: "Run spec-tree tests across product languages",
+  agentOption: "--agent",
+  agentDescription: "Capture raw runner output and print a compact agent summary",
+  recursiveShortFlag: "-r",
+  recursiveLongFlag: "--recursive",
+  recursiveDescription: "Extend a node-path operand to its descendant nodes' tests",
+  changedLongFlag: "--changed",
+  changedDescription: "Run only tests affected by changes against the selected base",
+  stagedLongFlag: "--staged",
+  stagedDescription: "With --changed, diff the staged snapshot instead of the worktree",
+  baseLongFlag: "--base",
+  baseOperand: "<ref>",
+  baseDescription: "Base ref for --changed; defaults to origin of the default branch",
+  targetsArgument: "[targets...]",
+  targetsDescription: "Node paths or test-file paths to run; omit to run the full discovered suite",
+  passingSubcommand: "passing",
+  passingDescription: "Run only the tests within the configured passing scope"
+};
+var UNMATCHED_TEST_FILES_WARNING = "Skipped test files with no registered runner";
+var GATED_TEST_RUNNERS_WARNING = "Skipped test files because their registered runner was gated out";
+var UNRESOLVED_TARGETS_WARNING = "No tests matched these operands";
+var UNRESOLVED_CHANGED_SOURCE_WARNING = "No related-test capability resolved these changed source files";
+var TESTING_PRODUCT_DIR_WARNING = {
+  NOT_GIT_REPOSITORY: `Warning: Not in a git repository. Reading ${SPEC_TREE_CONFIG.ROOT_DIRECTORY} tests relative to the current working directory.`
+};
+async function resolveTestProductDir(cwd, writeWarning) {
+  const { productDir, isGitRepo } = await detectWorktreeProductRoot(cwd);
+  writeWarning(isGitRepo ? void 0 : TESTING_PRODUCT_DIR_WARNING.NOT_GIT_REPOSITORY);
+  return productDir;
+}
+async function runTestsThroughCommand(productDir, passing, io, targets, changed) {
+  try {
+    return await runTestsCommand(
+      { productDir, passing, targets, changed },
+      {
+        registry: testingRegistry,
+        runnerDepsFor: createRunnerDepsFor(productDir),
+        relatedDepsFor: createRelatedDepsFor(productDir)
+      }
+    );
+  } catch (error) {
+    io.writeStderr(`${error instanceof Error ? error.message : String(error)}
+`);
+    io.exit(PROCESS_FAILURE_EXIT_CODE);
+  }
+}
+async function runAgentTestsThroughCommand(productDir, passing, io, targets, changed) {
+  try {
+    return await runTestsCommand(
+      { productDir, passing, targets, changed },
+      {
+        registry: testingRegistry,
+        runnerDepsFor: createAgentRunnerDepsFor(productDir),
+        relatedDepsFor: createRelatedDepsFor(productDir)
+      }
+    );
+  } catch (error) {
+    io.writeStderr(`${error instanceof Error ? error.message : String(error)}
+`);
     io.exit(PROCESS_FAILURE_EXIT_CODE);
   }
 }
@@ -18138,6 +18141,12 @@ var testingDomain = createTestingDomain();
 import { existsSync as existsSync9, realpathSync } from "fs";
 import { relative as relative11, resolve as resolve16 } from "path";
 
+// src/validation/languages/types.ts
+var VALIDATION_STAGE_PARTICIPATION = {
+  RUN: "run",
+  SKIP: "skip"
+};
+
 // src/commands/validation/formatting.ts
 import { existsSync, statSync } from "fs";
 import { isAbsolute as isAbsolute6, join as join29, relative as relative6 } from "path";
@@ -18153,8 +18162,8 @@ function unique(values) {
 function nonEmpty(values) {
   return values?.filter((value) => value.length > 0) ?? [];
 }
-function toProjectRelativeValidationPath(projectRoot, path4) {
-  return isAbsolute5(path4) ? relative5(projectRoot, path4) : path4;
+function toProductRelativeValidationPath(productDir, path4) {
+  return isAbsolute5(path4) ? relative5(productDir, path4) : path4;
 }
 function intersectIncludes(baseInclude, toolInclude) {
   const base = nonEmpty(baseInclude);
@@ -18259,6 +18268,9 @@ function applyValidationPathFilterToScope(scopeConfig, filter) {
   };
 }
 
+// src/validation/steps/formatting.ts
+import { createRequire } from "module";
+
 // src/validation/steps/subprocess-output.ts
 var VALIDATION_SUBPROCESS_EVENTS = {
   CLOSE: "close",
@@ -18270,6 +18282,13 @@ var defaultValidationSubprocessOutputStreams = {
   stdout: process.stdout,
   stderr: process.stderr
 };
+var discardValidationSubprocessOutputStream = {
+  write: () => true
+};
+var discardValidationSubprocessOutputStreams = {
+  stdout: discardValidationSubprocessOutputStream,
+  stderr: discardValidationSubprocessOutputStream
+};
 function forwardValidationSubprocessOutput(child, streams = defaultValidationSubprocessOutputStreams) {
   child.stdout?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, (chunk) => {
     forwardChunkWithBackpressure(child.stdout, streams.stdout, chunk);
@@ -18290,7 +18309,12 @@ function forwardChunkWithBackpressure(source, stream, chunk) {
 }
 
 // src/validation/steps/formatting.ts
-var DPRINT_COMMAND = "dprint";
+var DPRINT_EXECUTABLE_SPECIFIER = "dprint/bin.cjs";
+var cachedDprintCommand;
+function resolveDprintCommand() {
+  cachedDprintCommand ??= createRequire(import.meta.url).resolve(DPRINT_EXECUTABLE_SPECIFIER);
+  return cachedDprintCommand;
+}
 var DPRINT_CHECK_SUBCOMMAND = "check";
 var DPRINT_EXCLUDES_OPTION = "--excludes";
 var DPRINT_OPTIONS_TERMINATOR = "--";
@@ -18306,16 +18330,17 @@ function buildDprintCheckArgs(options) {
     ...files
   ];
 }
-async function validateFormatting(context, runner = defaultFormattingProcessRunner) {
+async function validateFormatting(context, runner = defaultFormattingProcessRunner, outputStreams) {
   const args = buildDprintCheckArgs({ files: context.files, excludes: context.excludes });
   return new Promise((resolve17) => {
-    const child = spawnManagedSubprocess(runner, DPRINT_COMMAND, args, { cwd: context.projectRoot });
+    const child = spawnManagedSubprocess(runner, resolveDprintCommand(), args, { cwd: context.productDir });
     const chunks = [];
     const capture = (chunk) => {
       chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString());
     };
     child.stdout?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
     child.stderr?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
+    forwardValidationSubprocessOutput(child, outputStreams);
     child.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
       resolve17({ success: code === 0, output: chunks.join("") });
     });
@@ -18337,59 +18362,140 @@ var VALIDATION_STAGE_DISPLAY_NAMES = {
 };
 var VALIDATION_SKIP_LABELS = {
   VERB: "Skipping",
-  CIRCULAR_REASON: "skip-circular",
-  LITERAL_REASON: "skip-literal",
   DISABLED_BY_PREFIX: "disabled by",
-  TYPESCRIPT_ABSENT_REASON: "TypeScript not detected in project",
+  TYPESCRIPT_ABSENT_REASON: "TypeScript not detected in product",
   VALIDATION_PATHS_NO_TARGETS_REASON: "validation paths matched no files",
+  EXPLICIT_PATHS_NO_TARGETS_REASON: "explicit paths matched no files in tool scope",
   MARKDOWN_NO_SCOPE_REASON: "no markdown files in explicit path scope",
   MARKDOWN_NO_DEFAULT_DIRECTORIES_REASON: "no spx/ or docs/ directories found"
 };
+var VALIDATION_STREAMED_STAGE_RESULT = "output streamed";
+var VALIDATION_PROBLEM_TERMS = {
+  SINGULAR: "problem",
+  PLURAL: "problems"
+};
+function formatValidationNoProblemsMessage(stageName) {
+  return `${stageName}: \u2713 No ${VALIDATION_PROBLEM_TERMS.PLURAL}`;
+}
+function formatValidationProblemsFoundMessage(stageName, options = {}) {
+  const countPrefix = options.count === void 0 ? "" : `${options.count} `;
+  const term = options.count === 1 ? VALIDATION_PROBLEM_TERMS.SINGULAR : VALIDATION_PROBLEM_TERMS.PLURAL;
+  const detailSuffix = options.detail === void 0 ? "" : ` (${options.detail})`;
+  return `${stageName}: ${countPrefix}${term} found${detailSuffix}`;
+}
+function formatValidationConfigProblemMessage(stageName, detail) {
+  return formatValidationProblemsFoundMessage(stageName, { count: 1, detail });
+}
+var VALIDATION_STAGE_PROBLEM_MESSAGES = {
+  [VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR]: {
+    clear: formatValidationNoProblemsMessage(VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR),
+    attention: formatValidationProblemsFoundMessage(VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR, {
+      detail: "circular dependencies"
+    })
+  },
+  [VALIDATION_STAGE_DISPLAY_NAMES.KNIP]: {
+    clear: formatValidationNoProblemsMessage(VALIDATION_STAGE_DISPLAY_NAMES.KNIP),
+    attention: formatValidationProblemsFoundMessage(VALIDATION_STAGE_DISPLAY_NAMES.KNIP, {
+      detail: "unused code"
+    })
+  },
+  [VALIDATION_STAGE_DISPLAY_NAMES.ESLINT]: {
+    clear: formatValidationNoProblemsMessage(VALIDATION_STAGE_DISPLAY_NAMES.ESLINT),
+    attention: formatValidationProblemsFoundMessage(VALIDATION_STAGE_DISPLAY_NAMES.ESLINT)
+  },
+  [VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT]: {
+    clear: formatValidationNoProblemsMessage(VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT),
+    attention: formatValidationProblemsFoundMessage(VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT)
+  },
+  [VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN]: {
+    clear: formatValidationNoProblemsMessage(VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN),
+    attention: formatValidationProblemsFoundMessage(VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN)
+  },
+  [VALIDATION_STAGE_DISPLAY_NAMES.LITERAL]: {
+    clear: formatValidationNoProblemsMessage(VALIDATION_STAGE_DISPLAY_NAMES.LITERAL),
+    attention: formatValidationProblemsFoundMessage(VALIDATION_STAGE_DISPLAY_NAMES.LITERAL)
+  },
+  [VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING]: {
+    clear: formatValidationNoProblemsMessage(VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING),
+    attention: formatValidationProblemsFoundMessage(VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING, {
+      detail: "unformatted files"
+    })
+  }
+};
 var VALIDATION_COMMAND_OUTPUT = {
-  CIRCULAR_FOUND: `${VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR}: circular dependencies found`,
-  CIRCULAR_NONE_FOUND: `${VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR}: \u2713 No circular dependencies found`,
-  KNIP_CONFIG_ERROR: `${VALIDATION_STAGE_DISPLAY_NAMES.KNIP}: \u2717 config error`,
+  CIRCULAR_FOUND: VALIDATION_STAGE_PROBLEM_MESSAGES[VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR].attention,
+  CIRCULAR_NONE_FOUND: VALIDATION_STAGE_PROBLEM_MESSAGES[VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR].clear,
+  KNIP_CONFIG_ERROR: formatValidationConfigProblemMessage(
+    VALIDATION_STAGE_DISPLAY_NAMES.KNIP,
+    "configuration error"
+  ),
   KNIP_DISABLED: `${VALIDATION_STAGE_DISPLAY_NAMES.KNIP}: skipped (${VALIDATION_SKIP_LABELS.DISABLED_BY_PREFIX} validation.knip.enabled)`,
-  KNIP_SUCCESS: `${VALIDATION_STAGE_DISPLAY_NAMES.KNIP}: \u2713 No unused code found`,
-  KNIP_FAILURE: "Unused code found",
-  ESLINT_SUCCESS: `${VALIDATION_STAGE_DISPLAY_NAMES.ESLINT}: \u2713 No errors found`,
-  ESLINT_FAILURE: `${VALIDATION_STAGE_DISPLAY_NAMES.ESLINT} validation failed`,
-  ESLINT_MISSING_CONFIG: "ESLint config not found: project has tsconfig.json but no eslint.config.{ts,js,mjs,cjs}",
-  TYPESCRIPT_SUCCESS: `${VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT}: \u2713 No type errors`,
-  TYPESCRIPT_FAILURE: `${VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT} validation failed`,
-  MARKDOWN_NO_ISSUES: `${VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN}: No issues found`,
-  MARKDOWN_ERROR_SUMMARY_SUFFIX: "error(s) found",
-  FORMATTING_NO_ISSUES: `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: \u2713 No formatting issues found`,
-  FORMATTING_FAILURE_SUMMARY: `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: unformatted files found`
-};
-var CIRCULAR_SKIP_OUTPUT = `${VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR}: skipped (--${VALIDATION_SKIP_LABELS.CIRCULAR_REASON})`;
-var CIRCULAR_SKIP_JSON_OUTPUT = JSON.stringify({
-  skipped: true,
-  reason: VALIDATION_SKIP_LABELS.CIRCULAR_REASON
-});
-var LITERAL_SKIP_OUTPUT = `${VALIDATION_STAGE_DISPLAY_NAMES.LITERAL}: skipped (--${VALIDATION_SKIP_LABELS.LITERAL_REASON})`;
-var LITERAL_SKIP_JSON_OUTPUT = JSON.stringify({
-  skipped: true,
-  reason: VALIDATION_SKIP_LABELS.LITERAL_REASON
-});
+  KNIP_SUCCESS: VALIDATION_STAGE_PROBLEM_MESSAGES[VALIDATION_STAGE_DISPLAY_NAMES.KNIP].clear,
+  KNIP_FAILURE: VALIDATION_STAGE_PROBLEM_MESSAGES[VALIDATION_STAGE_DISPLAY_NAMES.KNIP].attention,
+  ESLINT_SUCCESS: VALIDATION_STAGE_PROBLEM_MESSAGES[VALIDATION_STAGE_DISPLAY_NAMES.ESLINT].clear,
+  ESLINT_FAILURE: VALIDATION_STAGE_PROBLEM_MESSAGES[VALIDATION_STAGE_DISPLAY_NAMES.ESLINT].attention,
+  ESLINT_MISSING_CONFIG: formatValidationConfigProblemMessage(
+    VALIDATION_STAGE_DISPLAY_NAMES.ESLINT,
+    "configuration missing: product has tsconfig.json but no eslint.config.{ts,js,mjs,cjs}"
+  ),
+  TYPESCRIPT_SUCCESS: VALIDATION_STAGE_PROBLEM_MESSAGES[VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT].clear,
+  TYPESCRIPT_FAILURE: VALIDATION_STAGE_PROBLEM_MESSAGES[VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT].attention,
+  MARKDOWN_NO_ISSUES: VALIDATION_STAGE_PROBLEM_MESSAGES[VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN].clear,
+  FORMATTING_NO_ISSUES: VALIDATION_STAGE_PROBLEM_MESSAGES[VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING].clear,
+  FORMATTING_FAILURE_SUMMARY: VALIDATION_STAGE_PROBLEM_MESSAGES[VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING].attention
+};
+function formatValidationStageSkipOutput(stageName, reason) {
+  return `${stageName}: skipped (${reason})`;
+}
+function formatValidationStageSkipJsonOutput(reason, durationMs) {
+  return JSON.stringify({ skipped: true, reason, durationMs });
+}
 function formatTypeScriptAbsentSkipMessage(stageName) {
   return `\u23ED ${VALIDATION_SKIP_LABELS.VERB} ${stageName} (${VALIDATION_SKIP_LABELS.TYPESCRIPT_ABSENT_REASON})`;
 }
 function formatValidationPathsNoTargetsSkipMessage(stageName) {
   return `\u23ED ${VALIDATION_SKIP_LABELS.VERB} ${stageName} (${VALIDATION_SKIP_LABELS.VALIDATION_PATHS_NO_TARGETS_REASON})`;
 }
+function formatExplicitPathsNoTargetsSkipMessage(stageName) {
+  return `\u23ED ${VALIDATION_SKIP_LABELS.VERB} ${stageName} (${VALIDATION_SKIP_LABELS.EXPLICIT_PATHS_NO_TARGETS_REASON})`;
+}
+function formatValidationScopeNoTargetsSkipMessage(stageName, metadata) {
+  if (metadata.explicitPathNoMatches) {
+    return formatExplicitPathsNoTargetsSkipMessage(stageName);
+  }
+  if (metadata.filteredByValidationPathNoMatches) {
+    return formatValidationPathsNoTargetsSkipMessage(stageName);
+  }
+  return void 0;
+}
+
+// src/commands/validation/types.ts
+var VALIDATION_OUTPUT_TARGET = {
+  STDOUT: "stdout",
+  STDERR: "stderr"
+};
+var VALIDATION_STREAMED_TERMINAL_OUTPUT = "";
+function streamedValidationTerminalOutput(subprocessOutput, json, streamedPipelineOutput) {
+  return json !== true && streamedPipelineOutput === true && subprocessOutput !== void 0 && subprocessOutput.length > 0 ? VALIDATION_STREAMED_TERMINAL_OUTPUT : void 0;
+}
 
 // src/commands/validation/formatting.ts
+var defaultFormattingCommandDependencies = {
+  validateFormatting
+};
 var FORMATTING_COMMAND_OUTPUT = {
   NO_ISSUES: VALIDATION_COMMAND_OUTPUT.FORMATTING_NO_ISSUES,
   FAILURE_SUMMARY: VALIDATION_COMMAND_OUTPUT.FORMATTING_FAILURE_SUMMARY,
   EMPTY_SCOPE_REASON: "no files in scope",
   NO_CONFIG_SKIP_REASON: `no ${DPRINT_CONFIG_FILENAME} at product root`
 };
-var FORMATTING_CONFIG_ERROR_MESSAGE = `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: \u2717 config error`;
+var FORMATTING_CONFIG_ERROR_MESSAGE = formatValidationConfigProblemMessage(
+  VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING,
+  "configuration error"
+);
 var DPRINT_RECURSIVE_DIRECTORY_GLOB_SUFFIX = "/**/*";
-async function formattingCommand(options) {
-  const { cwd, files, quiet } = options;
+async function formattingCommand(options, dependencies = defaultFormattingCommandDependencies) {
+  const { cwd, files, json, outputStreams, quiet, streamedPipelineOutput } = options;
   const startTime = Date.now();
   const loaded = await resolveConfig(cwd, [validationConfigDescriptor]);
   if (!loaded.ok) {
@@ -18409,32 +18515,52 @@ async function formattingCommand(options) {
     VALIDATION_PATH_TOOL_SUBSECTIONS.FORMATTING
   );
   const hasExplicitScope = files !== void 0 && files.length > 0;
-  const scopedFiles = hasExplicitScope ? files.flatMap(
-    (filePath) => formattingPathOperandsForValidationPathFilter(
-      cwd,
-      isAbsolute6(filePath) ? relative6(cwd, filePath) : filePath,
-      pathFilter
-    )
-  ) : void 0;
-  const scopedExcludes = hasExplicitScope && files.some(
-    (filePath) => isFormattingFileOperand(cwd, isAbsolute6(filePath) ? relative6(cwd, filePath) : filePath)
-  ) ? [] : validationPathFilterExcludes(pathFilter);
-  if (hasExplicitScope && (scopedFiles === void 0 || scopedFiles.length === 0)) {
+  const contexts = formattingValidationContexts(cwd, files, pathFilter);
+  const scopedFiles = contexts.flatMap((context) => context.files ?? []);
+  if (hasExplicitScope && scopedFiles.length === 0 || contexts.length === 0) {
     const output2 = quiet ? "" : `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: skipped (${FORMATTING_COMMAND_OUTPUT.EMPTY_SCOPE_REASON})`;
     return { exitCode: 0, output: output2, durationMs: Date.now() - startTime };
   }
-  const result = await validateFormatting({
-    projectRoot: cwd,
-    files: scopedFiles,
-    excludes: scopedExcludes
-  });
+  const results = [];
+  const subprocessOutputStreams = outputStreams ?? discardValidationSubprocessOutputStreams;
+  for (const context of contexts) {
+    results.push(await dependencies.validateFormatting(context, void 0, subprocessOutputStreams));
+  }
   const durationMs = Date.now() - startTime;
-  if (result.success) {
+  if (results.every((result) => result.success)) {
     return { exitCode: 0, output: quiet ? "" : FORMATTING_COMMAND_OUTPUT.NO_ISSUES, durationMs };
   }
-  const detail = result.error ?? result.output;
+  const detail = results.filter((result) => !result.success).flatMap((result) => [result.output, result.error]).filter((output2) => output2 !== void 0).filter((output2) => output2.length > 0).join("\n");
   const output = [FORMATTING_COMMAND_OUTPUT.FAILURE_SUMMARY, detail].filter((line) => line.length > 0).join("\n");
-  return { exitCode: 1, output, durationMs };
+  const terminalOutput = formattingTerminalOutput(results, outputStreams, json, streamedPipelineOutput);
+  return { exitCode: 1, output, terminalOutput, durationMs };
+}
+function formattingValidationContexts(productDir, files, pathFilter) {
+  if (files === void 0 || files.length === 0) {
+    if (validationPathFilterHasNoMatchingIncludes(pathFilter)) return [];
+    const automaticFiles = pathFilter.include?.map((path4) => normalizeFormattingPathOperand(productDir, path4));
+    return [{
+      productDir,
+      files: automaticFiles !== void 0 && automaticFiles.length > 0 ? automaticFiles : void 0,
+      excludes: validationPathFilterExcludes(pathFilter)
+    }];
+  }
+  const relativeFiles = files.map((filePath) => isAbsolute6(filePath) ? relative6(productDir, filePath) : filePath);
+  return [{
+    productDir,
+    files: relativeFiles.map((filePath) => normalizeFormattingPathOperand(productDir, filePath)),
+    excludes: []
+  }];
+}
+function formattingTerminalOutput(results, outputStreams, json, streamedPipelineOutput) {
+  if (json === true || outputStreams === void 0) {
+    return void 0;
+  }
+  const errors = results.flatMap((result) => result.error === void 0 ? [] : [result.error]);
+  if (errors.length > 0) {
+    return [FORMATTING_COMMAND_OUTPUT.FAILURE_SUMMARY, ...errors].join("\n");
+  }
+  return streamedPipelineOutput === true ? VALIDATION_STREAMED_TERMINAL_OUTPUT : FORMATTING_COMMAND_OUTPUT.FAILURE_SUMMARY;
 }
 function normalizeFormattingPathOperand(productDir, relativePath) {
   if (isFormattingFileOperand(productDir, relativePath)) {
@@ -18450,22 +18576,35 @@ function isFormattingFileOperand(productDir, relativePath) {
   const absolutePath = join29(productDir, relativePath);
   return !existsSync(absolutePath) || !statSync(absolutePath).isDirectory();
 }
-function formattingPathOperandsForValidationPathFilter(productDir, relativePath, pathFilter) {
-  if (isFormattingFileOperand(productDir, relativePath)) {
-    return [relativePath];
-  }
-  return validationPathFilterIntersections(relativePath, pathFilter).map((path4) => normalizeFormattingPathOperand(productDir, path4));
-}
 
 // src/validation/languages/formatting.ts
 var FORMATTING_LANGUAGE_NAME = "formatting";
+var SKIP_FORMATTING_REASON = "skip-formatting";
+var FORMATTING_VALIDATION_STAGE_PARTICIPATION = {
+  [VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING]: {
+    default: VALIDATION_STAGE_PARTICIPATION.RUN,
+    skipReason: SKIP_FORMATTING_REASON,
+    override: {
+      flag: "--skip-formatting",
+      description: "Skip formatting validation for this validation all run"
+    }
+  }
+};
 var formattingValidationLanguage = {
   name: FORMATTING_LANGUAGE_NAME,
   stages: [
     {
       name: VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING,
       failsPipeline: true,
-      run: (context) => formattingCommand({ cwd: context.cwd, files: context.files, quiet: context.quiet })
+      participation: FORMATTING_VALIDATION_STAGE_PARTICIPATION[VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING],
+      run: (context) => formattingCommand({
+        cwd: context.cwd,
+        files: context.files,
+        quiet: context.quiet,
+        json: context.json,
+        streamedPipelineOutput: true,
+        outputStreams: context.outputStreams
+      })
     }
   ]
 };
@@ -18506,6 +18645,11 @@ var MARKDOWN_VALIDATION_TARGET_DIAGNOSTICS = {
 var defaultMarkdownValidationTargetDeps = {
   statSync: statSync2
 };
+var defaultMarkdownValidationDeps = {
+  runMarkdownlint: async (options) => {
+    await markdownlintMain(options);
+  }
+};
 function buildMarkdownlintConfig(directoryName) {
   const md024Disabled = MD024_DISABLED_DIRECTORIES.includes(
     directoryName
@@ -18517,8 +18661,8 @@ function buildMarkdownlintConfig(directoryName) {
     [MARKDOWN_CONFIG_CONTROL_KEYS.CUSTOM_RULES]: [relativeLinksRule]
   };
 }
-function getDefaultDirectories(projectRoot) {
-  return MARKDOWN_DEFAULT_DIRECTORY_NAMES.map((name) => join30(projectRoot, name)).filter((dir) => existsSync2(dir));
+function getDefaultDirectories(productDir) {
+  return MARKDOWN_DEFAULT_DIRECTORY_NAMES.map((name) => join30(productDir, name)).filter((dir) => existsSync2(dir));
 }
 function resolveMarkdownValidationTarget(path4, deps = defaultMarkdownValidationTargetDeps) {
   if (isExistingDirectory(path4, deps)) {
@@ -18534,10 +18678,10 @@ function resolveMarkdownValidationTarget(path4, deps = defaultMarkdownValidation
     }
   };
 }
-function getExcludeGlobsForTarget(target, projectRoot, entries) {
-  if (projectRoot === void 0 || entries.length === 0) return [];
+function getExcludeGlobsForTarget(target, productDir, entries) {
+  if (productDir === void 0 || entries.length === 0) return [];
   const directory = targetDirectory(target);
-  const specTreeRoot = join30(projectRoot, SPEC_TREE_CONFIG.ROOT_DIRECTORY);
+  const specTreeRoot = join30(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY);
   const targetPath = normalizePathPrefix(pathRelative(specTreeRoot, directory));
   return entries.flatMap((entry) => {
     const excludedPath = normalizePathPrefix(entry);
@@ -18615,24 +18759,24 @@ function isAsciiDigit(value) {
 function isAsciiWhitespace(value) {
   return value === " " || value === "	";
 }
-async function validateMarkdown(options) {
+async function validateMarkdown(options, deps = defaultMarkdownValidationDeps) {
   const {
     targets,
-    projectRoot,
+    productDir,
     applyNodeStatusExcludes = true,
     validationPathExcludes = []
   } = options;
   const errors = [];
-  const specTreeExcludeEntries = applyNodeStatusExcludes ? getExcludeEntries(projectRoot) : [];
+  const specTreeExcludeEntries = applyNodeStatusExcludes ? getExcludeEntries(productDir) : [];
   for (const target of targets) {
     const directory = targetDirectory(target);
-    const dirName = markdownlintConfigDirectoryName(directory, projectRoot);
+    const dirName = markdownlintConfigDirectoryName(directory, productDir);
     const config = buildMarkdownlintConfig(dirName);
     const excludeGlobs = [
-      ...getExcludeGlobsForTarget(target, projectRoot, specTreeExcludeEntries),
-      ...validationPathExcludeGlobsForTarget(target, projectRoot, validationPathExcludes)
+      ...getExcludeGlobsForTarget(target, productDir, specTreeExcludeEntries),
+      ...validationPathExcludeGlobsForTarget(target, productDir, validationPathExcludes)
     ];
-    const dirErrors = await validateTarget(target, config, projectRoot, excludeGlobs);
+    const dirErrors = await validateTarget(target, config, deps, productDir, excludeGlobs);
     errors.push(...dirErrors);
   }
   return {
@@ -18640,11 +18784,11 @@ async function validateMarkdown(options) {
     errors
   };
 }
-function getExcludeEntries(projectRoot) {
-  if (projectRoot === void 0) return [];
-  return createNodeStatusExcludeReader(projectRoot).entries();
+function getExcludeEntries(productDir) {
+  if (productDir === void 0) return [];
+  return createNodeStatusExcludeReader(productDir).entries();
 }
-async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
+async function validateTarget(target, config, deps, productDir, ignoreGlobs = []) {
   const errors = [];
   const directory = targetDirectory(target);
   const argv = target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE ? [basename7(target.path)] : [MARKDOWN_DIRECTORY_GLOB];
@@ -18652,14 +18796,14 @@ async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
   const optionsOverride = {
     config: {
       ...markdownlintConfig,
-      "relative-links": projectRoot ? { root_path: projectRoot } : true
+      "relative-links": productDir ? { root_path: productDir } : true
     },
     customRules,
     noProgress: true,
     noBanner: true,
     ...ignoreGlobs.length > 0 ? { ignores: ignoreGlobs } : {}
   };
-  await markdownlintMain({
+  await deps.runMarkdownlint({
     directory,
     argv,
     optionsOverride,
@@ -18681,10 +18825,10 @@ async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
 function targetDirectory(target) {
   return target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE ? dirname13(target.path) : target.path;
 }
-function validationPathExcludeGlobsForTarget(target, projectRoot, excludes) {
-  if (projectRoot === void 0 || excludes.length === 0 || target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE) return [];
+function validationPathExcludeGlobsForTarget(target, productDir, excludes) {
+  if (productDir === void 0 || excludes.length === 0 || target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE) return [];
   const directory = targetDirectory(target);
-  const targetPath = normalizePathPrefix(pathRelative(projectRoot, directory));
+  const targetPath = normalizePathPrefix(pathRelative(productDir, directory));
   return excludes.flatMap((exclude) => {
     const excludedPath = normalizePathPrefix(exclude);
     if (targetPath === excludedPath) {
@@ -18693,11 +18837,11 @@ function validationPathExcludeGlobsForTarget(target, projectRoot, excludes) {
     if (!pathContainsValidationPath(targetPath, excludedPath)) {
       return [];
     }
-    const relativeExclude = normalizePathPrefix(pathRelative(directory, join30(projectRoot, excludedPath)));
+    const relativeExclude = normalizePathPrefix(pathRelative(directory, join30(productDir, excludedPath)));
     if (relativeExclude.length === 0) {
       return [MARKDOWN_DIRECTORY_GLOB];
     }
-    const absoluteExclude = join30(projectRoot, excludedPath);
+    const absoluteExclude = join30(productDir, excludedPath);
     return [
       isExistingFile(absoluteExclude, defaultMarkdownValidationTargetDeps) ? relativeExclude : `${relativeExclude}/**`
     ];
@@ -18726,9 +18870,9 @@ function isExistingFile(path4, deps) {
     return false;
   }
 }
-function markdownlintConfigDirectoryName(directory, projectRoot) {
-  if (projectRoot !== void 0) {
-    const [rootSegment] = pathRelative(projectRoot, directory).split(/[\\/]/);
+function markdownlintConfigDirectoryName(directory, productDir) {
+  if (productDir !== void 0) {
+    const [rootSegment] = pathRelative(productDir, directory).split(/[\\/]/);
     if (MD024_DISABLED_DIRECTORIES.includes(rootSegment)) {
       return rootSegment;
     }
@@ -18738,11 +18882,14 @@ function markdownlintConfigDirectoryName(directory, projectRoot) {
 
 // src/commands/validation/markdown.ts
 var MARKDOWN_COMMAND_OUTPUT = {
-  ERROR_SUMMARY_SUFFIX: VALIDATION_COMMAND_OUTPUT.MARKDOWN_ERROR_SUMMARY_SUFFIX,
   NO_ISSUES: VALIDATION_COMMAND_OUTPUT.MARKDOWN_NO_ISSUES,
+  PROBLEM_TERM: VALIDATION_PROBLEM_TERMS.SINGULAR,
   SKIPPED_FILE_SCOPE_PREFIX: "Markdown skipped file scope"
 };
-var MARKDOWN_CONFIG_ERROR_MESSAGE = `${VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN}: \u2717 config error`;
+var MARKDOWN_CONFIG_ERROR_MESSAGE = formatValidationConfigProblemMessage(
+  VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN,
+  "configuration error"
+);
 async function markdownCommand(options) {
   const { cwd, files, quiet } = options;
   const startTime = Date.now();
@@ -18775,8 +18922,8 @@ async function markdownCommand(options) {
   }
   const result = await validateMarkdown({
     targets,
-    projectRoot: cwd,
-    validationPathExcludes: validationPathFilterExcludes(pathFilter)
+    productDir: cwd,
+    validationPathExcludes: targetResolutions === void 0 ? validationPathFilterExcludes(pathFilter) : []
   });
   const durationMs = Date.now() - startTime;
   return formatMarkdownResult(result, skippedOutput, quiet, durationMs);
@@ -18786,7 +18933,7 @@ function markdownValidationOperandPath(productDir, filePath) {
 }
 function defaultMarkdownTargets(productDir, pathFilter) {
   return getDefaultDirectories(productDir).flatMap(
-    (directory) => validationPathFilterIntersections(toProjectRelativeValidationPath(productDir, directory), pathFilter).map((intersection) => resolveMarkdownValidationTarget(join31(productDir, intersection)).target).filter((target) => target !== void 0)
+    (directory) => validationPathFilterIntersections(toProductRelativeValidationPath(productDir, directory), pathFilter).map((intersection) => resolveMarkdownValidationTarget(join31(productDir, intersection)).target).filter((target) => target !== void 0)
   );
 }
 function formatSkippedFileScope(target) {
@@ -18802,7 +18949,9 @@ function formatMarkdownResult(result, skippedOutput, quiet, durationMs) {
   );
   const output = [
     ...skippedOutput,
-    `Markdown: ${result.errors.length} ${MARKDOWN_COMMAND_OUTPUT.ERROR_SUMMARY_SUFFIX}`,
+    formatValidationProblemsFoundMessage(VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN, {
+      count: result.errors.length
+    }),
     ...errorLines
   ].join("\n");
   return { exitCode: 1, output, durationMs };
@@ -18810,12 +18959,24 @@ function formatMarkdownResult(result, skippedOutput, quiet, durationMs) {
 
 // src/validation/languages/markdown.ts
 var MARKDOWN_LANGUAGE_NAME = "markdown";
+var SKIP_MARKDOWN_REASON = "skip-markdown";
+var MARKDOWN_VALIDATION_STAGE_PARTICIPATION = {
+  [VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN]: {
+    default: VALIDATION_STAGE_PARTICIPATION.RUN,
+    skipReason: SKIP_MARKDOWN_REASON,
+    override: {
+      flag: "--skip-markdown",
+      description: "Skip Markdown validation for this validation all run"
+    }
+  }
+};
 var markdownValidationLanguage = {
   name: MARKDOWN_LANGUAGE_NAME,
   stages: [
     {
       name: VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN,
       failsPipeline: true,
+      participation: MARKDOWN_VALIDATION_STAGE_PARTICIPATION[VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN],
       run: (context) => markdownCommand({ cwd: context.cwd, files: context.files, quiet: context.quiet })
     }
   ]
@@ -19687,7 +19848,7 @@ var TSCONFIG_FILES = {
   full: "tsconfig.json",
   production: "tsconfig.production.json"
 };
-var PATH_SEGMENT_SEPARATOR4 = "/";
+var PATH_SEGMENT_SEPARATOR3 = "/";
 var GLOB_MARKER = "*";
 var RECURSIVE_GLOB_SEGMENT = "**";
 var SINGLE_CHARACTER_GLOB_MARKER = "?";
@@ -19718,8 +19879,8 @@ var EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND = {
   DIRECTORY: "directory",
   FILE: "file"
 };
-function resolveProjectPath(projectRoot, path4) {
-  return isAbsolute8(path4) ? path4 : join32(projectRoot, path4);
+function resolveProductPath(productDir, path4) {
+  return isAbsolute8(path4) ? path4 : join32(productDir, path4);
 }
 function parseTypeScriptConfig(configPath, deps = defaultScopeDeps) {
   try {
@@ -19733,11 +19894,11 @@ function parseTypeScriptConfig(configPath, deps = defaultScopeDeps) {
     };
   }
 }
-function resolveTypeScriptConfig(scope2, projectRoot, deps = defaultScopeDeps) {
+function resolveTypeScriptConfig(scope2, productDir, deps = defaultScopeDeps) {
   const configFile = TSCONFIG_FILES[scope2];
-  const config = parseTypeScriptConfig(resolveProjectPath(projectRoot, configFile), deps);
+  const config = parseTypeScriptConfig(resolveProductPath(productDir, configFile), deps);
   if (config.extends) {
-    const baseConfigs = normalizeExtends(config.extends).map((extendedConfig) => parseTypeScriptConfig(resolveProjectPath(projectRoot, extendedConfig), deps));
+    const baseConfigs = normalizeExtends(config.extends).map((extendedConfig) => parseTypeScriptConfig(resolveProductPath(productDir, extendedConfig), deps));
     const inheritedInclude = [...baseConfigs].reverse().find((baseConfig) => baseConfig.include !== void 0)?.include ?? [];
     const inheritedExclude = [...baseConfigs].reverse().find((baseConfig) => baseConfig.exclude !== void 0)?.exclude ?? [];
     return {
@@ -19773,48 +19934,48 @@ function hasTypeScriptFilesRecursive(dirPath, maxDepth = 2, deps = defaultScopeD
   }
 }
 function pathPassesTypeScriptFileDiscoveryExcludes(path4, options) {
-  const { excludePatterns = [], projectRoot } = options;
-  if (projectRoot === void 0) {
+  const { excludePatterns = [], productDir } = options;
+  if (productDir === void 0) {
     return true;
   }
-  const projectRelativePath = toProjectRelativeTypeScriptScopePath(projectRoot, path4);
+  const projectRelativePath = toProductRelativeTypeScriptScopePath(productDir, path4);
   return !excludePatterns.some((pattern) => pathMatchesTypeScriptPattern(projectRelativePath, pattern));
 }
-function getTopLevelDirectoriesWithTypeScript(config, projectRoot, deps = defaultScopeDeps) {
+function getTopLevelDirectoriesWithTypeScript(config, productDir, deps = defaultScopeDeps) {
   const directories = /* @__PURE__ */ new Set();
-  for (const dir of listTopLevelDirectories(projectRoot, deps)) {
-    if (directoryContributesTypeScriptScope(dir, config, projectRoot, deps)) {
+  for (const dir of listTopLevelDirectories(productDir, deps)) {
+    if (directoryContributesTypeScriptScope(dir, config, productDir, deps)) {
       directories.add(dir);
     }
   }
-  for (const dir of explicitIncludeTopLevelDirectories(config, projectRoot, deps)) {
+  for (const dir of explicitIncludeTopLevelDirectories(config, productDir, deps)) {
     directories.add(dir);
   }
   return Array.from(directories).sort(compareAsciiStrings);
 }
-function listTopLevelDirectories(projectRoot, deps) {
-  return deps.readdirSync(projectRoot, { withFileTypes: true }).filter((item) => item.isDirectory()).map((item) => item.name).filter((name) => !name.startsWith("."));
+function listTopLevelDirectories(productDir, deps) {
+  return deps.readdirSync(productDir, { withFileTypes: true }).filter((item) => item.isDirectory()).map((item) => item.name).filter((name) => !name.startsWith("."));
 }
-function directoryContributesTypeScriptScope(dir, config, projectRoot, deps) {
-  if (!directoryPassesIncludePatterns(dir, config.include ?? [], projectRoot, deps)) {
+function directoryContributesTypeScriptScope(dir, config, productDir, deps) {
+  if (!directoryPassesIncludePatterns(dir, config.include ?? [], productDir, deps)) {
     return false;
   }
   try {
-    return hasTypeScriptFilesRecursive(join32(projectRoot, dir), 2, deps, {
+    return hasTypeScriptFilesRecursive(join32(productDir, dir), 2, deps, {
       excludePatterns: config.exclude,
-      projectRoot
+      productDir
     });
   } catch {
     return false;
   }
 }
-function explicitIncludeTopLevelDirectories(config, projectRoot, deps) {
+function explicitIncludeTopLevelDirectories(config, productDir, deps) {
   if (!config.include) {
     return [];
   }
   const directories = [];
   for (const pattern of config.include) {
-    if (includePatternTargetsTypeScriptScope(pattern, projectRoot, deps) && pattern.includes(PATH_SEGMENT_SEPARATOR4)) {
+    if (includePatternTargetsTypeScriptScope(pattern, productDir, deps) && pattern.includes(PATH_SEGMENT_SEPARATOR3)) {
       const topLevelDir = getLiteralTopLevelPatternDirectory(pattern);
       if (topLevelDir) {
         directories.push(topLevelDir);
@@ -19824,39 +19985,39 @@ function explicitIncludeTopLevelDirectories(config, projectRoot, deps) {
   return directories;
 }
 function getLiteralTopLevelPatternDirectory(pattern) {
-  const topLevelDir = pattern.split(PATH_SEGMENT_SEPARATOR4)[0];
+  const topLevelDir = pattern.split(PATH_SEGMENT_SEPARATOR3)[0];
   if (!topLevelDir || typeScriptScopePatternHasGlob(topLevelDir) || topLevelDir.startsWith(HIDDEN_PATH_PREFIX)) {
     return null;
   }
   return topLevelDir;
 }
-function directoryPassesIncludePatterns(directory, patterns, projectRoot, deps) {
+function directoryPassesIncludePatterns(directory, patterns, productDir, deps) {
   return patterns.length === 0 || patterns.some(
-    (pattern) => includePatternTargetsTypeScriptScope(pattern, projectRoot, deps) && typeScriptScopePatternIntersectsDirectory(pattern, directory)
+    (pattern) => includePatternTargetsTypeScriptScope(pattern, productDir, deps) && typeScriptScopePatternIntersectsDirectory(pattern, directory)
   );
 }
 function stripTrailingPathSeparators2(value) {
   let end = value.length;
-  while (end > 0 && value.charAt(end - 1) === PATH_SEGMENT_SEPARATOR4) {
+  while (end > 0 && value.charAt(end - 1) === PATH_SEGMENT_SEPARATOR3) {
     end -= 1;
   }
   return value.slice(0, end);
 }
 function normalizeTypeScriptScopePath(path4) {
-  const joined = path4.split(/[\\/]/gu).join(PATH_SEGMENT_SEPARATOR4).replace(/^\.\//u, "");
+  const joined = path4.split(/[\\/]/gu).join(PATH_SEGMENT_SEPARATOR3).replace(/^\.\//u, "");
   return stripTrailingPathSeparators2(joined);
 }
 function pathMatchesLiteralPrefix(path4, prefix) {
   const normalizedPath = normalizeTypeScriptScopePath(path4);
   const normalizedPrefix = normalizeTypeScriptScopePath(prefix);
-  return normalizedPath === normalizedPrefix || normalizedPath.startsWith(`${normalizedPrefix}${PATH_SEGMENT_SEPARATOR4}`);
+  return normalizedPath === normalizedPrefix || normalizedPath.startsWith(`${normalizedPrefix}${PATH_SEGMENT_SEPARATOR3}`);
 }
 function splitTypeScriptScopePathSegments(path4) {
   const normalizedPath = normalizeTypeScriptScopePath(path4);
   if (normalizedPath.length === 0 || normalizedPath === ".") {
     return [];
   }
-  return normalizedPath.split(PATH_SEGMENT_SEPARATOR4);
+  return normalizedPath.split(PATH_SEGMENT_SEPARATOR3);
 }
 function globLiteralPrefix(pattern) {
   const normalizedPattern = normalizeTypeScriptScopePath(pattern);
@@ -19930,16 +20091,16 @@ function typeScriptScopeGlobPatternToRegExp(pattern) {
     const character = normalizedPattern[index];
     const nextCharacter = normalizedPattern[index + 1];
     const followingCharacter = normalizedPattern[index + 2];
-    if (character === GLOB_MARKER && nextCharacter === GLOB_MARKER && followingCharacter === PATH_SEGMENT_SEPARATOR4) {
-      source += `(?:.*${PATH_SEGMENT_SEPARATOR4})?`;
+    if (character === GLOB_MARKER && nextCharacter === GLOB_MARKER && followingCharacter === PATH_SEGMENT_SEPARATOR3) {
+      source += `(?:.*${PATH_SEGMENT_SEPARATOR3})?`;
       index += 2;
     } else if (character === GLOB_MARKER && nextCharacter === GLOB_MARKER) {
       source += ".*";
       index += 1;
     } else if (character === GLOB_MARKER) {
-      source += `[^${PATH_SEGMENT_SEPARATOR4}]*`;
+      source += `[^${PATH_SEGMENT_SEPARATOR3}]*`;
     } else if (character === SINGLE_CHARACTER_GLOB_MARKER) {
-      source += `[^${PATH_SEGMENT_SEPARATOR4}]`;
+      source += `[^${PATH_SEGMENT_SEPARATOR3}]`;
     } else {
       source += character.replaceAll(GLOB_REGEX_SPECIAL_CHARACTER_PATTERN, REGEX_ESCAPE_REPLACEMENT);
     }
@@ -20007,12 +20168,12 @@ function typeScriptScopePatternTargetsTypeScriptSource(pattern) {
   const terminalSegment = splitTypeScriptScopePathSegments(normalizedPattern).at(-1) ?? normalizedPattern;
   return typeScriptScopePatternHasGlob(terminalSegment) && !TERMINAL_EXTENSION_PATTERN.test(terminalSegment);
 }
-function includePatternTargetsTypeScriptScope(pattern, projectRoot, deps) {
-  return includePatternIsLiteralDirectory(pattern, projectRoot, deps) || typeScriptScopePatternTargetsTypeScriptSource(pattern);
+function includePatternTargetsTypeScriptScope(pattern, productDir, deps) {
+  return includePatternIsLiteralDirectory(pattern, productDir, deps) || typeScriptScopePatternTargetsTypeScriptSource(pattern);
 }
-function includePatternIsLiteralDirectory(pattern, projectRoot, deps) {
+function includePatternIsLiteralDirectory(pattern, productDir, deps) {
   const normalizedPattern = normalizeTypeScriptScopePath(pattern);
-  return !typeScriptScopePatternHasGlob(normalizedPattern) && pathIsDirectory(resolveProjectPath(projectRoot, normalizedPattern), deps);
+  return !typeScriptScopePatternHasGlob(normalizedPattern) && pathIsDirectory(resolveProductPath(productDir, normalizedPattern), deps);
 }
 function pathIsDirectory(path4, deps) {
   try {
@@ -20022,28 +20183,28 @@ function pathIsDirectory(path4, deps) {
     return false;
   }
 }
-function normalizeActiveIncludePattern(pattern, projectRoot, deps) {
+function normalizeActiveIncludePattern(pattern, productDir, deps) {
   const normalizedPattern = normalizeTypeScriptScopePath(pattern);
-  return includePatternIsLiteralDirectory(normalizedPattern, projectRoot, deps) ? `${normalizedPattern}${TYPESCRIPT_SCOPE_DIRECTORY_PATTERN_SUFFIX}` : pattern;
+  return includePatternIsLiteralDirectory(normalizedPattern, productDir, deps) ? `${normalizedPattern}${TYPESCRIPT_SCOPE_DIRECTORY_PATTERN_SUFFIX}` : pattern;
 }
-function filterActiveIncludePatterns(patterns, excludePatterns, projectRoot, deps) {
-  return patterns.map((pattern) => normalizeActiveIncludePattern(pattern, projectRoot, deps)).filter((pattern) => typeScriptScopePatternTargetsTypeScriptSource(pattern)).filter((pattern) => {
+function filterActiveIncludePatterns(patterns, excludePatterns, productDir, deps) {
+  return patterns.map((pattern) => normalizeActiveIncludePattern(pattern, productDir, deps)).filter((pattern) => typeScriptScopePatternTargetsTypeScriptSource(pattern)).filter((pattern) => {
     const topLevelDir = getLiteralTopLevelPatternDirectory(pattern);
-    return topLevelDir === null || deps.existsSync(join32(projectRoot, topLevelDir));
+    return topLevelDir === null || deps.existsSync(join32(productDir, topLevelDir));
   }).filter((pattern) => pathPassesValidationFilter(pattern, { exclude: excludePatterns }));
 }
-function getValidationDirectories(scope2, projectRoot, deps = defaultScopeDeps) {
-  const config = resolveTypeScriptConfig(scope2, projectRoot, deps);
-  const configDirectories = getTopLevelDirectoriesWithTypeScript(config, projectRoot, deps);
-  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(join32(projectRoot, dir)));
+function getValidationDirectories(scope2, productDir, deps = defaultScopeDeps) {
+  const config = resolveTypeScriptConfig(scope2, productDir, deps);
+  const configDirectories = getTopLevelDirectoriesWithTypeScript(config, productDir, deps);
+  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(join32(productDir, dir)));
   return existingDirectories;
 }
-function getTypeScriptScope(scope2, projectRoot, deps = defaultScopeDeps) {
-  const directories = getValidationDirectories(scope2, projectRoot, deps);
-  const config = resolveTypeScriptConfig(scope2, projectRoot, deps);
+function getTypeScriptScope(scope2, productDir, deps = defaultScopeDeps) {
+  const directories = getValidationDirectories(scope2, productDir, deps);
+  const config = resolveTypeScriptConfig(scope2, productDir, deps);
   return {
     directories,
-    filePatterns: filterActiveIncludePatterns(config.include ?? [], config.exclude ?? [], projectRoot, deps),
+    filePatterns: filterActiveIncludePatterns(config.include ?? [], config.exclude ?? [], productDir, deps),
     excludePatterns: config.exclude ?? []
   };
 }
@@ -20055,31 +20216,31 @@ function pathPassesTypeScriptScope(path4, scopeConfig) {
   const excluded = scopeConfig.excludePatterns.some((pattern) => pathMatchesTypeScriptPattern(path4, pattern));
   return included && !excluded;
 }
-function pathStaysInsideTypeScriptScopeRoot(projectRoot, path4) {
-  const resolvedPath = isAbsolute8(path4) ? resolve14(path4) : resolve14(projectRoot, path4);
-  const relativePath = relative7(projectRoot, resolvedPath);
-  const segments = normalizeTypeScriptScopePath(relativePath).split(PATH_SEGMENT_SEPARATOR4);
+function pathStaysInsideTypeScriptScopeRoot(productDir, path4) {
+  const resolvedPath = isAbsolute8(path4) ? resolve14(path4) : resolve14(productDir, path4);
+  const relativePath = relative7(productDir, resolvedPath);
+  const segments = normalizeTypeScriptScopePath(relativePath).split(PATH_SEGMENT_SEPARATOR3);
   return relativePath.length === 0 || !segments.includes("..") && !isAbsolute8(relativePath);
 }
-function toProjectRelativeTypeScriptScopePath(projectRoot, path4) {
-  const resolvedPath = isAbsolute8(path4) ? resolve14(path4) : resolve14(projectRoot, path4);
-  const relativePath = relative7(projectRoot, resolvedPath);
+function toProductRelativeTypeScriptScopePath(productDir, path4) {
+  const resolvedPath = isAbsolute8(path4) ? resolve14(path4) : resolve14(productDir, path4);
+  const relativePath = relative7(productDir, resolvedPath);
   return relativePath.length === 0 ? TYPESCRIPT_SCOPE_PROJECT_ROOT : normalizeTypeScriptScopePath(relativePath);
 }
-function toExplicitTypeScriptScopeTarget(projectRoot, originalPath, deps = defaultScopeDeps) {
-  const path4 = toProjectRelativeTypeScriptScopePath(projectRoot, originalPath);
+function toExplicitTypeScriptScopeTarget(productDir, originalPath, deps = defaultScopeDeps) {
+  const path4 = toProductRelativeTypeScriptScopePath(productDir, originalPath);
   return {
-    kind: pathIsDirectory(resolveProjectPath(projectRoot, path4), deps) ? EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.DIRECTORY : EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.FILE,
+    kind: pathIsDirectory(resolveProductPath(productDir, path4), deps) ? EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.DIRECTORY : EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.FILE,
     path: path4
   };
 }
-function explicitTypeScriptScopeTargetExists(projectRoot, target, deps) {
-  return deps.existsSync(resolveProjectPath(projectRoot, target.path));
+function explicitTypeScriptScopeTargetExists(productDir, target, deps) {
+  return deps.existsSync(resolveProductPath(productDir, target.path));
 }
 function filterExplicitTypeScriptScopeTargets(filter, deps = defaultScopeDeps) {
   const {
     paths,
-    projectRoot,
+    productDir,
     requireExistingPaths = true,
     scopeConfig,
     validationPathFilter,
@@ -20088,7 +20249,7 @@ function filterExplicitTypeScriptScopeTargets(filter, deps = defaultScopeDeps) {
   if (paths === void 0) {
     return void 0;
   }
-  return paths.filter((path4) => pathStaysInsideTypeScriptScopeRoot(projectRoot, path4)).map((path4) => toExplicitTypeScriptScopeTarget(projectRoot, path4, deps)).filter((target) => !requireExistingPaths || explicitTypeScriptScopeTargetExists(projectRoot, target, deps)).filter((target) => explicitTypeScriptScopeTargetPassesSourceKind(target)).filter(
+  return paths.filter((path4) => pathStaysInsideTypeScriptScopeRoot(productDir, path4)).map((path4) => toExplicitTypeScriptScopeTarget(productDir, path4, deps)).filter((target) => !requireExistingPaths || explicitTypeScriptScopeTargetExists(productDir, target, deps)).filter((target) => explicitTypeScriptScopeTargetPassesSourceKind(target)).filter(
     (target) => bypassValidationPathFilter || explicitTypeScriptScopeTargetIntersectsValidationPathFilter(target, validationPathFilter)
   ).filter((target) => explicitTypeScriptScopeTargetPassesScope(target, scopeConfig));
 }
@@ -20157,7 +20318,7 @@ function constrainTypeScriptScopeToExplicitTargets(scopeConfig, targets) {
   const retainedDirectoryOperandPatterns = scopeConfig.filePatterns.length === 0 ? retainedDirectories.map(typeScriptLiteralDirectoryPattern) : [];
   const explicitFileTargets = targets.filter((target) => target.kind === EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.FILE).map((target) => target.path).filter(
     (path4) => !retainedDirectories.some(
-      (directory) => path4 === directory || path4.startsWith(`${directory}${PATH_SEGMENT_SEPARATOR4}`)
+      (directory) => path4 === directory || path4.startsWith(`${directory}${PATH_SEGMENT_SEPARATOR3}`)
     )
   );
   const uncoveredExplicitFileTargets = explicitFileTargets.filter(
@@ -20182,28 +20343,28 @@ function typeScriptLiteralDirectoryPattern(pattern) {
   return pattern === TYPESCRIPT_SCOPE_PROJECT_ROOT ? TYPESCRIPT_SCOPE_DIRECTORY_PATTERN_SUFFIX.slice(1) : `${pattern}${TYPESCRIPT_SCOPE_DIRECTORY_PATTERN_SUFFIX}`;
 }
 function resolveTypeScriptValidationScope(filter, deps = defaultScopeDeps) {
-  const baseScopeConfig = getTypeScriptScope(filter.scope, filter.projectRoot, deps);
+  const baseScopeConfig = getTypeScriptScope(filter.scope, filter.productDir, deps);
   const scopeConfig = applyValidationPathFilterToScope(baseScopeConfig, filter.validationPathFilter);
-  const explicitTargetScopeConfig = filter.bypassExplicitPathValidationFilter === true ? baseScopeConfig : scopeConfig;
   const explicitTargets = filterExplicitTypeScriptScopeTargets({
     paths: filter.paths,
-    projectRoot: filter.projectRoot,
+    productDir: filter.productDir,
     validationPathFilter: filter.validationPathFilter,
-    scopeConfig: explicitTargetScopeConfig,
-    bypassValidationPathFilter: filter.bypassExplicitPathValidationFilter
+    scopeConfig: baseScopeConfig,
+    bypassValidationPathFilter: true
   }, deps);
   if (filter.paths !== void 0 && filter.paths.length > 0 && explicitTargets?.length === 0) {
     return {
       ...scopeConfig,
       directories: [],
       filePatterns: [],
-      filteredByValidationPaths: true,
-      filteredByValidationPathIncludes: true,
-      filteredByValidationPathNoMatches: true
+      explicitPathNoMatches: true,
+      filteredByValidationPaths: void 0,
+      filteredByValidationPathIncludes: void 0,
+      filteredByValidationPathNoMatches: void 0
     };
   }
   if (explicitTargets !== void 0 && explicitTargets.length > 0) {
-    const explicitScopeConfig = constrainTypeScriptScopeToExplicitTargets(explicitTargetScopeConfig, explicitTargets);
+    const explicitScopeConfig = constrainTypeScriptScopeToExplicitTargets(baseScopeConfig, explicitTargets);
     return filter.markExplicitPathsAsValidationFilter === true ? {
       ...explicitScopeConfig,
       filteredByValidationPaths: true,
@@ -20216,7 +20377,7 @@ function resolveTypeScriptValidationScope(filter, deps = defaultScopeDeps) {
 function constrainTypeScriptPatternToDirectory(pattern, directory) {
   const normalizedPattern = normalizeTypeScriptScopePath(pattern);
   const normalizedDirectory = normalizeTypeScriptScopePath(directory);
-  if (normalizedPattern === normalizedDirectory || normalizedPattern.startsWith(`${normalizedDirectory}${PATH_SEGMENT_SEPARATOR4}`)) {
+  if (normalizedPattern === normalizedDirectory || normalizedPattern.startsWith(`${normalizedDirectory}${PATH_SEGMENT_SEPARATOR3}`)) {
     return normalizedPattern;
   }
   const patternSegments = splitTypeScriptScopePathSegments(normalizedPattern);
@@ -20229,7 +20390,7 @@ function constrainTypeScriptPatternToDirectory(pattern, directory) {
   const suffixSegments = patternSegments.slice(patternIndex);
   const constrainedSuffixSegments = directoryAdvance.recursiveGlobConsumedDirectory && suffixSegments.length > 0 ? [RECURSIVE_GLOB_SEGMENT, ...suffixSegments] : suffixSegments;
   if (constrainedSuffixSegments.length > 0) {
-    return [normalizedDirectory, ...constrainedSuffixSegments].join(PATH_SEGMENT_SEPARATOR4);
+    return [normalizedDirectory, ...constrainedSuffixSegments].join(PATH_SEGMENT_SEPARATOR3);
   }
   return typeScriptScopePatternHasGlob(normalizedPattern) && typeScriptScopePatternCoversDirectorySourceSet(normalizedPattern, normalizedDirectory) ? `${normalizedDirectory}${TYPESCRIPT_SCOPE_DIRECTORY_PATTERN_SUFFIX}` : normalizedDirectory;
 }
@@ -20263,7 +20424,7 @@ function patternSegmentMatchesDirectorySegment(patternSegment, directorySegment)
 
 // src/validation/discovery/tool-finder.ts
 import fs3 from "fs";
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import path3 from "path";
 import { fileURLToPath } from "url";
 
@@ -20298,7 +20459,11 @@ var TOOL_DISCOVERY = {
 };
 
 // src/validation/discovery/tool-finder.ts
-var require2 = createRequire(import.meta.url);
+var TOOL_DISCOVERY_PRIORITY = {
+  BUNDLED_FIRST: "bundled-first",
+  PRODUCT_FIRST: "product-first"
+};
+var require2 = createRequire2(import.meta.url);
 var FILE_URL_PROTOCOL = new URL(import.meta.url).protocol;
 var PACKAGE_MANIFEST_FILENAME = "package.json";
 var defaultToolDiscoveryDeps = {
@@ -20345,30 +20510,44 @@ function bundledToolPath(resolvedPath, existsSync10) {
   return nearestPackageRoot(bundledFilePath, existsSync10) ?? path3.dirname(bundledFilePath);
 }
 async function discoverTool(tool, options = {}) {
-  const { projectRoot = CONFIG_PROCESS_CWD.read(), deps = defaultToolDiscoveryDeps } = options;
-  const bundledPath = deps.resolveModule(`${tool}/package.json`) ?? deps.resolveImport?.(tool);
+  const {
+    productDir = CONFIG_PROCESS_CWD.read(),
+    executableName = tool,
+    bundledExecutable,
+    includeBundled = true,
+    priority = TOOL_DISCOVERY_PRIORITY.BUNDLED_FIRST,
+    deps = defaultToolDiscoveryDeps
+  } = options;
+  const productBinPath = path3.join(productDir, "node_modules", ".bin", executableName);
+  const productLocation = () => deps.existsSync(productBinPath) ? {
+    found: true,
+    location: {
+      tool,
+      path: productBinPath,
+      source: TOOL_DISCOVERY.SOURCES.PROJECT
+    }
+  } : null;
+  if (priority === TOOL_DISCOVERY_PRIORITY.PRODUCT_FIRST) {
+    const productResult = productLocation();
+    if (productResult !== null) return productResult;
+  }
+  const bundledSpecifier = bundledExecutable ?? `${tool}/package.json`;
+  const bundledPath = includeBundled ? deps.resolveModule(bundledSpecifier) ?? deps.resolveImport?.(bundledExecutable ?? tool) : null;
   if (bundledPath) {
     return {
       found: true,
       location: {
         tool,
-        path: bundledToolPath(bundledPath, deps.existsSync),
+        path: bundledExecutable === void 0 ? bundledToolPath(bundledPath, deps.existsSync) : resolvedModulePath(bundledPath),
         source: TOOL_DISCOVERY.SOURCES.BUNDLED
       }
     };
   }
-  const projectBinPath = path3.join(projectRoot, "node_modules", ".bin", tool);
-  if (deps.existsSync(projectBinPath)) {
-    return {
-      found: true,
-      location: {
-        tool,
-        path: projectBinPath,
-        source: TOOL_DISCOVERY.SOURCES.PROJECT
-      }
-    };
+  if (priority === TOOL_DISCOVERY_PRIORITY.BUNDLED_FIRST) {
+    const productResult = productLocation();
+    if (productResult !== null) return productResult;
   }
-  const globalPath = deps.whichSync(tool);
+  const globalPath = deps.whichSync(executableName);
   if (globalPath) {
     return {
       found: true,
@@ -20519,13 +20698,13 @@ function dependencyCruiserGlobSegmentToRegExpSource(segment) {
   }
   return source;
 }
-function buildDependencyCruiserOptions(typescriptScope, projectRoot, tsConfigFile) {
+function buildDependencyCruiserOptions(typescriptScope, productDir, tsConfigFile) {
   const excludePatterns = [
     DEPENDENCY_CRUISER_PACKAGE_EXCLUDE_PATTERN,
     ...toDependencyCruiserExcludePatterns(typescriptScope.excludePatterns)
   ];
   return {
-    baseDir: projectRoot,
+    baseDir: productDir,
     enhancedResolveOptions: { extensions: [...DEPENDENCY_CRUISER_TYPESCRIPT_RESOLVE_EXTENSIONS] },
     exclude: { path: excludePatterns },
     includeOnly: { path: DEPENDENCY_CRUISER_TYPESCRIPT_SOURCE_PATTERN },
@@ -20633,16 +20812,16 @@ function circularDependencyCycles(result) {
   );
   return uniqueCycles(cycles);
 }
-async function validateCircularDependencies(scope2, typescriptScope, projectRoot, deps = defaultCircularDeps) {
+async function validateCircularDependencies(scope2, typescriptScope, productDir, deps = defaultCircularDeps) {
   try {
     const analyzeSourcePatterns = toDependencyCruiserSourcePatterns(typescriptScope);
     if (analyzeSourcePatterns.length === 0) {
       return { success: true };
     }
-    const tsConfigFile = join33(projectRoot, TSCONFIG_FILES[scope2]);
+    const tsConfigFile = join33(productDir, TSCONFIG_FILES[scope2]);
     const result = await deps.dependencyCruiser(
       analyzeSourcePatterns,
-      buildDependencyCruiserOptions(typescriptScope, projectRoot, tsConfigFile),
+      buildDependencyCruiserOptions(typescriptScope, productDir, tsConfigFile),
       void 0,
       { tsConfig: deps.extractTypeScriptConfig(tsConfigFile) }
     );
@@ -20681,9 +20860,9 @@ var EXECUTION_MODES = {
 
 // src/commands/validation/circular.ts
 var TYPESCRIPT_ABSENT_MESSAGE = formatTypeScriptAbsentSkipMessage(VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR);
-var CIRCULAR_CONFIG_ERROR_MESSAGE = `${VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR}: \u2717 config error`;
-var CIRCULAR_VALIDATION_PATHS_NO_TARGETS_MESSAGE = formatValidationPathsNoTargetsSkipMessage(
-  VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR
+var CIRCULAR_CONFIG_ERROR_MESSAGE = formatValidationConfigProblemMessage(
+  VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR,
+  "configuration error"
 );
 var CIRCULAR_DEPENDENCY_OUTPUT = {
   FOUND: VALIDATION_COMMAND_OUTPUT.CIRCULAR_FOUND
@@ -20691,7 +20870,6 @@ var CIRCULAR_DEPENDENCY_OUTPUT = {
 var defaultCircularCommandDeps = {
   validateCircularDependencies
 };
-var DEPENDENCY_CRUISER_PACKAGE_NAME = "dependency-cruiser";
 function formatCircularValidationResult(result, quiet) {
   if (result.success) {
     return {
@@ -20723,11 +20901,6 @@ async function circularCommand(options, deps = defaultCircularCommandDeps) {
       durationMs: Date.now() - startTime
     };
   }
-  const toolResult = await discoverTool(DEPENDENCY_CRUISER_PACKAGE_NAME, { projectRoot: cwd });
-  if (!toolResult.found) {
-    const skipMessage = formatSkipMessage(VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR, toolResult);
-    return { exitCode: 0, output: skipMessage, durationMs: Date.now() - startTime };
-  }
   const loaded = await resolveConfig(cwd, [validationConfigDescriptor]);
   if (!loaded.ok) {
     return {
@@ -20738,19 +20911,22 @@ async function circularCommand(options, deps = defaultCircularCommandDeps) {
   }
   const validationConfig = loaded.value[validationConfigDescriptor.section];
   const effectiveScopeConfig = resolveTypeScriptValidationScope({
-    projectRoot: cwd,
+    productDir: cwd,
     scope: scope2,
     paths: files,
     validationPathFilter: validationPathFilterForTool(
       validationConfig.paths,
       VALIDATION_PATH_TOOL_SUBSECTIONS.CIRCULAR
-    ),
-    bypassExplicitPathValidationFilter: true
+    )
   });
-  if (effectiveScopeConfig.filteredByValidationPathNoMatches) {
+  const noTargetsMessage = formatValidationScopeNoTargetsSkipMessage(
+    VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR,
+    effectiveScopeConfig
+  );
+  if (noTargetsMessage !== void 0) {
     return {
       exitCode: 0,
-      output: quiet ? "" : CIRCULAR_VALIDATION_PATHS_NO_TARGETS_MESSAGE,
+      output: quiet ? "" : noTargetsMessage,
       durationMs: Date.now() - startTime
     };
   }
@@ -20770,6 +20946,7 @@ var KNIP_COMMAND_TOKENS = {
   TSCONFIG_FLAG: "--tsConfig",
   USE_TSCONFIG_FILES_FLAG: "--use-tsconfig-files"
 };
+var KNIP_LOCAL_BIN_SEGMENTS = ["node_modules", ".bin", KNIP_COMMAND_TOKENS.COMMAND];
 var defaultKnipDeps = {
   existsSync: existsSync4,
   mkdir: mkdir7,
@@ -20777,9 +20954,9 @@ var defaultKnipDeps = {
   rm: rm4,
   writeFile: writeFile5
 };
-async function validateKnip2(context, runner = defaultKnipProcessRunner, deps = defaultKnipDeps) {
+async function validateKnip2(context, runner = defaultKnipProcessRunner, deps = defaultKnipDeps, outputStreams = defaultValidationSubprocessOutputStreams) {
   try {
-    const { projectRoot, typescriptScope } = context;
+    const { productDir, typescriptScope, toolPath } = context;
     const analyzeTargets = [
       ...typescriptScope.directories,
       ...typescriptScope.filePatterns
@@ -20787,16 +20964,16 @@ async function validateKnip2(context, runner = defaultKnipProcessRunner, deps =
     if (analyzeTargets.length === 0) {
       return { success: true };
     }
-    return await runKnipSubprocess(projectRoot, typescriptScope, runner, deps);
+    return await runKnipSubprocess(productDir, typescriptScope, runner, deps, outputStreams, toolPath);
   } catch (error) {
     const errorMessage2 = error instanceof Error ? error.message : String(error);
     return { success: false, error: errorMessage2 };
   }
 }
-async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
-  const scopedTsconfig = typescriptScope.filteredByValidationPaths ? await createScopedKnipTsconfig(projectRoot, typescriptScope, deps) : void 0;
-  const localBin = join34(projectRoot, "node_modules", ".bin", "knip");
-  const binary = deps.existsSync(localBin) ? localBin : KNIP_COMMAND_TOKENS.NPX_COMMAND;
+async function runKnipSubprocess(productDir, typescriptScope, runner, deps, outputStreams, toolPath) {
+  const scopedTsconfig = typescriptScope.filteredByValidationPaths ? await createScopedKnipTsconfig(productDir, typescriptScope, deps) : void 0;
+  const localBin = join34(productDir, ...KNIP_LOCAL_BIN_SEGMENTS);
+  const binary = toolPath ?? (deps.existsSync(localBin) ? localBin : KNIP_COMMAND_TOKENS.NPX_COMMAND);
   const baseArgs = scopedTsconfig === void 0 ? [] : [
     KNIP_COMMAND_TOKENS.USE_TSCONFIG_FILES_FLAG,
     KNIP_COMMAND_TOKENS.TSCONFIG_FLAG,
@@ -20804,8 +20981,9 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   ];
   const args = binary === KNIP_COMMAND_TOKENS.NPX_COMMAND ? [KNIP_COMMAND_TOKENS.COMMAND, ...baseArgs] : baseArgs;
   const knipProcess = spawnManagedSubprocess(runner, binary, args, {
-    cwd: projectRoot
+    cwd: productDir
   });
+  forwardValidationSubprocessOutput(knipProcess, outputStreams);
   const cleanup = scopedTsconfig?.cleanup ?? (async () => {
   });
   let cleanupStarted = false;
@@ -20835,7 +21013,7 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
     };
     knipProcess.on("close", (code) => {
       if (code === 0) {
-        resolveAfterCleanup({ success: true });
+        resolveAfterCleanup({ success: true, output: knipOutput });
       } else {
         const errorOutput = knipOutput || knipError || "Unused code detected";
         resolveAfterCleanup({
@@ -20849,12 +21027,12 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
     });
   });
 }
-async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
-  const tempParentDir = join34(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+async function createScopedKnipTsconfig(productDir, typescriptScope, deps) {
+  const tempParentDir = join34(productDir, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   await deps.mkdir(tempParentDir, { recursive: true });
   const tempDir = await deps.mkdtemp(join34(tempParentDir, "validate-knip-"));
   const configPath = join34(tempDir, TSCONFIG_FILES.full);
-  const toProjectPathPattern = (pattern) => isAbsolute9(pattern) ? pattern : join34(projectRoot, pattern);
+  const toProjectPathPattern = (pattern) => isAbsolute9(pattern) ? pattern : join34(productDir, pattern);
   const project = [
     ...typescriptScope.directories.flatMap(
       (directory) => TYPESCRIPT_FALLBACK_INCLUDE_PATTERNS.map((pattern) => `${directory}/${pattern}`)
@@ -20862,7 +21040,7 @@ async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
     ...typescriptScope.filePatterns
   ];
   const config = {
-    extends: join34(projectRoot, TSCONFIG_FILES.full),
+    extends: join34(productDir, TSCONFIG_FILES.full),
     include: project.map(toProjectPathPattern),
     exclude: typescriptScope.excludePatterns.map(toProjectPathPattern)
   };
@@ -20879,17 +21057,25 @@ var defaultKnipCommandDeps = {
   discoverTool,
   validateKnip: validateKnip2
 };
-var TYPESCRIPT_ABSENT_MESSAGE2 = formatTypeScriptAbsentSkipMessage(VALIDATION_STAGE_DISPLAY_NAMES.KNIP);
-var KNIP_VALIDATION_PATHS_NO_TARGETS_MESSAGE = formatValidationPathsNoTargetsSkipMessage(
+var KNIP_VALIDATION_STEP_NAME = "unused code detection";
+var KNIP_TYPESCRIPT_ABSENT_MESSAGE = formatTypeScriptAbsentSkipMessage(
   VALIDATION_STAGE_DISPLAY_NAMES.KNIP
 );
 async function knipCommand(options, deps = defaultKnipCommandDeps) {
-  const { cwd, files, quiet, scope: scope2 = VALIDATION_SCOPES.FULL } = options;
+  const {
+    cwd,
+    files,
+    json,
+    outputStreams,
+    quiet,
+    scope: scope2 = VALIDATION_SCOPES.FULL,
+    streamedPipelineOutput
+  } = options;
   const startTime = Date.now();
   if (!deps.detectTypeScript(cwd).present) {
     return {
       exitCode: 0,
-      output: quiet ? "" : TYPESCRIPT_ABSENT_MESSAGE2,
+      output: quiet ? "" : KNIP_TYPESCRIPT_ABSENT_MESSAGE,
       durationMs: Date.now() - startTime
     };
   }
@@ -20906,34 +21092,51 @@ async function knipCommand(options, deps = defaultKnipCommandDeps) {
     const output = quiet ? "" : VALIDATION_COMMAND_OUTPUT.KNIP_DISABLED;
     return { exitCode: 0, output, durationMs: Date.now() - startTime };
   }
-  const toolResult = await deps.discoverTool("knip", { projectRoot: cwd });
+  const toolResult = await deps.discoverTool(KNIP_COMMAND_TOKENS.COMMAND, {
+    productDir: cwd,
+    includeBundled: false
+  });
   if (!toolResult.found) {
-    const skipMessage = formatSkipMessage("unused code detection", toolResult);
+    const skipMessage = formatSkipMessage(KNIP_VALIDATION_STEP_NAME, toolResult);
     return { exitCode: 0, output: skipMessage, durationMs: Date.now() - startTime };
   }
   const scopeConfig = resolveTypeScriptValidationScope({
-    projectRoot: cwd,
+    productDir: cwd,
     scope: scope2,
     paths: files,
     validationPathFilter: validationPathFilterForTool(validationConfig.paths, VALIDATION_PATH_TOOL_SUBSECTIONS.KNIP),
-    markExplicitPathsAsValidationFilter: true,
-    bypassExplicitPathValidationFilter: true
+    markExplicitPathsAsValidationFilter: true
   });
-  if (scopeConfig.filteredByValidationPathNoMatches) {
+  const noTargetsMessage = formatValidationScopeNoTargetsSkipMessage(
+    VALIDATION_STAGE_DISPLAY_NAMES.KNIP,
+    scopeConfig
+  );
+  if (noTargetsMessage !== void 0) {
     return {
       exitCode: 0,
-      output: quiet ? "" : KNIP_VALIDATION_PATHS_NO_TARGETS_MESSAGE,
+      output: quiet ? "" : noTargetsMessage,
       durationMs: Date.now() - startTime
     };
   }
-  const result = await deps.validateKnip({ projectRoot: cwd, typescriptScope: scopeConfig });
+  const result = await deps.validateKnip(
+    {
+      productDir: cwd,
+      typescriptScope: scopeConfig,
+      toolPath: toolResult.location.path
+    },
+    void 0,
+    void 0,
+    outputStreams ?? discardValidationSubprocessOutputStreams
+  );
   const durationMs = Date.now() - startTime;
   if (result.success) {
-    const output = quiet ? "" : VALIDATION_COMMAND_OUTPUT.KNIP_SUCCESS;
-    return { exitCode: 0, output, durationMs };
+    const output = quiet ? "" : [VALIDATION_COMMAND_OUTPUT.KNIP_SUCCESS, result.output].filter((line) => line !== void 0 && line.length > 0).join("\n");
+    const terminalOutput = streamedValidationTerminalOutput(result.output, json, streamedPipelineOutput);
+    return { exitCode: 0, output, terminalOutput, durationMs };
   } else {
     const output = result.error ?? VALIDATION_COMMAND_OUTPUT.KNIP_FAILURE;
-    return { exitCode: 1, output, durationMs };
+    const terminalOutput = streamedValidationTerminalOutput(result.error, json, streamedPipelineOutput);
+    return { exitCode: 1, output, terminalOutput, durationMs };
   }
 }
 
@@ -21193,8 +21396,7 @@ function validateLintPolicy(productDir) {
   }
 }
 
-// src/validation/steps/eslint.ts
-var defaultEslintProcessRunner = lifecycleProcessRunner;
+// src/validation/steps/eslint-contract.ts
 var DEFAULT_ESLINT_CONFIG_FILE = "eslint.config.ts";
 var ESLINT_COMMAND_TOKENS = {
   COMMAND: "eslint",
@@ -21205,6 +21407,9 @@ var ESLINT_COMMAND_TOKENS = {
   IGNORE_PATTERN_FLAG: "--ignore-pattern"
 };
 var ESLINT_LOCAL_BIN_SEGMENTS = ["node_modules", ".bin", ESLINT_COMMAND_TOKENS.COMMAND];
+
+// src/validation/steps/eslint.ts
+var defaultEslintProcessRunner = lifecycleProcessRunner;
 function buildEslintArgs(context) {
   const {
     validatedFiles,
@@ -21252,8 +21457,8 @@ function buildIgnorePatternArgs(patterns) {
   return patterns.flatMap((pattern) => [ESLINT_COMMAND_TOKENS.IGNORE_PATTERN_FLAG, pattern]);
 }
 async function validateESLint(context, runner = defaultEslintProcessRunner, outputStreams = defaultValidationSubprocessOutputStreams) {
-  const { projectRoot, scope: scope2, validatedFiles, mode, eslintConfigFile } = context;
-  const lintPolicy = validateLintPolicy(projectRoot);
+  const { productDir, scope: scope2, validatedFiles, mode, eslintConfigFile, toolPath } = context;
+  const lintPolicy = validateLintPolicy(productDir);
   if (!lintPolicy.ok) {
     return { success: false, error: lintPolicy.error };
   }
@@ -21269,47 +21474,57 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
     scopeConfig: context.scopeConfig
   });
   return new Promise((resolve17) => {
-    const localBin = join36(projectRoot, ...ESLINT_LOCAL_BIN_SEGMENTS);
-    const binary = existsSync6(localBin) ? localBin : "npx";
+    const localBin = join36(productDir, ...ESLINT_LOCAL_BIN_SEGMENTS);
+    const binary = toolPath ?? (existsSync6(localBin) ? localBin : "npx");
     const spawnArgs = binary === "npx" ? eslintArgs : eslintArgs.slice(1);
     const eslintProcess = spawnManagedSubprocess(runner, binary, spawnArgs, {
-      cwd: projectRoot
+      cwd: productDir
     });
+    const chunks = [];
+    const capture = (chunk) => {
+      chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString());
+    };
+    eslintProcess.stdout?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
+    eslintProcess.stderr?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
     forwardValidationSubprocessOutput(eslintProcess, outputStreams);
     eslintProcess.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
+      const output = chunks.join("");
       if (code === 0) {
-        resolve17({ success: true });
+        resolve17({ success: true, output });
       } else {
-        resolve17({ success: false, error: `ESLint exited with code ${code}` });
+        resolve17({ success: false, output, error: `ESLint exited with code ${code}` });
       }
     });
     eslintProcess.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
-      resolve17({ success: false, error: error.message });
+      resolve17({ success: false, output: chunks.join(""), error: error.message });
     });
   });
 }
 
 // src/commands/validation/lint.ts
-var TYPESCRIPT_ABSENT_MESSAGE3 = formatTypeScriptAbsentSkipMessage(VALIDATION_STAGE_DISPLAY_NAMES.ESLINT);
-var MISSING_CONFIG_MESSAGE = VALIDATION_COMMAND_OUTPUT.ESLINT_MISSING_CONFIG;
-var ESLINT_CONFIG_ERROR_MESSAGE = `${VALIDATION_STAGE_DISPLAY_NAMES.ESLINT}: \u2717 config error`;
-var VALIDATION_PATHS_NO_TARGETS_MESSAGE = formatValidationPathsNoTargetsSkipMessage(
-  VALIDATION_STAGE_DISPLAY_NAMES.ESLINT
-);
-var defaultLintCommandDependencies = {
+var defaultLintCommandDeps = {
   detectTypeScript,
   discoverTool,
   resolveConfig,
   validateESLint
 };
-async function lintCommand(options, deps = defaultLintCommandDependencies) {
-  const { cwd, scope: scope2 = "full", files, fix, outputStreams, quiet } = options;
+var TYPESCRIPT_ABSENT_MESSAGE2 = formatTypeScriptAbsentSkipMessage(VALIDATION_STAGE_DISPLAY_NAMES.ESLINT);
+var MISSING_CONFIG_MESSAGE = VALIDATION_COMMAND_OUTPUT.ESLINT_MISSING_CONFIG;
+var ESLINT_CONFIG_ERROR_MESSAGE = formatValidationConfigProblemMessage(
+  VALIDATION_STAGE_DISPLAY_NAMES.ESLINT,
+  "configuration error"
+);
+var VALIDATION_PATHS_NO_TARGETS_MESSAGE = formatValidationPathsNoTargetsSkipMessage(
+  VALIDATION_STAGE_DISPLAY_NAMES.ESLINT
+);
+async function lintCommand(options, deps = defaultLintCommandDeps) {
+  const { cwd, scope: scope2 = "full", files, fix, json, outputStreams, quiet, streamedPipelineOutput } = options;
   const startTime = Date.now();
   const tsDetection = deps.detectTypeScript(cwd);
   if (!tsDetection.present) {
     return {
       exitCode: 0,
-      output: quiet ? "" : TYPESCRIPT_ABSENT_MESSAGE3,
+      output: quiet ? "" : TYPESCRIPT_ABSENT_MESSAGE2,
       durationMs: Date.now() - startTime
     };
   }
@@ -21336,35 +21551,38 @@ async function lintCommand(options, deps = defaultLintCommandDependencies) {
   );
   const explicitMode = files !== void 0 && files.length > 0;
   const scopeConfig = resolveTypeScriptValidationScope({
-    projectRoot: cwd,
+    productDir: cwd,
     scope: scope2,
     paths: files,
     validationPathFilter,
-    markExplicitPathsAsValidationFilter: explicitMode,
-    bypassExplicitPathValidationFilter: true
+    markExplicitPathsAsValidationFilter: explicitMode
   });
   const explicitTargets = explicitMode ? filterExplicitTypeScriptScopeTargets({
     paths: files,
-    projectRoot: cwd,
+    productDir: cwd,
     validationPathFilter,
     scopeConfig: getTypeScriptScope(scope2, cwd),
     bypassValidationPathFilter: true
   }) : void 0;
-  const validatedFiles = explicitTargets?.every((target) => target.kind === EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.FILE) ? explicitTargets.map((target) => formatLintValidationOperand(toProjectRelativeValidationPath(cwd, target.path))) : void 0;
-  if (scopeConfig.filteredByValidationPathNoMatches) {
+  const validatedFiles = explicitTargets?.every((target) => target.kind === EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.FILE) ? explicitTargets.map((target) => formatLintValidationOperand(toProductRelativeValidationPath(cwd, target.path))) : void 0;
+  const noTargetsMessage = formatValidationScopeNoTargetsSkipMessage(
+    VALIDATION_STAGE_DISPLAY_NAMES.ESLINT,
+    scopeConfig
+  );
+  if (noTargetsMessage !== void 0) {
     return {
       exitCode: 0,
-      output: quiet ? "" : VALIDATION_PATHS_NO_TARGETS_MESSAGE,
+      output: quiet ? "" : noTargetsMessage,
       durationMs: Date.now() - startTime
     };
   }
-  const toolResult = await deps.discoverTool("eslint", { projectRoot: cwd });
+  const toolResult = await deps.discoverTool("eslint", { productDir: cwd, includeBundled: false });
   if (!toolResult.found) {
     const skipMessage = formatSkipMessage(VALIDATION_STAGE_DISPLAY_NAMES.ESLINT, toolResult);
     return { exitCode: 0, output: skipMessage, durationMs: Date.now() - startTime };
   }
   const context = {
-    projectRoot: cwd,
+    productDir: cwd,
     scope: scope2,
     scopeConfig,
     mode: fix ? "write" : "read",
@@ -21372,26 +21590,35 @@ async function lintCommand(options, deps = defaultLintCommandDependencies) {
     validatedFiles,
     validatedFileIgnorePatterns: void 0,
     isFileSpecificMode: Boolean(validatedFiles && validatedFiles.length > 0),
-    eslintConfigFile
+    eslintConfigFile,
+    toolPath: toolResult.location.path
   };
-  const result = await deps.validateESLint(context, void 0, outputStreams);
+  const result = await deps.validateESLint(
+    context,
+    void 0,
+    outputStreams ?? discardValidationSubprocessOutputStreams
+  );
   const durationMs = Date.now() - startTime;
-  return formatLintResult(result, quiet, durationMs);
+  return formatLintResult(result, quiet, durationMs, json, streamedPipelineOutput);
 }
 function formatLintValidationOperand(path4) {
   return path4.length === 0 ? "." : path4;
 }
-function formatLintResult(result, quiet, durationMs) {
+function formatLintResult(result, quiet, durationMs, json, streamedPipelineOutput) {
   if (result.skipped) {
     const output2 = quiet ? "" : VALIDATION_PATHS_NO_TARGETS_MESSAGE;
     return { exitCode: 0, output: output2, durationMs };
   }
   if (result.success) {
-    const output2 = quiet ? "" : VALIDATION_COMMAND_OUTPUT.ESLINT_SUCCESS;
-    return { exitCode: 0, output: output2, durationMs };
+    const output2 = quiet ? "" : [VALIDATION_COMMAND_OUTPUT.ESLINT_SUCCESS, result.output].filter(
+      (line) => line !== void 0 && line.length > 0
+    ).join("\n");
+    const terminalOutput2 = streamedValidationTerminalOutput(result.output, json, streamedPipelineOutput);
+    return { exitCode: 0, output: output2, terminalOutput: terminalOutput2, durationMs };
   }
-  const output = result.error ?? VALIDATION_COMMAND_OUTPUT.ESLINT_FAILURE;
-  return { exitCode: 1, output, durationMs };
+  const output = [result.output, result.error ?? VALIDATION_COMMAND_OUTPUT.ESLINT_FAILURE].filter((line) => line !== void 0 && line.length > 0).join("\n");
+  const terminalOutput = streamedValidationTerminalOutput(result.output, json, streamedPipelineOutput);
+  return { exitCode: 1, output, terminalOutput, durationMs };
 }
 
 // src/domains/validation/literal-problem-kind.ts
@@ -21443,7 +21670,7 @@ var GIT_DEFAULT_GLOBAL_IGNORE_PATH = {
   GIT_DIRECTORY: "git",
   IGNORE_FILE: "ignore"
 };
-var PATH_SEGMENT_SEPARATOR5 = "/";
+var PATH_SEGMENT_SEPARATOR4 = "/";
 var CURRENT_DIRECTORY_PREFIX2 = ".";
 var GIT_SCOPE_FAILURE_MESSAGE = "failed to read git scope";
 var GIT_MISSING_CONTEXT_MESSAGE = "missing git working tree";
@@ -21576,11 +21803,11 @@ function readGlobalExcludesPath(productDir) {
 }
 function parentPrefixes(path4) {
   const prefixes = [];
-  let index = path4.lastIndexOf(PATH_SEGMENT_SEPARATOR5);
+  let index = path4.lastIndexOf(PATH_SEGMENT_SEPARATOR4);
   while (index > 0) {
     const parent = path4.slice(0, index);
     prefixes.push(parent);
-    index = parent.lastIndexOf(PATH_SEGMENT_SEPARATOR5);
+    index = parent.lastIndexOf(PATH_SEGMENT_SEPARATOR4);
   }
   return prefixes;
 }
@@ -21635,7 +21862,7 @@ function createIgnoreSourceReader(productDir, config) {
     },
     hasIncludedDescendant(relativePath) {
       return descendantParents.has(
-        relativePath.endsWith(PATH_SEGMENT_SEPARATOR5) ? relativePath.slice(0, -1) : relativePath
+        relativePath.endsWith(PATH_SEGMENT_SEPARATOR4) ? relativePath.slice(0, -1) : relativePath
       );
     },
     appliedOverrides() {
@@ -22340,7 +22567,8 @@ async function validateLiteralReuse(input) {
   return {
     findings,
     indexedOccurrencesByFile,
-    filteredByValidationPathNoMatches: input.scopeConfig?.filteredByValidationPathNoMatches
+    filteredByValidationPathNoMatches: input.scopeConfig?.filteredByValidationPathNoMatches,
+    explicitPathNoMatches: input.scopeConfig?.explicitPathNoMatches
   };
 }
 async function readSafe(path4) {
@@ -22388,29 +22616,29 @@ var OUTPUT_MODE_NAME = {
   JSON: "json"
 };
 var OUTPUT_MODE_NAMES = Object.values(OUTPUT_MODE_NAME);
+var defaultLiteralCommandDeps = {
+  validateLiteralReuse
+};
 var LITERAL_EXIT_CODES = {
   OK: 0,
   FINDINGS: 1,
   CONFIG_ERROR: 2
 };
-var TYPESCRIPT_ABSENT_MESSAGE4 = formatTypeScriptAbsentSkipMessage(
-  VALIDATION_STAGE_DISPLAY_NAMES.LITERAL
-);
-var VALIDATION_PATHS_NO_TARGETS_MESSAGE2 = formatValidationPathsNoTargetsSkipMessage(
+var TYPESCRIPT_ABSENT_MESSAGE3 = formatTypeScriptAbsentSkipMessage(
   VALIDATION_STAGE_DISPLAY_NAMES.LITERAL
 );
 var LITERAL_DISABLED_MESSAGE = `\u23ED ${VALIDATION_SKIP_LABELS.VERB} ${VALIDATION_STAGE_DISPLAY_NAMES.LITERAL} (${VALIDATION_SKIP_LABELS.DISABLED_BY_PREFIX} validation.literal.enabled)`;
-var NO_PROBLEMS_MESSAGE = "Literal: \u2713 No problems";
+var NO_PROBLEMS_MESSAGE = formatValidationNoProblemsMessage(VALIDATION_STAGE_DISPLAY_NAMES.LITERAL);
 function formatNoProblemsOfKind(kind) {
   return `Literal: No problems of type ${kind}`;
 }
-async function literalCommand(options) {
+async function literalCommand(options, deps = defaultLiteralCommandDeps) {
   const start = Date.now();
   const tsDetection = detectTypeScript(options.cwd);
   if (!tsDetection.present) {
     return {
       exitCode: LITERAL_EXIT_CODES.OK,
-      output: options.quiet ? "" : TYPESCRIPT_ABSENT_MESSAGE4,
+      output: options.quiet ? "" : TYPESCRIPT_ABSENT_MESSAGE3,
       durationMs: Date.now() - start
     };
   }
@@ -22418,7 +22646,10 @@ async function literalCommand(options) {
   if (typeof resolved === "string") {
     return {
       exitCode: LITERAL_EXIT_CODES.CONFIG_ERROR,
-      output: `Literal: \u2717 config error \u2014 ${resolved}`,
+      output: `${formatValidationConfigProblemMessage(
+        VALIDATION_STAGE_DISPLAY_NAMES.LITERAL,
+        "configuration error"
+      )} \u2014 ${resolved}`,
       durationMs: Date.now() - start
     };
   }
@@ -22429,17 +22660,18 @@ async function literalCommand(options) {
       durationMs: Date.now() - start
     };
   }
-  const result = await validateLiteralReuse({
+  const result = await deps.validateLiteralReuse({
     productDir: options.cwd,
     explicitFiles: explicitLiteralPaths(options.files),
     config: resolved.literalConfig,
     pathConfig: resolved.pathConfig,
     scopeConfig: resolveExplicitLiteralTypeScriptScope(options, resolved.pathConfig)
   });
-  if (options.files !== void 0 && options.files.length > 0 && result.filteredByValidationPathNoMatches) {
+  const noTargetsMessage = explicitLiteralNoTargetsSkipMessage(options, result);
+  if (noTargetsMessage !== void 0) {
     return {
       exitCode: LITERAL_EXIT_CODES.OK,
-      output: options.quiet ? "" : VALIDATION_PATHS_NO_TARGETS_MESSAGE2,
+      output: options.quiet ? "" : noTargetsMessage,
       durationMs: Date.now() - start
     };
   }
@@ -22454,7 +22686,18 @@ async function literalCommand(options) {
   } else {
     output = formatLiteralCommandOutput(filteredFindings, options);
   }
-  return { exitCode, output, durationMs: Date.now() - start };
+  return {
+    exitCode,
+    output,
+    durationMs: Date.now() - start,
+    outputTarget: VALIDATION_OUTPUT_TARGET.STDOUT
+  };
+}
+function explicitLiteralNoTargetsSkipMessage(options, result) {
+  if (options.files === void 0 || options.files.length === 0) {
+    return void 0;
+  }
+  return formatValidationScopeNoTargetsSkipMessage(VALIDATION_STAGE_DISPLAY_NAMES.LITERAL, result);
 }
 async function resolveLiteralCommandConfig(options) {
   if (options.config !== void 0) {
@@ -22481,12 +22724,11 @@ function resolveExplicitLiteralTypeScriptScope(options, pathConfig) {
     return void 0;
   }
   return resolveTypeScriptValidationScope({
-    projectRoot: options.cwd,
+    productDir: options.cwd,
     scope: options.scope ?? VALIDATION_SCOPES.FULL,
     paths: options.files,
     validationPathFilter: pathConfig,
-    markExplicitPathsAsValidationFilter: true,
-    bypassExplicitPathValidationFilter: true
+    markExplicitPathsAsValidationFilter: true
   });
 }
 function explicitLiteralPaths(files) {
@@ -22630,8 +22872,8 @@ function formatTypeScriptExitCodeError(code) {
 }
 var TEMPORARY_TSCONFIG_COMPILER_OPTIONS = { noEmit: true };
 var TEMPORARY_TSCONFIG_DIR_PREFIX = "validate-ts-";
-async function createTemporaryTsconfigDir(projectRoot, deps) {
-  const parent = join39(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+async function createTemporaryTsconfigDir(productDir, deps) {
+  const parent = join39(productDir, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   deps.mkdirSync(parent, { recursive: true });
   return deps.mkdtemp(join39(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
 }
@@ -22639,13 +22881,13 @@ function buildTypeScriptArgs(context) {
   const { scope: scope2, configFile } = context;
   return scope2 === VALIDATION_SCOPES.FULL ? ["tsc", "--noEmit"] : ["tsc", "--project", configFile];
 }
-async function createFileSpecificTsconfig(scope2, files, projectRoot, deps = defaultTypeScriptDeps) {
-  const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
+async function createFileSpecificTsconfig(scope2, files, productDir, deps = defaultTypeScriptDeps) {
+  const tempDir = await createTemporaryTsconfigDir(productDir, deps);
   const configPath = join39(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
-  const absoluteFiles = files.map((file) => isAbsolute12(file) ? file : join39(projectRoot, file));
+  const absoluteFiles = files.map((file) => isAbsolute12(file) ? file : join39(productDir, file));
   const tempConfig = {
-    extends: join39(projectRoot, baseConfigFile),
+    extends: join39(productDir, baseConfigFile),
     files: absoluteFiles,
     include: [],
     exclude: [],
@@ -22655,16 +22897,16 @@ async function createFileSpecificTsconfig(scope2, files, projectRoot, deps = def
   const cleanup = createTemporaryTsconfigCleanup(tempDir, deps);
   return { configPath, tempDir, cleanup };
 }
-async function createScopeFilteredTsconfig(scope2, projectRoot, scopeConfig, deps = defaultTypeScriptDeps) {
-  const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
+async function createScopeFilteredTsconfig(scope2, productDir, scopeConfig, deps = defaultTypeScriptDeps) {
+  const tempDir = await createTemporaryTsconfigDir(productDir, deps);
   const configPath = join39(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
   const toTemporaryConfigPathPattern = (pattern) => {
-    const absolutePattern = isAbsolute12(pattern) ? pattern : join39(projectRoot, pattern);
+    const absolutePattern = isAbsolute12(pattern) ? pattern : join39(productDir, pattern);
     return relative10(tempDir, absolutePattern);
   };
   const tempConfig = {
-    extends: join39(projectRoot, baseConfigFile),
+    extends: join39(productDir, baseConfigFile),
     include: scopeConfigToTemporaryIncludes(scopeConfig).map(toTemporaryConfigPathPattern),
     exclude: scopeConfig.excludePatterns.map(toTemporaryConfigPathPattern),
     compilerOptions: TEMPORARY_TSCONFIG_COMPILER_OPTIONS
@@ -22693,19 +22935,20 @@ function createTemporaryTsconfigCleanup(tempDir, deps) {
   };
 }
 async function validateTypeScript(context, options = {}) {
-  const { scope: scope2, projectRoot, files, scopeConfig } = context;
+  const { scope: scope2, productDir, files, scopeConfig } = context;
   const {
     runner = defaultTypeScriptProcessRunner,
     deps = defaultTypeScriptDeps,
+    toolPath,
     outputStreams = defaultValidationSubprocessOutputStreams
   } = options;
   const configFile = TSCONFIG_FILES[scope2];
   if (files && files.length > 0) {
-    const { configPath, cleanup } = await createFileSpecificTsconfig(scope2, files, projectRoot, deps);
+    const { configPath, cleanup } = await createFileSpecificTsconfig(scope2, files, productDir, deps);
     try {
       return await runTypeScriptInvocation(
-        projectRoot,
-        resolveProjectTscInvocation(projectRoot, deps, ["--project", configPath]),
+        productDir,
+        resolveTscInvocation(productDir, deps, ["--project", configPath], toolPath),
         runner,
         outputStreams,
         cleanup
@@ -22722,64 +22965,89 @@ async function validateTypeScript(context, options = {}) {
     if (scopeConfig.filePatterns.length === 0 && scopeConfig.directories.length === 0) {
       return { success: true, skipped: true };
     }
-    const { configPath, cleanup } = await createScopeFilteredTsconfig(scope2, projectRoot, scopeConfig, deps);
+    const { configPath, cleanup } = await createScopeFilteredTsconfig(scope2, productDir, scopeConfig, deps);
     return runTypeScriptInvocation(
-      projectRoot,
-      resolveProjectTscInvocation(projectRoot, deps, ["--project", configPath]),
+      productDir,
+      resolveTscInvocation(productDir, deps, ["--project", configPath], toolPath),
       runner,
       outputStreams,
       cleanup
     );
   }
   return runTypeScriptInvocation(
-    projectRoot,
-    resolveProjectTscInvocation(projectRoot, deps, buildTypeScriptArgs({ scope: scope2, configFile }).slice(1)),
+    productDir,
+    resolveTscInvocation(productDir, deps, buildTypeScriptArgs({ scope: scope2, configFile }).slice(1), toolPath),
     runner,
     outputStreams
   );
 }
-function resolveProjectTscInvocation(projectRoot, deps, tscArgs) {
-  const tscBin = join39(projectRoot, "node_modules", ".bin", "tsc");
+function resolveTscInvocation(productDir, deps, tscArgs, toolPath) {
+  if (toolPath !== void 0) {
+    return { tool: toolPath, args: tscArgs };
+  }
+  const tscBin = join39(productDir, "node_modules", ".bin", "tsc");
   const tool = deps.existsSync(tscBin) ? tscBin : "npx";
   return {
     tool,
     args: tool === "npx" ? ["tsc", ...tscArgs] : tscArgs
   };
 }
-function runTypeScriptInvocation(projectRoot, invocation, runner, outputStreams, cleanup = () => {
+function runTypeScriptInvocation(productDir, invocation, runner, outputStreams, cleanup = () => {
 }) {
   return new Promise((resolve17) => {
     const tscProcess = spawnManagedSubprocess(runner, invocation.tool, invocation.args, {
-      cwd: projectRoot
+      cwd: productDir
     });
+    const chunks = [];
+    const capture = (chunk) => {
+      chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString());
+    };
+    tscProcess.stdout?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
+    tscProcess.stderr?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
     forwardValidationSubprocessOutput(tscProcess, outputStreams);
     tscProcess.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
       cleanup();
+      const output = chunks.join("");
       if (code === 0) {
-        resolve17({ success: true, skipped: false });
+        resolve17({ success: true, skipped: false, output });
       } else {
-        resolve17({ success: false, error: formatTypeScriptExitCodeError(code) });
+        resolve17({ success: false, output, error: formatTypeScriptExitCodeError(code) });
       }
     });
     tscProcess.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
       cleanup();
-      resolve17({ success: false, error: error.message });
+      resolve17({ success: false, output: chunks.join(""), error: error.message });
     });
   });
 }
 
 // src/commands/validation/typescript.ts
+var defaultTypeScriptCommandDeps = {
+  detectTypeScript,
+  discoverTool,
+  validateTypeScript
+};
 var TYPESCRIPT_VALIDATION_MESSAGES = {
   ABSENT: formatTypeScriptAbsentSkipMessage(VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT),
-  CONFIG_ERROR: `${VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT}: \u2717 config error`,
+  CONFIG_ERROR: formatValidationConfigProblemMessage(
+    VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT,
+    "configuration error"
+  ),
   NO_VALIDATION_PATH_TARGETS: formatValidationPathsNoTargetsSkipMessage(VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT),
+  NO_EXPLICIT_PATH_TARGETS: formatExplicitPathsNoTargetsSkipMessage(VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT),
   SUCCESS: VALIDATION_COMMAND_OUTPUT.TYPESCRIPT_SUCCESS,
   TOOL_LABEL: VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT
 };
-async function typescriptCommand(options) {
-  const { cwd, scope: scope2 = "full", files, outputStreams, quiet } = options;
+var TYPESCRIPT_TOOL_DISCOVERY = {
+  TOOL: "typescript",
+  EXECUTABLE_NAME: "tsc",
+  BUNDLED_EXECUTABLE: "typescript/bin/tsc",
+  PRODUCT_EXECUTABLE_SEGMENTS: ["node_modules", ".bin", "tsc"]
+};
+async function typescriptCommand(options, deps = defaultTypeScriptCommandDeps) {
+  const { cwd, scope: scope2 = "full", files, json, outputStreams, quiet, streamedPipelineOutput } = options;
   const startTime = Date.now();
-  const tsDetection = detectTypeScript(cwd);
+  const tsDetection = deps.detectTypeScript(cwd);
   if (!tsDetection.present) {
     return {
       exitCode: 0,
@@ -22797,53 +23065,69 @@ async function typescriptCommand(options) {
   }
   const validationConfig = loaded.value[validationConfigDescriptor.section];
   const scopeConfig = resolveTypeScriptValidationScope({
-    projectRoot: cwd,
+    productDir: cwd,
     scope: scope2,
     paths: files,
     validationPathFilter: validationPathFilterForTool(
       validationConfig.paths,
       VALIDATION_PATH_TOOL_SUBSECTIONS.TYPESCRIPT
     ),
-    markExplicitPathsAsValidationFilter: true,
-    bypassExplicitPathValidationFilter: true
+    markExplicitPathsAsValidationFilter: true
   });
-  if (scopeConfig.filteredByValidationPathNoMatches) {
+  const noTargetsMessage = formatValidationScopeNoTargetsSkipMessage(
+    VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT,
+    scopeConfig
+  );
+  if (noTargetsMessage !== void 0) {
     return {
       exitCode: 0,
-      output: quiet ? "" : TYPESCRIPT_VALIDATION_MESSAGES.NO_VALIDATION_PATH_TARGETS,
+      output: quiet ? "" : noTargetsMessage,
       durationMs: Date.now() - startTime
     };
   }
-  const toolResult = await discoverTool("typescript", { projectRoot: cwd });
+  const toolResult = await deps.discoverTool(TYPESCRIPT_TOOL_DISCOVERY.TOOL, {
+    productDir: cwd,
+    executableName: TYPESCRIPT_TOOL_DISCOVERY.EXECUTABLE_NAME,
+    bundledExecutable: TYPESCRIPT_TOOL_DISCOVERY.BUNDLED_EXECUTABLE,
+    priority: TOOL_DISCOVERY_PRIORITY.PRODUCT_FIRST
+  });
   if (!toolResult.found) {
     const skipMessage = formatSkipMessage(VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT, toolResult);
     return { exitCode: 0, output: skipMessage, durationMs: Date.now() - startTime };
   }
-  const result = await validateTypeScript({
+  const result = await deps.validateTypeScript({
     scope: scope2,
-    projectRoot: cwd,
+    productDir: cwd,
     scopeConfig
   }, {
-    outputStreams
+    toolPath: toolResult.location.path,
+    outputStreams: outputStreams ?? discardValidationSubprocessOutputStreams
   });
   const durationMs = Date.now() - startTime;
-  return formatTypeScriptResult(result, quiet, durationMs);
+  return formatTypeScriptResult(result, quiet, durationMs, json, streamedPipelineOutput);
 }
-function formatTypeScriptResult(result, quiet, durationMs) {
+function formatTypeScriptResult(result, quiet, durationMs, json, streamedPipelineOutput) {
   if (result.skipped) {
     const output2 = quiet ? "" : TYPESCRIPT_VALIDATION_MESSAGES.NO_VALIDATION_PATH_TARGETS;
     return { exitCode: 0, output: output2, durationMs };
   }
   if (result.success) {
-    const output2 = quiet ? "" : TYPESCRIPT_VALIDATION_MESSAGES.SUCCESS;
-    return { exitCode: 0, output: output2, durationMs };
+    const output2 = quiet ? "" : [TYPESCRIPT_VALIDATION_MESSAGES.SUCCESS, result.output].filter((line) => line !== void 0 && line.length > 0).join("\n");
+    const terminalOutput2 = streamedValidationTerminalOutput(result.output, json, streamedPipelineOutput);
+    return { exitCode: 0, output: output2, terminalOutput: terminalOutput2, durationMs };
   }
-  const output = result.error ?? VALIDATION_COMMAND_OUTPUT.TYPESCRIPT_FAILURE;
-  return { exitCode: 1, output, durationMs };
+  const output = [result.output, result.error ?? VALIDATION_COMMAND_OUTPUT.TYPESCRIPT_FAILURE].filter((line) => line !== void 0 && line.length > 0).join("\n");
+  const terminalOutput = streamedValidationTerminalOutput(result.output, json, streamedPipelineOutput);
+  return { exitCode: 1, output, terminalOutput, durationMs };
 }
 
 // src/validation/languages/typescript.ts
 var TYPESCRIPT_LANGUAGE_NAME = "typescript";
+var SKIP_CIRCULAR_REASON = "skip-circular";
+var SKIP_KNIP_REASON = "skip-knip";
+var SKIP_LINT_REASON = "skip-lint";
+var SKIP_TYPESCRIPT_REASON = "skip-typescript";
+var SKIP_LITERAL_REASON = "skip-literal";
 var TYPESCRIPT_VALIDATION_CONCERN = {
   LINT: "lint",
   TYPE_CHECK: "type-check",
@@ -22852,14 +23136,60 @@ var TYPESCRIPT_VALIDATION_CONCERN = {
   LITERAL_REUSE: "literal-reuse",
   UNUSED_CODE: "unused-code"
 };
+var TYPESCRIPT_VALIDATION_STAGE_BY_CONCERN = {
+  [TYPESCRIPT_VALIDATION_CONCERN.LINT]: VALIDATION_STAGE_DISPLAY_NAMES.ESLINT,
+  [TYPESCRIPT_VALIDATION_CONCERN.TYPE_CHECK]: VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT,
+  [TYPESCRIPT_VALIDATION_CONCERN.AST_ENFORCEMENT]: VALIDATION_STAGE_DISPLAY_NAMES.ESLINT,
+  [TYPESCRIPT_VALIDATION_CONCERN.CIRCULAR_DEPS]: VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR,
+  [TYPESCRIPT_VALIDATION_CONCERN.LITERAL_REUSE]: VALIDATION_STAGE_DISPLAY_NAMES.LITERAL,
+  [TYPESCRIPT_VALIDATION_CONCERN.UNUSED_CODE]: VALIDATION_STAGE_DISPLAY_NAMES.KNIP
+};
+var TYPESCRIPT_VALIDATION_STAGE_PARTICIPATION = {
+  [VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR]: {
+    default: VALIDATION_STAGE_PARTICIPATION.RUN,
+    skipReason: SKIP_CIRCULAR_REASON,
+    override: {
+      flag: "--skip-circular",
+      description: "Skip circular dependency detection for this validation all run"
+    }
+  },
+  [VALIDATION_STAGE_DISPLAY_NAMES.KNIP]: {
+    default: VALIDATION_STAGE_PARTICIPATION.RUN,
+    skipReason: SKIP_KNIP_REASON,
+    override: {
+      flag: "--skip-knip",
+      description: "Skip unused-code detection for this validation all run"
+    }
+  },
+  [VALIDATION_STAGE_DISPLAY_NAMES.ESLINT]: {
+    default: VALIDATION_STAGE_PARTICIPATION.RUN,
+    skipReason: SKIP_LINT_REASON,
+    override: {
+      flag: "--skip-lint",
+      description: "Skip ESLint validation for this validation all run"
+    }
+  },
+  [VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT]: {
+    default: VALIDATION_STAGE_PARTICIPATION.RUN,
+    skipReason: SKIP_TYPESCRIPT_REASON,
+    override: {
+      flag: "--skip-typescript",
+      description: "Skip TypeScript validation for this validation all run"
+    }
+  },
+  [VALIDATION_STAGE_DISPLAY_NAMES.LITERAL]: {
+    default: VALIDATION_STAGE_PARTICIPATION.RUN,
+    skipReason: SKIP_LITERAL_REASON,
+    override: {
+      flag: "--skip-literal",
+      description: "Skip literal reuse detection for this validation all run"
+    }
+  }
+};
 var defaultKnipStageDeps = {
   knipCommand
 };
 async function runCircularStage(context) {
-  if (context.skipCircular) {
-    const skipOutput = context.json ? CIRCULAR_SKIP_JSON_OUTPUT : CIRCULAR_SKIP_OUTPUT;
-    return { exitCode: 0, output: context.quiet ? "" : skipOutput };
-  }
   return circularCommand({
     cwd: context.cwd,
     scope: context.scope,
@@ -22869,10 +23199,6 @@ async function runCircularStage(context) {
   });
 }
 async function runLiteralStage(context) {
-  if (context.skipLiteral) {
-    const skipOutput = context.json ? LITERAL_SKIP_JSON_OUTPUT : LITERAL_SKIP_OUTPUT;
-    return { exitCode: 0, output: context.quiet ? "" : skipOutput };
-  }
   return literalCommand({
     cwd: context.cwd,
     scope: context.scope,
@@ -22887,27 +23213,32 @@ async function runKnipStage(context, deps = defaultKnipStageDeps) {
     scope: context.scope,
     files: context.files,
     quiet: context.quiet,
-    json: context.json
+    json: context.json,
+    streamedPipelineOutput: true,
+    outputStreams: context.outputStreams
   });
 }
 var typescriptValidationLanguage = {
   name: TYPESCRIPT_LANGUAGE_NAME,
   concerns: Object.values(TYPESCRIPT_VALIDATION_CONCERN),
+  stageByConcern: TYPESCRIPT_VALIDATION_STAGE_BY_CONCERN,
   stages: [
     {
       name: VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR,
       failsPipeline: true,
+      participation: TYPESCRIPT_VALIDATION_STAGE_PARTICIPATION[VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR],
       run: runCircularStage
     },
     {
       name: VALIDATION_STAGE_DISPLAY_NAMES.KNIP,
-      // Knip is informational: unused-code findings never fail the pipeline.
-      failsPipeline: false,
+      failsPipeline: true,
+      participation: TYPESCRIPT_VALIDATION_STAGE_PARTICIPATION[VALIDATION_STAGE_DISPLAY_NAMES.KNIP],
       run: runKnipStage
     },
     {
       name: VALIDATION_STAGE_DISPLAY_NAMES.ESLINT,
       failsPipeline: true,
+      participation: TYPESCRIPT_VALIDATION_STAGE_PARTICIPATION[VALIDATION_STAGE_DISPLAY_NAMES.ESLINT],
       run: (context) => lintCommand({
         cwd: context.cwd,
         scope: context.scope,
@@ -22915,32 +23246,46 @@ var typescriptValidationLanguage = {
         fix: context.fix,
         quiet: context.quiet,
         json: context.json,
+        streamedPipelineOutput: true,
         outputStreams: context.outputStreams
       })
     },
     {
       name: VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT,
       failsPipeline: true,
+      participation: TYPESCRIPT_VALIDATION_STAGE_PARTICIPATION[VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT],
       run: (context) => typescriptCommand({
         cwd: context.cwd,
         scope: context.scope,
         files: context.files,
         quiet: context.quiet,
         json: context.json,
+        streamedPipelineOutput: true,
         outputStreams: context.outputStreams
       })
     },
     {
       name: VALIDATION_STAGE_DISPLAY_NAMES.LITERAL,
       failsPipeline: true,
+      participation: TYPESCRIPT_VALIDATION_STAGE_PARTICIPATION[VALIDATION_STAGE_DISPLAY_NAMES.LITERAL],
       run: runLiteralStage
     }
   ]
 };
 
 // src/validation/registry.ts
+var VALIDATION_STAGE_PARTICIPATION_POLICIES = {
+  ...TYPESCRIPT_VALIDATION_STAGE_PARTICIPATION,
+  ...MARKDOWN_VALIDATION_STAGE_PARTICIPATION,
+  ...FORMATTING_VALIDATION_STAGE_PARTICIPATION
+};
+var VALIDATION_REGISTRY_LANGUAGES = [
+  typescriptValidationLanguage,
+  markdownValidationLanguage,
+  formattingValidationLanguage
+];
 var validationRegistry = {
-  languages: [typescriptValidationLanguage, markdownValidationLanguage, formattingValidationLanguage]
+  languages: VALIDATION_REGISTRY_LANGUAGES
 };
 function composeValidationPipelineStages(languages) {
   return languages.flatMap((language) => language.stages);
@@ -22974,10 +23319,17 @@ function formatSummary(options) {
 }
 
 // src/commands/validation/all.ts
-function formatStepWithTiming(stepNumber, totalSteps, result, quiet) {
-  if (quiet || !result.output) return "";
+function formatStepWithTiming(stepNumber, totalSteps, stageName, result, quiet) {
+  const output = result.terminalOutput ?? result.output;
+  if (quiet) return "";
+  if (result.terminalOutput === VALIDATION_STREAMED_TERMINAL_OUTPUT) {
+    const verdict = result.exitCode === 0 ? VALIDATION_SYMBOLS.SUCCESS : VALIDATION_SYMBOLS.FAILURE;
+    const timing2 = result.durationMs === void 0 ? "" : ` (${formatDuration(result.durationMs)})`;
+    return `[${stepNumber}/${totalSteps}] ${stageName}: ${verdict} ${VALIDATION_STREAMED_STAGE_RESULT}${timing2}`;
+  }
+  if (!output) return "";
   const timing = result.durationMs === void 0 ? "" : ` (${formatDuration(result.durationMs)})`;
-  return `[${stepNumber}/${totalSteps}] ${result.output}${timing}`;
+  return `[${stepNumber}/${totalSteps}] ${output}${timing}`;
 }
 function parseStageOutput(output) {
   if (output.length === 0) return null;
@@ -23011,12 +23363,39 @@ function recordStageResult(options) {
     });
     return;
   }
-  const stepOutput = formatStepWithTiming(stepNumber, totalSteps, result, quiet);
+  const stepOutput = formatStepWithTiming(stepNumber, totalSteps, stage.name, result, quiet);
   if (stepOutput) {
     outputs.push(stepOutput);
     writeOutput5?.(stepOutput);
   }
 }
+function resolveStageParticipation(stage, participationOverrides) {
+  const override = stage.participation.override;
+  if (participationOverrides.has(override.flag)) {
+    const participation = stage.participation.default === VALIDATION_STAGE_PARTICIPATION.RUN ? VALIDATION_STAGE_PARTICIPATION.SKIP : VALIDATION_STAGE_PARTICIPATION.RUN;
+    return {
+      participation,
+      reason: participation === VALIDATION_STAGE_PARTICIPATION.SKIP ? stage.participation.skipReason : void 0,
+      flag: override.flag
+    };
+  }
+  return {
+    participation: stage.participation.default,
+    reason: stage.participation.default === VALIDATION_STAGE_PARTICIPATION.SKIP ? stage.participation.skipReason : void 0
+  };
+}
+function skippedStageResult(stage, participation, json, durationMs) {
+  const reason = participation.reason;
+  if (reason === void 0) {
+    throw new Error(`validation stage ${stage.name} skipped without a configured reason`);
+  }
+  return {
+    exitCode: 0,
+    output: json ? formatValidationStageSkipJsonOutput(reason, durationMs) : formatValidationStageSkipOutput(stage.name, participation.flag ?? reason),
+    structuredOutput: json,
+    durationMs
+  };
+}
 function createCapturedSubprocessOutput() {
   const stdout = [];
   const stderr = [];
@@ -23037,14 +23416,72 @@ function createCaptureStream(chunks) {
     }
   };
 }
+function resolveFullPipelineStages(validationStages, dependencyStages) {
+  return validationStages ?? dependencyStages ?? validationPipelineStages;
+}
+async function executeValidationStages(options) {
+  let hasFailure = false;
+  for (const [index, stage] of options.stages.entries()) {
+    const stepNumber = index + 1;
+    const execution = await executeValidationStage(stage, options);
+    recordStageResult({
+      json: options.json,
+      stepNumber,
+      totalSteps: options.stages.length,
+      stage,
+      result: execution.result,
+      quiet: options.quiet,
+      outputs: options.outputs,
+      jsonSteps: options.jsonSteps,
+      subprocessOutput: execution.subprocessOutput,
+      writeOutput: options.writeOutput
+    });
+    notifyStageCompletion(stage, execution.result, stepNumber, options);
+    hasFailure ||= stage.failsPipeline && execution.result.exitCode !== 0;
+  }
+  return hasFailure;
+}
+async function executeValidationStage(stage, options) {
+  const subprocessOutput = options.json ? createCapturedSubprocessOutput() : void 0;
+  const stageStartTime = options.now();
+  const participation = resolveStageParticipation(stage, options.participationOverrides);
+  const stageResult = participation.participation === VALIDATION_STAGE_PARTICIPATION.RUN ? await stage.run({
+    ...options.context,
+    outputStreams: subprocessOutput?.streams ?? options.outputStreams
+  }) : skippedStageResult(stage, participation, options.json, options.now() - stageStartTime);
+  const result = stageResult.durationMs === void 0 ? { ...stageResult, durationMs: options.now() - stageStartTime } : stageResult;
+  return { result, subprocessOutput };
+}
+function notifyStageCompletion(stage, result, stepNumber, options) {
+  if (options.json || options.onStageComplete === void 0) return;
+  const output = formatStepWithTiming(stepNumber, options.stages.length, stage.name, result, options.quiet);
+  if (output.length === 0) return;
+  options.onStageComplete({
+    stepNumber,
+    totalSteps: options.stages.length,
+    stageName: stage.name,
+    result,
+    output
+  });
+}
 async function allCommand(options, deps = {}) {
-  const { cwd, scope: scope2, files, fix, quiet = false, json, skipCircular = false, skipLiteral = false } = options;
-  const stages = deps.stages ?? validationPipelineStages;
+  const {
+    cwd,
+    scope: scope2,
+    files,
+    fix,
+    quiet = false,
+    json,
+    validationStages,
+    participationOverrides = [],
+    onStageComplete,
+    outputStreams
+  } = options;
+  const stages = resolveFullPipelineStages(validationStages, deps.stages);
   const now = deps.now ?? Date.now;
   const startTime = now();
   const outputs = [];
   const jsonSteps = [];
-  let hasFailure = false;
   const context = {
     cwd,
     scope: scope2,
@@ -23052,28 +23489,21 @@ async function allCommand(options, deps = {}) {
     fix,
     quiet: json === true ? false : quiet,
     json,
-    skipCircular,
-    skipLiteral
+    outputStreams
   };
-  let stepNumber = 0;
-  for (const stage of stages) {
-    stepNumber += 1;
-    const subprocessOutput = json === true ? createCapturedSubprocessOutput() : void 0;
-    const result = await stage.run({ ...context, outputStreams: subprocessOutput?.streams });
-    recordStageResult({
-      json: json === true,
-      stepNumber,
-      totalSteps: stages.length,
-      stage,
-      result,
-      quiet,
-      outputs,
-      jsonSteps,
-      subprocessOutput,
-      writeOutput: deps.writeOutput
-    });
-    if (stage.failsPipeline && result.exitCode !== 0) hasFailure = true;
-  }
+  const hasFailure = await executeValidationStages({
+    stages,
+    context,
+    participationOverrides: new Set(participationOverrides),
+    json: json === true,
+    quiet,
+    outputs,
+    jsonSteps,
+    onStageComplete,
+    outputStreams,
+    writeOutput: deps.writeOutput,
+    now
+  });
   const totalDurationMs = now() - startTime;
   if (json === true) {
     const jsonOutput = {
@@ -23086,18 +23516,26 @@ async function allCommand(options, deps = {}) {
     return {
       exitCode: hasFailure ? 1 : 0,
       output,
+      outputTarget: VALIDATION_OUTPUT_TARGET.STDOUT,
       durationMs: totalDurationMs
     };
   }
+  let terminalOutput;
   if (!quiet) {
     const summary = formatSummary({ success: !hasFailure, totalDurationMs });
-    outputs.push("", summary);
     deps.writeOutput?.(`
 ${summary}`);
+    if (onStageComplete !== void 0) {
+      terminalOutput = `
+${summary}`;
+    } else {
+      outputs.push("", summary);
+    }
   }
   return {
     exitCode: hasFailure ? 1 : 0,
     output: outputs.join("\n"),
+    terminalOutput,
     durationMs: totalDurationMs
   };
 }
@@ -23117,36 +23555,44 @@ var validationCliDefinition = {
     typescript: {
       commandName: "typescript",
       alias: "ts",
-      description: "Run TypeScript type checking"
+      description: "Run TypeScript type checking",
+      options: { scope: true, json: false }
     },
     lint: {
       commandName: "lint",
-      description: "Run ESLint"
+      description: "Run ESLint",
+      options: { scope: true, json: false }
     },
     circular: {
       commandName: "circular",
-      description: "Check for circular dependencies"
+      description: "Check for circular dependencies",
+      options: { scope: true, json: false }
     },
     knip: {
       commandName: "knip",
-      description: "Detect unused code"
+      description: "Detect unused code",
+      options: { scope: true, json: false }
     },
     literal: {
       commandName: "literal",
-      description: "Detect cross-file literal reuse between source and tests"
+      description: "Detect cross-file literal reuse between source and tests",
+      options: { scope: true, json: true }
     },
     markdown: {
       commandName: "markdown",
       alias: "md",
-      description: "Validate markdown link integrity and structure"
+      description: "Validate markdown link integrity and structure",
+      options: { scope: false, json: false }
     },
     format: {
       commandName: "format",
-      description: "Check code formatting with dprint"
+      description: "Check code formatting with dprint",
+      options: { scope: false, json: false }
     },
     all: {
       commandName: "all",
-      description: "Run all validations"
+      description: "Run all validations",
+      options: { scope: true, json: true }
     }
   },
   commanderHelpOperands: {
@@ -23196,16 +23642,25 @@ var literalValidationCliOptions = {
     description: "Print grouped problem details"
   }
 };
-var allValidationCliOptions = {
-  skipCircular: {
-    flag: "--skip-circular",
-    description: "Skip circular dependency detection for this validation all run"
+var validationCommonCliOptions = {
+  scope: {
+    flag: "--scope"
   },
-  skipLiteral: {
-    flag: "--skip-literal",
-    description: "Skip literal reuse detection for this validation all run"
+  quiet: {
+    flag: "--quiet"
+  },
+  json: {
+    flag: "--json"
   }
 };
+var validationAllBuiltInCliOptions = {
+  fix: {
+    flag: "--fix"
+  }
+};
+function isValidationLiteralProblemKind(value) {
+  return validationLiteralProblemKinds.some((kind) => kind === value);
+}
 var validationSubcommandOperands = Object.values(validationCliDefinition.subcommands).flatMap(
   (subcommand) => {
     const operands = [subcommand.commandName];
@@ -23218,6 +23673,7 @@ var validationKnownOperands = /* @__PURE__ */ new Set([
   ...Object.values(validationCliDefinition.commanderHelpOperands)
 ]);
 var validationOptionPrefix = validationCliDefinition.commanderHelpOperands.longFlag.slice(0, 2);
+var validationShortOptionPrefix = validationCliDefinition.commanderHelpOperands.shortFlag.slice(0, 1);
 
 // src/validation/literal/allowlist-existing.ts
 import { randomBytes as randomBytes3 } from "crypto";
@@ -23304,27 +23760,86 @@ function serializeWithUpdatedInclude(target, include) {
 }
 
 // src/interfaces/cli/validation.ts
-var defaultValidationCliDependencies = {
-  allCommand,
-  allowlistExisting,
-  circularCommand,
-  formattingCommand,
-  knipCommand,
-  lintCommand,
-  literalCommand,
-  markdownCommand,
-  typescriptCommand
+var LONG_OPTION_PREFIX = "--";
+var OPTION_PROPERTY_WORD_SEPARATOR_PATTERN = /-([a-z0-9])/g;
+var VALIDATION_ALL_OVERRIDE_FLAG_PATTERN = /^--(?!no-)[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
+var validationAllReservedOverrideFlags = /* @__PURE__ */ new Set([
+  ...Object.values(validationCommonCliOptions).map((option) => option.flag),
+  ...Object.values(validationAllBuiltInCliOptions).map((option) => option.flag),
+  validationCliDefinition.commanderHelpOperands.longFlag
+]);
+function validationOptionPropertyName(flag) {
+  return flag.slice(LONG_OPTION_PREFIX.length).replace(OPTION_PROPERTY_WORD_SEPARATOR_PATTERN, (_match, character) => character.toUpperCase());
+}
+function deriveValidationAllOverrideCliOptions(stages) {
+  const optionPropertyNames = /* @__PURE__ */ new Set();
+  return stages.flatMap((stage) => {
+    validateStageParticipationMetadata(stage);
+    const override = stage.participation.override;
+    const optionPropertyName = validationOptionPropertyName(override.flag);
+    if (optionPropertyNames.has(optionPropertyName)) {
+      throw new Error(`duplicate validation all override option property: ${optionPropertyName}`);
+    }
+    optionPropertyNames.add(optionPropertyName);
+    return [{
+      stageName: stage.name,
+      flag: override.flag,
+      description: override.description,
+      reason: stage.participation.skipReason,
+      optionPropertyName
+    }];
+  });
+}
+function validateStageParticipationMetadata(stage) {
+  if (stage.participation.skipReason.length === 0) {
+    throw new Error(`validation stage ${stage.name} skip participation requires a reason`);
+  }
+  const override = stage.participation.override;
+  if (!VALIDATION_ALL_OVERRIDE_FLAG_PATTERN.test(override.flag)) {
+    throw new Error(`validation stage ${stage.name} override flag must be a bare long kebab-case boolean flag`);
+  }
+  if (validationAllReservedOverrideFlags.has(override.flag)) {
+    throw new Error(`validation stage ${stage.name} override flag collides with a validation all built-in option`);
+  }
+  if (override.description.length === 0) {
+    throw new Error(`validation stage ${stage.name} override flag requires a description`);
+  }
+}
+var validationAllOverrideCliOptions = deriveValidationAllOverrideCliOptions(validationPipelineStages);
+var defaultValidationCommandHandlers = {
+  typescript: typescriptCommand,
+  lint: lintCommand,
+  circular: circularCommand,
+  knip: knipCommand,
+  literal: literalCommand,
+  markdown: markdownCommand,
+  format: formattingCommand,
+  all: allCommand
 };
 function emitValidationResult(result, io) {
-  if (result.output.length > 0) {
-    io.writeStdout(`${result.output}
+  const output = result.terminalOutput ?? result.output;
+  if (output.length > 0) {
+    const outputTarget = result.outputTarget ?? (result.exitCode === 0 ? VALIDATION_OUTPUT_TARGET.STDOUT : VALIDATION_OUTPUT_TARGET.STDERR);
+    const writeOutput5 = outputTarget === VALIDATION_OUTPUT_TARGET.STDOUT ? io.writeStdout : io.writeStderr;
+    writeOutput5(`${output}
 `);
   }
   return io.exit(result.exitCode);
 }
-function addCommonOptions(cmd) {
+function addCommonOptions(cmd, definition) {
   const { pathOperands } = validationCliDefinition;
-  return cmd.argument(pathOperands.optionalVariadic, pathOperands.description).option("--scope <scope>", "Validation scope (full|production)", "full").option("--quiet", "Suppress progress output").option("--json", "Output results as JSON");
+  let configured = cmd.argument(pathOperands.optionalVariadic, pathOperands.description).option(validationCommonCliOptions.quiet.flag, "Suppress progress output");
+  if (definition.options.scope) {
+    configured = configured.option(
+      `${validationCommonCliOptions.scope.flag} <scope>`,
+      "Validation scope (full|production)",
+      "full"
+    );
+  }
+  if (definition.options.json) {
+    configured = configured.option(validationCommonCliOptions.json.flag, "Output results as JSON");
+  }
+  return configured;
 }
 async function normalizeProductPathOperand(productDir, effectiveInvocationDir, operand) {
   const resolvedProductDir = await canonicalPathThroughExistingAncestor(resolve16(productDir));
@@ -23384,57 +23899,65 @@ function addValidationSubcommand(validationCmd, definition) {
   }
   return subcommand;
 }
-function registerValidationCommands(validationCmd, invocation, deps) {
+function selectedValidationAllOverrides(options, allOverrideCliOptions = validationAllOverrideCliOptions) {
+  return allOverrideCliOptions.filter((option) => options[option.optionPropertyName] === true).map((option) => option.flag);
+}
+function registerValidationCommands(validationCmd, invocation, options = {}) {
   const { subcommands } = validationCliDefinition;
-  const tsCmd = addValidationSubcommand(validationCmd, subcommands.typescript).action(async (pathOperands, options) => {
+  const commandHandlers = {
+    ...defaultValidationCommandHandlers,
+    ...options.commandHandlers
+  };
+  const runAllowlistExisting = options.allowlistExisting ?? allowlistExisting;
+  const validationStages = options.validationStages ?? validationPipelineStages;
+  const allOverrideCliOptions = deriveValidationAllOverrideCliOptions(
+    validationStages
+  );
+  const tsCmd = addValidationSubcommand(validationCmd, subcommands.typescript).action(async (pathOperands, options2) => {
     const paths = await resolveValidationPaths(invocation, pathOperands);
-    const result = await deps.typescriptCommand({
+    const result = await commandHandlers.typescript({
       cwd: paths.productDir,
-      scope: options.scope,
+      scope: options2.scope,
       files: paths.files,
-      quiet: options.quiet,
-      json: options.json
+      quiet: options2.quiet
     });
     emitValidationResult(result, invocation.io);
   });
-  addCommonOptions(tsCmd);
-  const lintCmd = addValidationSubcommand(validationCmd, subcommands.lint).option("--fix", "Auto-fix issues").action(async (pathOperands, options) => {
+  addCommonOptions(tsCmd, subcommands.typescript);
+  const lintCmd = addValidationSubcommand(validationCmd, subcommands.lint).option("--fix", "Auto-fix issues").action(async (pathOperands, options2) => {
     const paths = await resolveValidationPaths(invocation, pathOperands);
-    const result = await deps.lintCommand({
+    const result = await commandHandlers.lint({
       cwd: paths.productDir,
-      scope: options.scope,
+      scope: options2.scope,
       files: paths.files,
-      fix: options.fix,
-      quiet: options.quiet,
-      json: options.json
+      fix: options2.fix,
+      quiet: options2.quiet
     });
     emitValidationResult(result, invocation.io);
   });
-  addCommonOptions(lintCmd);
-  const circularCmd = addValidationSubcommand(validationCmd, subcommands.circular).action(async (pathOperands, options) => {
+  addCommonOptions(lintCmd, subcommands.lint);
+  const circularCmd = addValidationSubcommand(validationCmd, subcommands.circular).action(async (pathOperands, options2) => {
     const paths = await resolveValidationPaths(invocation, pathOperands);
-    const result = await deps.circularCommand({
+    const result = await commandHandlers.circular({
       cwd: paths.productDir,
-      scope: options.scope,
+      scope: options2.scope,
       files: paths.files,
-      quiet: options.quiet,
-      json: options.json
+      quiet: options2.quiet
     });
     emitValidationResult(result, invocation.io);
   });
-  addCommonOptions(circularCmd);
-  const knipCmd = addValidationSubcommand(validationCmd, subcommands.knip).action(async (pathOperands, options) => {
+  addCommonOptions(circularCmd, subcommands.circular);
+  const knipCmd = addValidationSubcommand(validationCmd, subcommands.knip).action(async (pathOperands, options2) => {
     const paths = await resolveValidationPaths(invocation, pathOperands);
-    const result = await deps.knipCommand({
+    const result = await commandHandlers.knip({
       cwd: paths.productDir,
-      scope: options.scope,
+      scope: options2.scope,
       files: paths.files,
-      quiet: options.quiet,
-      json: options.json
+      quiet: options2.quiet
     });
     emitValidationResult(result, invocation.io);
   });
-  addCommonOptions(knipCmd);
+  addCommonOptions(knipCmd, subcommands.knip);
   const literalCmd = addValidationSubcommand(validationCmd, subcommands.literal).option(
     literalValidationCliOptions.allowlistExisting.flag,
     literalValidationCliOptions.allowlistExisting.description
@@ -23444,106 +23967,127 @@ function registerValidationCommands(validationCmd, invocation, deps) {
   ).option(literalValidationCliOptions.literals.flag, literalValidationCliOptions.literals.description).option(literalValidationCliOptions.verbose.flag, literalValidationCliOptions.verbose.description).addHelpText(
     "after",
     "\nEnabled for TypeScript projects by default. Set validation.literal.enabled=false\nin spx.config.* to skip during migration."
-  ).action(async (pathOperands, options) => {
+  ).action(async (pathOperands, options2) => {
     const paths = await resolveValidationPaths(invocation, pathOperands);
-    if (options.allowlistExisting) {
-      const result2 = await deps.allowlistExisting({ productDir: paths.productDir });
+    if (options2.allowlistExisting) {
+      const result2 = await runAllowlistExisting({ productDir: paths.productDir });
       emitValidationResult(result2, invocation.io);
     }
     let kind;
-    if (options.kind !== void 0) {
-      kind = parseLiteralProblemKind(options.kind);
+    if (options2.kind !== void 0) {
+      kind = parseLiteralProblemKind(options2.kind);
       if (kind === void 0) {
         const { unknownLiteralProblemKind } = validationCliDefinition.diagnostics;
         invocation.io.writeStderr(
-          `spx validation literal: ${unknownLiteralProblemKind.messageLabel}: ${sanitizeCliArgument(options.kind)}
+          `spx validation literal: ${unknownLiteralProblemKind.messageLabel}: ${sanitizeCliArgument(options2.kind)}
 `
         );
         invocation.io.exit(unknownLiteralProblemKind.exitCode);
       }
     }
-    const result = await deps.literalCommand({
+    const result = await commandHandlers.literal({
       cwd: paths.productDir,
-      scope: options.scope,
+      scope: options2.scope,
       files: paths.files,
       kind,
-      filesWithProblems: options.filesWithProblems,
-      literals: options.literals,
-      verbose: options.verbose,
-      quiet: options.quiet,
-      json: options.json
+      filesWithProblems: options2.filesWithProblems,
+      literals: options2.literals,
+      verbose: options2.verbose,
+      quiet: options2.quiet,
+      json: options2.json
     });
     emitValidationResult(result, invocation.io);
   });
-  addCommonOptions(literalCmd);
+  addCommonOptions(literalCmd, subcommands.literal);
   const markdownCmd = addValidationSubcommand(validationCmd, subcommands.markdown).addHelpText(
     "after",
     "\nValidates spx/ and docs/ by default. For nodes listed in spx/EXCLUDE,\nonly direct markdown files in that node directory are skipped;\nchild-node markdown remains in scope."
-  ).action(async (pathOperands, options) => {
+  ).action(async (pathOperands, options2) => {
     const paths = await resolveValidationPaths(invocation, pathOperands);
-    const result = await deps.markdownCommand({
+    const result = await commandHandlers.markdown({
       cwd: paths.productDir,
       files: paths.files,
-      quiet: options.quiet
+      quiet: options2.quiet
     });
     emitValidationResult(result, invocation.io);
   });
-  addCommonOptions(markdownCmd);
-  const formatCmd = addValidationSubcommand(validationCmd, subcommands.format).action(async (pathOperands, options) => {
+  addCommonOptions(markdownCmd, subcommands.markdown);
+  const formatCmd = addValidationSubcommand(validationCmd, subcommands.format).action(async (pathOperands, options2) => {
     const paths = await resolveValidationPaths(invocation, pathOperands);
-    const result = await deps.formattingCommand({
+    const result = await commandHandlers.format({
       cwd: paths.productDir,
       files: paths.files,
-      quiet: options.quiet
+      quiet: options2.quiet
     });
     emitValidationResult(result, invocation.io);
   });
-  addCommonOptions(formatCmd);
-  const allCmd = addValidationSubcommand(validationCmd, subcommands.all).option("--fix", "Auto-fix ESLint issues").option(allValidationCliOptions.skipCircular.flag, allValidationCliOptions.skipCircular.description).option(allValidationCliOptions.skipLiteral.flag, allValidationCliOptions.skipLiteral.description).action(async (pathOperands, options) => {
+  addCommonOptions(formatCmd, subcommands.format);
+  let allCmd = addValidationSubcommand(validationCmd, subcommands.all).option(validationAllBuiltInCliOptions.fix.flag, "Auto-fix ESLint issues");
+  for (const option of allOverrideCliOptions) {
+    allCmd = allCmd.option(option.flag, option.description);
+  }
+  allCmd = allCmd.action(async (pathOperands, options2) => {
     const paths = await resolveValidationPaths(invocation, pathOperands);
-    const result = await deps.allCommand({
+    const result = await commandHandlers.all({
       cwd: paths.productDir,
-      scope: options.scope,
+      scope: options2.scope,
       files: paths.files,
-      fix: options.fix,
-      skipCircular: options.skipCircular,
-      skipLiteral: options.skipLiteral,
-      quiet: options.quiet,
-      json: options.json
-    }, {
-      writeOutput: (output) => invocation.io.writeStdout(`${output}
-`)
+      fix: options2.fix,
+      validationStages,
+      participationOverrides: selectedValidationAllOverrides(options2, allOverrideCliOptions),
+      quiet: options2.quiet,
+      json: options2.json,
+      onStageComplete: ({ output }) => invocation.io.writeStdout(`${output}
+`),
+      outputStreams: validationSubprocessOutputStreams(invocation.io, options2.json)
     });
-    return invocation.io.exit(result.exitCode);
+    emitValidationResult(result, invocation.io);
   });
-  addCommonOptions(allCmd);
+  addCommonOptions(allCmd, subcommands.all);
+}
+function validationSubprocessOutputStreams(io, json) {
+  if (json === true) return discardValidationSubprocessOutputStreams;
+  return {
+    stdout: {
+      write: (chunk) => {
+        io.writeStdout(Buffer.from(chunk).toString());
+        return true;
+      }
+    },
+    stderr: {
+      write: (chunk) => {
+        io.writeStderr(Buffer.from(chunk).toString());
+        return true;
+      }
+    }
+  };
 }
 function parseLiteralProblemKind(value) {
-  return validationLiteralProblemKinds.find((problemKind) => problemKind === value);
+  if (isValidationLiteralProblemKind(value)) {
+    return value;
+  }
+  return void 0;
 }
 function handleUnknownSubcommand(operands, io) {
   const [first] = operands;
   const sanitized = sanitizeCliArgument(first);
   const { domain, diagnostics } = validationCliDefinition;
   const { unknownSubcommand } = diagnostics;
-  io.writeStderr(
-    `${SPX_PROGRAM_NAME} ${domain.commandName}: ${unknownSubcommand.messageLabel}: ${sanitized}
-`
-  );
+  io.writeStderr(`${SPX_PROGRAM_NAME} ${domain.commandName}: ${unknownSubcommand.messageLabel}: ${sanitized}
+`);
   return io.exit(unknownSubcommand.exitCode);
 }
-function createValidationDomain(overrides = {}) {
-  const deps = { ...defaultValidationCliDependencies, ...overrides };
+function createValidationDomain(options = {}) {
   return {
     name: validationCliDefinition.domain.commandName,
     description: validationCliDefinition.domain.description,
     register: (program, invocation) => {
       const { domain } = validationCliDefinition;
-      const validationCmd = program.command(domain.commandName).alias(domain.alias).description(domain.description);
+      const validationCmd = program.command(domain.commandName).alias(domain.alias).description(domain.description).addHelpCommand(false);
       validationCmd.on("command:*", (operands) => {
         handleUnknownSubcommand(operands, invocation.io);
       });
-      registerValidationCommands(validationCmd, invocation, deps);
+      registerValidationCommands(validationCmd, invocation, options);
     }
   };
 }
@@ -23850,6 +24394,10 @@ var REVIEW_TERMINAL_STATE = {
   CHANGES_REQUESTED: "changes_requested",
   COMMENTED: "commented"
 };
+var REVIEW_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  JOURNAL_RUN_STATE_STATUS.APPROVED,
+  JOURNAL_RUN_STATE_STATUS.REJECTED
+]);
 var AUDIT_CLASS = {
   IMPLEMENTATION: "implementation",
   INSTRUCTIONS: "instructions",
@@ -24154,6 +24702,9 @@ function validateReviewTerminal(input) {
   if (input.metadata !== void 0 && validated === void 0) {
     return { ok: false, error: TERMINAL_METADATA_VALIDATION_ERROR.METADATA_INVALID };
   }
+  if (!REVIEW_TERMINAL_STATUSES.has(input.terminalStatus)) {
+    return { ok: false, error: TERMINAL_METADATA_VALIDATION_ERROR.STATUS_CONFLICT };
+  }
   const evidenceStatus = expectedReviewEvidenceTerminalStatus(input.events);
   const metadataStatus = expectedReviewMetadataTerminalStatus(validated);
   if (evidenceStatus !== void 0 && metadataStatus !== void 0 && evidenceStatus !== metadataStatus) {
@@ -25685,7 +26236,7 @@ function createCliProgram(options = {}) {
 
 // src/cli.ts
 installLifecycle();
-var require3 = createRequire2(import.meta.url);
+var require3 = createRequire3(import.meta.url);
 var { version } = require3("../package.json");
 createCliProgram({ version }).parse();
 //# sourceMappingURL=cli.js.map