@systemfsoftware/stryker-js-cli 3.1.0 → 3.2.0

package/dist/main.mjs

@@ -2,9 +2,10 @@
 import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
 import * as NodeStdio from "@effect/platform-node/NodeStdio";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
-import semver from "semver";
-import { strykerEngines, strykerVersion } from "@systemfsoftware/stryker-js-mutation-run/stryker-package";
+import * as Logger from "effect/Logger";
+import { ExitClass, buildVerdictEnvelope, defaultOptions, defaultStages, forkCoreSchema, generateRunId, highestExitClass, makeRunLayer, readConfig, resolveExitCode, runMutationTest, strykerEngines, strykerVersion, toRelativeNormalizedFileName } from "@systemfsoftware/stryker-js-mutation-run";
 import * as Context from "effect/Context";
 import * as Result from "effect/Result";
 import * as CliError from "effect/unstable/cli/CliError";
@@ -15,7 +16,10 @@ import * as Fiber from "effect/Fiber";
 import * as Queue from "effect/Queue";
 import * as Stdio from "effect/Stdio";
 import * as Stream from "effect/Stream";
-import { buildVerdictEnvelope, generateRunId } from "@systemfsoftware/stryker-js-mutation-run/verdict-envelope";
+import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
+import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
+import * as NodePath$1 from "@effect/platform-node-shared/NodePath";
+import { RENDERED_OPTION_DEFAULTS, causeText } from "@systemfsoftware/stryker-js-plugin-api/core";
 import * as Console from "effect/Console";
 import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
@@ -27,28 +31,21 @@ import * as CliConfig from "effect/unstable/cli/CliConfig";
 import * as Command from "effect/unstable/cli/Command";
 import * as Flag from "effect/unstable/cli/Flag";
 import * as GlobalFlag from "effect/unstable/cli/GlobalFlag";
-import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
-import { ConfigReader, OptionsValidator, defaultOptions } from "@systemfsoftware/stryker-js-mutation-run/config/config-resolution";
-import { PluginKind } from "@systemfsoftware/stryker-js-plugin-api/plugin";
-import { strykerPlugins } from "@systemfsoftware/stryker-js-mutation-report/stryker-plugins";
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
-import "@systemfsoftware/stryker-js-plugin-api/core";
-import { noopLogger } from "@systemfsoftware/stryker-js-util";
-import * as Exit from "effect/Exit";
-import { pipe } from "effect/Function";
+import { NodePath } from "@effect/platform-node";
 import * as Match from "effect/Match";
+import * as Predicate from "effect/Predicate";
 import * as S from "effect/Schema";
-import { Stryker } from "@systemfsoftware/stryker-js-mutation-run";
-import { forkCoreSchema } from "@systemfsoftware/stryker-js-mutation-run/config/fork-schema";
-import { ConfigError, retrieveCause } from "@systemfsoftware/stryker-js-mutation-run/errors";
-import { ExitClass, getPendingExitClasses, resolveExitCode } from "@systemfsoftware/stryker-js-mutation-run/exit-classification";
+import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
 import { performance } from "node:perf_hooks";
 import { format, inspect } from "node:util";
-import { toRelativeNormalizedFileName } from "@systemfsoftware/stryker-js-mutation-run/mutants/incremental-differ";
-//#region src/OutputMode.ts
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { noopLogger } from "@systemfsoftware/stryker-js-plugin-api/logging";
+import { pipe } from "effect/Function";
+import { PluginKind } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import { strykerPlugins } from "@systemfsoftware/stryker-js-mutation-report/stryker-plugins";
+//#region src/output-mode.ts
 /**
 * The known tool variables. Narrow per the plan — exactly
 * `['CLAUDECODE', 'CODEX_SANDBOX']` — and load-bearing rather than a
@@ -109,15 +106,6 @@ function resolveMode(input) {
 	});
 }
 /**
-* The progress bar's gate. Human mode on a non-TTY stdout (AE1) must not leak
-* its control sequences into a pipe, and machine mode keeps stdout clean for
-* the verdict envelope (R5). Decided from the resolved mode's own detection
-* data — never a second `isTTY` probe.
-*/
-function isProgressEnabled(resolved) {
-	return resolved.mode === "human" && resolved.stdoutIsTTY;
-}
-/**
 * The log colouriser's gate (R8). Machine mode never emits colour, so a
 * harness merging `2>&1` is not handed escape sequences it must strip, and
 * `NO_COLOR` is honoured for the human path per the convention: any value
@@ -127,8 +115,8 @@ function isColorEnabled(resolved, noColor) {
 	return resolved.mode === "human" && (noColor === void 0 || noColor.length === 0);
 }
 //#endregion
-//#region src/OutputModeAdapter.ts
-var OutputModeProbeTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/OutputModeAdapter/OutputModeProbeTag") {};
+//#region src/output-mode-probe.ts
+var OutputModeProbeTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/output-mode-probe/OutputModeProbeTag") {};
 const OutputModeProbe = OutputModeProbeTag;
 const OutputModeProbeLive = Layer.succeed(OutputModeProbe, OutputModeProbe.of({ detectMode: () => {
 	const envMode = process.env["STRYKER_MODE"];
@@ -141,7 +129,7 @@ const OutputModeProbeLive = Layer.succeed(OutputModeProbe, OutputModeProbe.of({
 	}));
 } }));
 //#endregion
-//#region src/StreamProtocol.ts
+//#region src/stream-protocol.ts
 /**
 * The heartbeat interval (R19), matching Terraform's `apply_progress`
 * cadence: long enough that a slow phase is not noisy, short enough that a
@@ -149,23 +137,24 @@ const OutputModeProbeLive = Layer.succeed(OutputModeProbe, OutputModeProbe.of({
 */
 const TICK_INTERVAL_MS = 1e4;
 //#endregion
-//#region src/RunEventStreamAdapter.ts
-var RunEventStreamPortTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/RunEventStreamAdapter/RunEventStreamPortTag") {};
+//#region src/run-event-stream.ts
+var RunEventStreamPortTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/run-event-stream/RunEventStreamPortTag") {};
 const RunEventStreamPort = RunEventStreamPortTag;
 const isTerminalEvent = (event) => event.kind === "verdict" || event.kind === "error" || event.kind === "help" || event.kind === "manifest";
 /**
 * The push adapter from the run's synchronous sink to the callback mailbox.
 * `Queue.offer`/`Queue.end` on an unbounded queue never block or fail, so the
-* sync sink can drive them with `Effect.runSync`. Defined at module scope,
-* outside any Effect expression.
+* sync sink can drive them with `Effect.runSyncWith(ctx)` using the context
+* captured where the sink is constructed. Takes the queue and the captured
+* context, keeping the adapter pure with respect to its environment.
 */
-function queueEmit(queue) {
+function queueEmit(queue, ctx) {
 	return {
 		single: (event) => {
-			Effect.runSync(Queue.offer(queue, event));
+			Effect.runSyncWith(ctx)(Queue.offer(queue, event));
 		},
 		end: () => {
-			Effect.runSync(Queue.end(queue));
+			Effect.runSyncWith(ctx)(Queue.end(queue));
 		}
 	};
 }
@@ -190,6 +179,7 @@ const drainOf = (stdio, framed) => Stream.run(framed, stdio.stdout({ endOnDone:
 const makeRunEventStream = (stdio, resolved) => Effect.gen(function* () {
 	const runId = generateRunId();
 	const startedAt = yield* Clock.currentTimeMillis;
+	const ctx = yield* Effect.context();
 	const state = {
 		mode: resolved.mode,
 		signal: resolved.signal,
@@ -203,7 +193,7 @@ const makeRunEventStream = (stdio, resolved) => Effect.gen(function* () {
 	};
 	const registered = yield* Deferred.make();
 	const eventStream = Stream.callback((queue) => Effect.sync(() => {
-		state.emit = queueEmit(queue);
+		state.emit = queueEmit(queue, ctx);
 	}).pipe(Effect.andThen(Deferred.succeed(registered, void 0))));
 	const tickStream = Stream.tick(TICK_INTERVAL_MS).pipe(Stream.filter(() => state.mode === "machine" && state.headerWritten && !state.terminalWritten), Stream.mapEffect(() => Effect.gen(function* () {
 		return {
@@ -285,187 +275,531 @@ const makeRunEventStream = (stdio, resolved) => Effect.gen(function* () {
 	};
 });
 const RunEventStreamLive = Layer.effect(RunEventStreamPort, Effect.map(Stdio.Stdio, (stdio) => RunEventStreamPort.of({ createRunEventStream: (resolved) => makeRunEventStream(stdio, resolved) })));
-function isObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function stringField(node, key) {
-	const value = node[key];
-	return typeof value === "string" ? value : void 0;
+//#endregion
+//#region src/signal-observer.ts
+const SIGNAL_NUMBERS = Object.freeze({
+	SIGINT: 2,
+	SIGTERM: 15
+});
+/**
+* Installs the listeners and returns the reader.
+*
+* The listener records and returns: interrupting the run is the runtime's job,
+* and doing it from here would race the run's own finalizer for the stream.
+* `once` per signal, because a second delivery of the same signal cannot
+* change the answer.
+*/
+function observeTerminatingSignal() {
+	let observed = null;
+	for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => {
+		observed = SIGNAL_NUMBERS[signal] ?? null;
+	});
+	return () => observed;
 }
-function stringArrayField(node, key) {
-	const value = node[key];
-	if (!Array.isArray(value)) return [];
-	const strings = [];
-	for (const item of value) if (typeof item === "string") strings.push(item);
-	return strings;
+//#endregion
+//#region src/survivors-report.schema.ts
+/**
+* The mutant shape the admission carries, named once because both the decision's
+* `Admitted` payload and the command's precomputed survivor list are the same shape.
+*/
+const MutantShape = S.Struct({
+	id: S.String,
+	fileName: S.String,
+	mutatorName: S.String,
+	replacement: S.String,
+	location: S.Struct({
+		start: S.Struct({
+			line: S.Finite,
+			column: S.Finite
+		}),
+		end: S.Struct({
+			line: S.Finite,
+			column: S.Finite
+		})
+	})
+});
+/**
+* The prior report as a document, decoded at the boundary. Module-internal: consumers
+* get the decode function, not the schema, so the report's wire shape is not a
+* surface commitment and the codec has exactly one caller.
+*
+* `status` is a bare string rather than the closed status set on purpose: the decide only
+* compares it to `'Survived'`, so a report written by a newer engine that added a status
+* must not be refused for carrying one.
+*/
+const PriorReportDocument = S.Struct({
+	config: S.optional(S.Record(S.String, S.Unknown)),
+	framework: S.optional(S.Struct({ version: S.optional(S.String) })),
+	files: S.Record(S.String, S.Struct({
+		source: S.String,
+		mutants: S.Array(S.Struct({
+			id: S.String,
+			mutatorName: S.String,
+			replacement: S.optional(S.String),
+			status: S.String,
+			location: S.Struct({
+				start: S.Struct({
+					line: S.Finite,
+					column: S.Finite
+				}),
+				end: S.Struct({
+					line: S.Finite,
+					column: S.Finite
+				})
+			})
+		}))
+	}))
+});
+//#endregion
+//#region src/survivors-admission.workflow.ts
+/**
+* U8 — survivor re-run admission (R10, R11, KTD6, KTD7).
+*
+* The `--survivors` run re-tests exactly the mutants that survived a previous
+* run. Its input is the previous run's mutation report, and the run is
+* admitted only when a single structural hash of the resolved options, the
+* recorded framework version, and the per-file source content all match the
+* current run (KTD6).
+*/
+/**
+* The decision's helpers reach three language built-ins the purity gate cannot
+* resolve as globals, so each is bound at module scope.
+*
+* These live here, beside the decision, because `make-body-purity` follows the
+* decision's reachable set: a helper `admissionVerdict` calls is checked as part
+* of the body even though it is declared outside it. That is why the properties
+* covering them are in this file's in-source block rather than beside a pure helper -
+* testing a copy the decision does not run is worse than not testing it, because
+* the suite goes green either way.
+*/
+const isArray = Array.isArray;
+const { fromEntries: objectFromEntries$1, keys: objectKeys } = Object;
+const stringify = JSON.stringify;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !isArray(value);
 }
-/** The compiled shapes discriminate on `_tag`; read it once, off the record. */
-function tagOf(node) {
-	return node["_tag"];
+const SURVIVORS_RUN_FIRST_REMEDIATION = "run a full `stryker run` first, then re-run with --survivors";
+const SURVIVORS_BOOKKEEPING_KEYS = ["survivorsPriorReport"];
+/**
+* The resolved options without the survivors-run bookkeeping keys, so both
+* sides of the admission comparison describe the same configuration.
+*/
+function stripSurvivorsKeys(config) {
+	if (!isRecord(config)) return {};
+	const rest = { ...config };
+	for (const key of SURVIVORS_BOOKKEEPING_KEYS) delete rest[key];
+	return rest;
 }
-function walkParam(param, isOptional, out) {
-	if (!isObject(param)) return;
-	switch (tagOf(param)) {
-		case "Single":
-			describeSingle(param, isOptional, out);
-			return;
-		case "Map":
-		case "Transform":
-			walkParam(param["param"], isOptional, out);
-			return;
-		case "Optional":
-			walkParam(param["param"], true, out);
-			return;
-		case "Variadic":
-			walkParam(param["param"], isOptional, out);
-			return;
-		default: return;
-	}
+/**
+* A report written by a survivors run embeds the bookkeeping key in its
+* `config`. Such a report is never a valid input for another survivors run
+* (KTD7): without this check the second run would either re-read a shrunken set
+* or re-test a stale one.
+*/
+function wasProducedBySurvivorsRun(priorReport) {
+	const config = priorReport.config;
+	return isRecord(config) && "survivorsPriorReport" in config;
 }
-const PRIMITIVE_KIND = {
-	Boolean: "boolean",
-	Choice: "choice",
-	Date: "date",
-	FileParse: "file",
-	FileSchema: "file",
-	FileText: "file",
-	Float: "float",
-	Integer: "integer",
-	KeyValuePair: "key=value",
-	None: "none",
-	Path: "path",
-	Redacted: "redacted",
-	String: "text"
-};
-function kindOf(primitive) {
-	const tag = stringField(primitive, "_tag");
-	return tag === void 0 ? "unknown" : PRIMITIVE_KIND[tag] ?? tag;
+/**
+* Serializes the comparison input with keys sorted at every level, so the result
+* is a function of the data and not of key insertion order.
+*/
+function serializeSurvivorsHashInput(input) {
+	return stringify(sortKeys(input));
 }
-function choiceValues(primitive) {
-	const keys = primitive["choiceKeys"];
-	if (!Array.isArray(keys)) return;
-	const values = [];
-	for (const key of keys) if (typeof key === "string") values.push(key);
-	return values;
+function sortKeys(value) {
+	if (isArray(value)) return value.map(sortKeys);
+	if (isRecord(value)) return objectFromEntries$1(objectKeys(value).sort().map((key) => [key, sortKeys(value[key])]));
+	return value;
 }
-/** The allowed reporter names, read from the U9 registry — the same list the plugin loader accepts. */
-const REPORTER_NAMES = strykerPlugins.filter((plugin) => plugin.kind === PluginKind.Reporter).map((plugin) => plugin.name);
 /**
-* v4 option descriptions are stored as `Option.some(string)` on the compiled
-* `Single`; the walker unwraps the option.
+* The prior report's facts the decision reads: its embedded configuration, which carries
+* both the compared options and the survivors-run provenance marker, and the engine
+* version it recorded. The report's files are not here — the survivors and the per-file
+* source hashes derived from them need capabilities the command cannot hold, so they
+* arrive already computed.
 */
-function descriptionOf(single) {
-	const description = single["description"];
-	if (!isObject(description)) return "";
-	switch (tagOf(description)) {
-		case "Some": {
-			const value = description["value"];
-			return typeof value === "string" ? value : "";
-		}
-		default: return "";
-	}
+var PriorReportFacts = class extends S.Class("PriorReportFacts")({
+	config: S.Record(S.String, S.Unknown),
+	frameworkVersion: S.UndefinedOr(S.String)
+}) {};
+/**
+* The command of the admission workflow: a schema class, because `Workflow.make`
+* constrains its first argument on the class value and a declared interface produces no
+* value to pass. Every field is pure data — the two capabilities the previous shape
+* carried, a digest function and a path resolver, can never be schema fields, so their
+* results arrive precomputed from the decode phase instead.
+*/
+var AdmitSurvivorsRunCommand = class extends S.Class("AdmitSurvivorsRunCommand")({
+	/**
+	* The prior run's report facts, `undefined` when no report exists — the run cannot be
+	* admitted without one ('no-report'). Explicitly nullable rather than key-optional: a
+	* missing report is a state the edge determined and states, not a key it forgot.
+	*/
+	priorReport: S.UndefinedOr(PriorReportFacts),
+	/** The current run's resolved options (defaults + config file + CLI). */
+	currentConfig: S.Record(S.String, S.Unknown),
+	/** The current CLI/framework version (`strykerVersion`). */
+	frameworkVersion: S.String,
+	/**
+	* Per-file content hashes of the current source, keyed by the prior report's relative
+	* file keys. The prior side is hashed from the sources the report embeds, so an editor
+	* save that shifts line ranges — which would silently re-test a different mutant than
+	* the one that survived — is caught here.
+	*/
+	sourceContentHashes: S.Record(S.String, S.String),
+	/** The same hashes for the sources the prior report embeds, computed at the edge. */
+	priorSourceHashes: S.Record(S.String, S.String),
+	/** The prior report's survivors, already converted to the internal mutant shape. */
+	priorSurvivors: S.Array(MutantShape)
+}) {};
+const NO_REPORT_DETAIL = "No prior mutation report found — a --survivors run needs the report of a previous run.";
+const SURVIVORS_RUN_SOURCE_DETAIL = "The prior mutation report was itself produced by a --survivors run, so it is not a valid input for another one.";
+const MISMATCH_DETAIL = "The prior mutation report does not match the current run (resolved options, framework version, or source content differ).";
+/**
+* Whether the admission inputs agree: the prior report's embedded resolved options,
+* framework version and source content against the current run's.
+*
+* The comparison is on the canonical serializations rather than digests of them. Equal
+* serializations are equal runs, so the digest was a lossy restatement of the check that
+* also demanded a capability no command can carry.
+*/
+function hashesMatch(priorReport, input) {
+	return serializeSurvivorsHashInput({
+		resolvedOptions: stripSurvivorsKeys(priorReport.config),
+		frameworkVersion: priorReport.frameworkVersion,
+		sourceContentHashes: input.priorSourceHashes
+	}) === serializeSurvivorsHashInput({
+		resolvedOptions: stripSurvivorsKeys(input.currentConfig),
+		frameworkVersion: input.frameworkVersion,
+		sourceContentHashes: input.sourceContentHashes
+	});
 }
-function describeSingle(single, isOptional, out) {
-	const name = stringField(single, "name") ?? "";
-	const primitive = isObject(single["primitiveType"]) ? single["primitiveType"] : {};
-	const kind = kindOf(primitive);
-	const choices = name === "reporters" ? REPORTER_NAMES : kind === "choice" ? choiceValues(primitive) : void 0;
-	const description = descriptionOf(single);
-	const required = kind !== "boolean" && !isOptional;
-	const described = {
-		name,
-		aliases: stringArrayField(single, "aliases"),
-		kind,
-		required,
-		...choices !== void 0 ? { choices } : {},
-		description
+const rejection = (reason, detail) => ({
+	kind: "reject",
+	reason,
+	remediation: `${detail} ${SURVIVORS_RUN_FIRST_REMEDIATION}`
+});
+function admissionVerdict(input) {
+	const priorReport = input.priorReport;
+	if (priorReport === void 0) return rejection("no-report", NO_REPORT_DETAIL);
+	if (wasProducedBySurvivorsRun(priorReport)) return rejection("mismatch", SURVIVORS_RUN_SOURCE_DETAIL);
+	if (input.priorSurvivors.length === 0) return { kind: "no-survivors" };
+	if (!hashesMatch(priorReport, input)) return rejection("mismatch", MISMATCH_DETAIL);
+	return {
+		kind: "admit",
+		survivors: input.priorSurvivors
 	};
-	if (single["kind"] === "argument") {
-		out.args.push({
-			name,
-			kind,
-			required,
-			description
-		});
-		return;
+}
+const SurvivorsAdmissionTypeId = Symbol.for("@systemfsoftware/stryker-js-cli/SurvivorsAdmission");
+var Admitted = class extends S.TaggedClass()("Admitted", { survivors: S.Array(MutantShape) }) {
+	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
+};
+var NoSurvivors = class extends S.TaggedClass()("NoSurvivors", {}) {
+	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
+};
+S.Union([Admitted, NoSurvivors]);
+var SurvivorsRejection = class extends S.TaggedError()("SurvivorsRejection", {
+	reason: S.Literals(["no-report", "mismatch"]),
+	remediation: S.String
+}) {
+	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
+};
+/**
+* The survivors admission decision: the classification `admissionVerdict`
+* produces, assigned to the workflow channels — one arm per kind, no guard
+* chain. A missing report, a survivors-sourced report and a hash mismatch are
+* the same reject outcome with different reasons; only the rejection's
+* remediation names the full run to do first (R10).
+*/
+const admitSurvivorsRun = Workflow.make(AdmitSurvivorsRunCommand, (command) => Match.value(admissionVerdict(command)).pipe(Match.discriminator("kind")("reject", (verdict) => Result.fail(SurvivorsRejection.make({
+	reason: verdict.reason,
+	remediation: verdict.remediation
+}))), Match.discriminator("kind")("no-survivors", () => Result.succeed(NoSurvivors.make())), Match.discriminator("kind")("admit", (verdict) => Result.succeed(Admitted.make({ survivors: verdict.survivors }))), Match.exhaustive));
+//#endregion
+//#region src/survivors-exit.ts
+/** The exit class a rejected survivors run exits with (R6: exit 2). */
+const SURVIVORS_REJECT_EXIT_CLASS = ExitClass.ConfigError;
+//#endregion
+//#region src/cli-exit-code.ts
+function isExitClass(value) {
+	return value === ExitClass.VerdictFail || value === ExitClass.ConfigError || value === ExitClass.RuntimeError || value === ExitClass.InternalError;
+}
+/**
+* The `exitClass` of a tagged error, when it carries one.
+*
+* Every `*.schema.ts` error in `mutation-run` carries a `readonly exitClass`
+* member (or schema field) — `2` for config, `3` for runtime, `4` for
+* internal. The field is deliberately off-wire, but at the CLI edge the
+* errors are in-process objects, so it is readable via `Reflect.get`.
+*/
+function exitClassOf(value) {
+	if (typeof value !== "object" || value === null) return;
+	if (!("exitClass" in value)) return;
+	const raw = Reflect.get(value, "exitClass");
+	if (typeof raw !== "number" || !isExitClass(raw)) return;
+	return raw;
+}
+/**
+* Collects every `exitClass` present in a value's nested `cause` chain.
+*
+* Depth-capped and cycle-safe: schema errors nest (`PrepareFailedError`
+* wrapping `ConfigFileInvalidError` wrapping a validation detail), and a
+* malformed chain must not recurse unboundedly.
+*/
+function collectExitClassesFromValue(value, out, seen, depth) {
+	if (depth > 10 || value === null || value === void 0) return;
+	if (typeof value !== "object") return;
+	if (seen.has(value)) return;
+	seen.add(value);
+	const ec = exitClassOf(value);
+	if (ec !== void 0) out.push(ec);
+	if ("cause" in value) {
+		const causeVal = Reflect.get(value, "cause");
+		if (Array.isArray(causeVal)) for (const entry of causeVal) collectExitClassesFromValue(entry, out, seen, depth + 1);
+		else collectExitClassesFromValue(causeVal, out, seen, depth + 1);
 	}
-	out.flags.push(described);
 }
-function walkConfigNode(node, orderedParams, out) {
-	if (!isObject(node)) return;
-	switch (tagOf(node)) {
-		case "Param": {
-			const index = node["index"];
-			const param = typeof index === "number" ? orderedParams[index] : void 0;
-			if (param !== void 0) walkParam(param, false, out);
-			return;
+/**
+* Collects every `exitClass` present in the failure's `Cause` and in each
+* error's nested `cause` field.
+*
+* A `Cause` holds typed `Fail` and defect `Die` reasons
+* (`repos/effect/packages/effect/src/Cause.ts:144-196`, `isFailReason` /
+* `isDieReason`). `Effect.mapError` replaces the error value while keeping
+* only the mapped error in `cause.reasons`
+* (`repos/effect/packages/effect/src/internal/effect.ts:3253-3267`), so a
+* wrapped config error is invisible at the top level and must be found by
+* walking both the `Cause` reasons and each error's own `cause` field.
+*/
+function collectExitClasses(exit) {
+	const out = [];
+	const seen = /* @__PURE__ */ new WeakSet();
+	if (Exit.isFailure(exit)) for (const reason of exit.cause.reasons) {
+		const candidate = Cause.isFailReason(reason) ? reason.error : Cause.isDieReason(reason) ? reason.defect : void 0;
+		if (candidate !== void 0) collectExitClassesFromValue(candidate, out, seen, 0);
+	}
+	return out;
+}
+/**
+* Classifies a failed run for the finalizer: usage/parse failures
+* (`CliError` — except a bare help request, which exits 0), rejected
+* survivors runs (`SurvivorsRejection`), an unreadable prior report
+* (`S.SchemaError`) all exit 2; otherwise the highest `exitClass` found by
+* walking the failure's `Cause` reasons and each error's nested `cause` field
+* wins by the precedence `4 > 3 > 2 > 1` (via `highestExitClass`); no class
+* found is 1 (the framework's default). A successful run exits 0; the verdict
+* gates (U5) then resolve the final classed code.
+*
+* The report parse failure shares the survivors class deliberately. It is not a
+* verdict — the decider never sees the report — but the operator's answer is the
+* same class of answer as a rejection: the input you named cannot be used. Letting
+* it fall through to 1 would make an unusable `--survivors` input indistinguishable
+* from a crash.
+*
+* Previously this matched only a top-level `ConfigError` via `carriesConfigError`,
+* so a `PrepareFailedError` wrapping a `ConfigFileInvalidError` was invisible
+* and classes 3 and 4 were unreachable. Walking the chain makes them reachable.
+*/
+function resolveCliExitCode(exit) {
+	if (Exit.isSuccess(exit)) return 0;
+	if (Cause.hasInterruptsOnly(exit.cause)) return 1;
+	const failure = Cause.findErrorOption(exit.cause);
+	if (Option.isSome(failure)) {
+		const value = failure.value;
+		if (S.is(CliError.ShowHelp)(value)) return value.errors.length > 0 ? 2 : 0;
+		if (CliError.isCliError(value)) return 2;
+		if (S.is(SurvivorsRejection)(value)) return SURVIVORS_REJECT_EXIT_CLASS;
+		if (S.isSchemaError(value)) return SURVIVORS_REJECT_EXIT_CLASS;
+	}
+	const classes = collectExitClasses(exit);
+	const highest = highestExitClass(classes);
+	if (highest !== null) return highest;
+	return 1;
+}
+//#endregion
+//#region src/cli-failure-text.ts
+/**
+* The reason a domain error carries, when it carries one.
+*
+* Every stage error in this engine is an `S.TaggedError` whose payload field is
+* `reason` — `DryRunNoTestsError`, `DryRunFailedError`, `PrepareFailedError`
+* and friends. Those classes extend `Error`, but nothing assigns `.message`, so
+* reading `.message` off one yields the empty string and the operator is told
+* a run failed with no indication of why. Read the field the errors actually
+* populate, and fall back only when it is absent.
+*/
+function reasonOf(value) {
+	if (!("reason" in value)) return;
+	const reason = Reflect.get(value, "reason");
+	if (typeof reason !== "string" || reason.length === 0) return;
+	const detail = causeTextOf(value);
+	return detail === void 0 ? reason : `${reason}: ${detail}`;
+}
+/**
+* The human-readable text of a domain error's wrapped `cause`, if it has one.
+*
+* Recurses, because these errors nest: a stage error wraps a
+* `TestRunnerFailed`, which wraps the spawn or import failure that actually
+* happened. Stopping at the first layer reports a tag name — "TestRunnerFailed"
+* — and leaves the operator to guess. Each layer contributes only what it
+* knows, so the reader gets the chain down to the real fault.
+*/
+function causeTextOf(value, depth = 0) {
+	if (depth > 4 || !("cause" in value)) return;
+	const cause = Reflect.get(value, "cause");
+	return causeText(cause, depth + 1);
+}
+function configDetailOf(value) {
+	const reason = reasonOf(value);
+	if (reason !== void 0) return reason;
+	const text = causeText(value, 0);
+	if (text !== void 0 && text.length > 0) return text;
+	if ("message" in value) {
+		const msg = Reflect.get(value, "message");
+		if (typeof msg === "string" && msg.length > 0) return msg;
+	}
+}
+function shouldVisitConfigValue(value, depth, seen) {
+	if (depth > 10) return false;
+	if (value === null || value === void 0) return false;
+	if (typeof value !== "object") return false;
+	if (seen.has(value)) return false;
+	return true;
+}
+function pushConfigCauses(value, depth, stack) {
+	if (!("cause" in value)) return;
+	const causeVal = Reflect.get(value, "cause");
+	if (Array.isArray(causeVal)) for (let index = causeVal.length - 1; index >= 0; index--) stack.push({
+		value: causeVal[index],
+		depth: depth + 1
+	});
+	else stack.push({
+		value: causeVal,
+		depth: depth + 1
+	});
+}
+/**
+* The first config-class error's detail in cause-chain order, for the
+* config remediation.
+*/
+function firstConfigErrorDetail(exit) {
+	if (!Exit.isFailure(exit)) return;
+	const seen = /* @__PURE__ */ new WeakSet();
+	const stack = [];
+	for (const reason of exit.cause.reasons) {
+		const candidate = Cause.isFailReason(reason) ? reason.error : Cause.isDieReason(reason) ? reason.defect : void 0;
+		if (candidate !== void 0) stack.push({
+			value: candidate,
+			depth: 0
+		});
+	}
+	while (stack.length > 0) {
+		const entry = stack.pop();
+		if (entry === void 0) continue;
+		const { value, depth } = entry;
+		if (!shouldVisitConfigValue(value, depth, seen)) continue;
+		seen.add(value);
+		if (exitClassOf(value) === ExitClass.ConfigError) {
+			const detail = configDetailOf(value);
+			if (detail !== void 0) return detail;
 		}
-		case "Array":
-			if (Array.isArray(node["children"])) for (const child of node["children"]) walkConfigNode(child, orderedParams, out);
-			return;
-		case "Nested":
-			if (isObject(node["tree"])) walkConfigTree(node["tree"], orderedParams, out);
-			return;
-		default: return;
+		pushConfigCauses(value, depth, stack);
 	}
 }
-function walkConfigTree(tree, orderedParams, out) {
-	for (const key of Object.keys(tree)) walkConfigNode(tree[key], orderedParams, out);
+/**
+* The contextual remediation for a failure, picked from the class of the
+* failure whose cause chain contains an `exitClass` of `ConfigError` (2)
+* names the config file, rejected survivors runs name the full run to do
+* first. Everything else points at the report file and the verdict envelope,
+* which is where a runtime failure's detail already is. The classification
+* walks the `Cause` reasons and each error's nested `cause` field — see
+* `collectExitClasses`.
+*/
+function remediationFor(exit, code) {
+	if (code > 128) return "the run was interrupted by a signal; re-run it to continue";
+	const value = failureValue(exit);
+	if (value !== void 0) {
+		if (CliError.isCliError(value)) return "re-run with --help to see the full usage";
+		if (S.is(SurvivorsRejection)(value)) return value.remediation;
+	}
+	if (collectExitClasses(exit).includes(ExitClass.ConfigError)) {
+		const detail = firstConfigErrorDetail(exit);
+		return detail !== void 0 ? `check the config file: ${detail}` : "check the config file";
+	}
+	return "see --reportFile or the verdict envelope on stdout";
 }
-function describeCommandNode(node) {
-	if (!isObject(node)) return;
-	const out = {
-		flags: [],
-		args: []
-	};
-	const config = node["config"];
-	if (isObject(config) && isObject(config["tree"])) {
-		const orderedParams = Array.isArray(config["orderedParams"]) ? config["orderedParams"] : [];
-		walkConfigTree(config["tree"], orderedParams, out);
+/**
+* The failure's own text, used when the capture buffer is empty — a failure
+* stryker reported through its own logger rather than the framework's
+* `Console`. Falls back to a rendered cause.
+*/
+function describeFailure(exit) {
+	if (Exit.isFailure(exit)) {
+		const value = failureValue(exit);
+		if (value !== void 0) {
+			if (S.is(SurvivorsRejection)(value)) return value.remediation;
+			if (typeof value === "object" && value !== null) {
+				const reason = reasonOf(value);
+				if (reason !== void 0) return reason;
+			}
+			if (value instanceof Error && value.message.length > 0) return value.message;
+			if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol") return String(value);
+			return Cause.pretty(exit.cause);
+		}
+		return Cause.pretty(exit.cause);
 	}
-	const subcommands = [];
-	const grouped = node["subcommands"];
-	if (Array.isArray(grouped)) for (const group of grouped) {
-		if (!isObject(group) || !Array.isArray(group["commands"])) continue;
-		for (const child of group["commands"]) {
-			const described = describeCommandNode(child);
-			if (described !== void 0) subcommands.push(described);
+	return "";
+}
+/**
+* The argument the framework reports it does not know, named the way the wire
+* contract spells it. The v4 parser fails wrapped in a ShowHelp whose errors
+* carry the offending flag or operand; when the unrecognized flag was given a
+* separate value (`--format text`), the value is the token the old parser
+* reported, so the token after the flag is named when one was given.
+*/
+function unrecognizedArgumentOf(exit, argv) {
+	if (!Exit.isFailure(exit)) return;
+	const value = failureValue(exit);
+	if (value === void 0 || !CliError.isCliError(value)) return;
+	const errors = S.is(CliError.ShowHelp)(value) ? value.errors : [value];
+	for (const error of errors) {
+		if (S.is(CliError.UnrecognizedOption)(error)) {
+			const at = argv.indexOf(error.option);
+			const next = at >= 0 ? argv[at + 1] : void 0;
+			return next !== void 0 && !next.startsWith("-") ? next : error.option;
 		}
+		if (S.is(CliError.UnexpectedArgument)(error)) return error.arguments[0];
+		if (S.is(CliError.UnknownSubcommand)(error)) return error.subcommand;
 	}
-	return {
-		name: stringField(node, "name") ?? "",
-		description: typeof node["description"] === "string" ? node["description"] : "",
-		options: out.flags,
-		args: out.args,
-		subcommands
-	};
 }
 /**
-* Builds the manifest document for a command, walking its compiled form (the
-* same structure the parser matches against). `version` is the tool version,
-* passed in so this module stays free of package state.
+* The first typed error in the exit's cause. The framework fails with
+* `Cause.fail` (usage errors); the run handler is `Effect.promise`, whose
+* rejected promises surface as *defects* (`Die` reasons) rather than
+* failures — so stryker's own ConfigError/StrykerError values arrive there
+* and must be read from the cause's `Die` reasons.
 */
-function buildLLMSManifest(command, version) {
-	const root = describeCommandNode(command) ?? {
-		name: "",
-		description: "",
-		options: [],
-		args: [],
-		subcommands: []
-	};
+function failureValue(exit) {
+	if (!Exit.isFailure(exit)) return;
+	const failure = Cause.findErrorOption(exit.cause);
+	if (Option.isSome(failure)) return failure.value;
+	const dieReason = exit.cause.reasons.find(Cause.isDieReason);
+	return dieReason === void 0 ? void 0 : dieReason.defect;
+}
+//#endregion
+//#region src/cli-error-envelope.ts
+function buildErrorEnvelope(exit, code, captured, argv) {
+	const unrecognized = unrecognizedArgumentOf(exit, argv);
 	return {
 		schemaVersion: "1.0",
-		tool: root.name,
-		version,
-		commands: [root]
+		code,
+		error: unrecognized !== void 0 ? `Received unknown argument: '${unrecognized}'` : captured.length > 0 ? captured : describeFailure(exit),
+		remediation: remediationFor(exit, code)
 	};
 }
-/** The manifest as one JSON document, ready for stdout — the U4 convention. */
-function emitLLMSManifest(command, version) {
-	return JSON.stringify(buildLLMSManifest(command, version));
-}
 //#endregion
-//#region src/OutputModeConsoleState.ts
+//#region src/console-capture.ts
 /**
 * U6 — the machine-mode `Console` layer (KTD3, R7).
 *
@@ -580,96 +914,108 @@ function resetCapturedConsole() {
 	timeByLabel.clear();
 }
 //#endregion
-//#region src/Survivors.workflow.ts
+//#region src/cli-machine-output.ts
 /**
-* The decision's helper closure reaches three language built-ins the purity
-* gate cannot resolve as globals, so each is bound at module scope and the
-* helpers reference the bindings: `isArray` keeps `Array.isArray`'s narrow,
-* `objectEntries`/`objectFromEntries`/`objectKeys` keep `Object`'s trio, and
-* `stringify` keeps `JSON.stringify`'s exact text.
+* Machine mode emits the U4 verdict envelope for a run that produced no
+* mutants and no report file: a `--survivors` run with zero survivors (AE3)
+* or a successful `--dryRunOnly` run that ended before the mutation
+* pipeline. The envelope carries a null score and an empty mutant list and is
+* written as the terminal `verdict` line of the stdout stream (U6), carrying
+* the run id the stream header already opened with (KTD11 — never a fresh
+* id). Human mode prints nothing (the sink drops in human mode).
 */
-const isArray = Array.isArray;
-const { entries: objectEntries, fromEntries: objectFromEntries, keys: objectKeys } = Object;
-const stringify = JSON.stringify;
-/**
-* U8 — survivor re-run admission (R10, R11, KTD6, KTD7).
-*
-* The `--survivors` run re-tests exactly the mutants that survived a previous
-* run. Its input is the previous run's mutation report, and the run is
-* admitted only when a single structural hash of the resolved options, the
-* recorded framework version, and the per-file source content all match the
-* current run (KTD6). Because thresholds live inside the resolved options, a
-* threshold-only change is caught for free. Every rejection exits 2 with a
-* remediation naming the full run to do first; zero survivors exits 0 with a
-* null score and writes no new report (AE3); and a report written by a
-* survivors run is never admitted as the input of another survivors run
-* (KTD7), so chaining two survivors runs fails loudly instead of re-testing a
-* shrunken or stale set.
-*
-* All functions here are pure over their inputs — no file I/O — so the
-* admission logic is fixture-testable in seconds.
-*/
-/** The path a `--survivors` run reads when no `survivorsPriorReport` is configured. */
-const DEFAULT_SURVIVORS_PRIOR_REPORT = "reports/mutation-report.json";
-/**
-* The remediation every rejection carries (R10): name the full run to do
-* first, never the survivors run itself.
-*/
-const SURVIVORS_RUN_FIRST_REMEDIATION = "run a full `stryker run` first, then re-run with --survivors";
-/**
-* The survivors-run bookkeeping keys carried in the resolved options. They
-* are run mechanics, not configuration: a survivors run adds them, so without
-* stripping them the current run's hash would differ from the prior full
-* run's hash for the very same configuration. Their presence in a report's
-* embedded config is also the marker that the report was produced by a
-* survivors run (KTD7).
-*/
-const SURVIVORS_BOOKKEEPING_KEYS = ["survivorsPriorReport"];
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !isArray(value);
-}
-/**
-* The resolved options without the survivors-run bookkeeping keys, so both
-* sides of the admission hash describe the same configuration.
-*/
-function stripSurvivorsKeys(config) {
-	if (!isRecord(config)) return {};
-	const rest = { ...config };
-	for (const key of SURVIVORS_BOOKKEEPING_KEYS) delete rest[key];
-	return rest;
+function emitNullScoreVerdict(stream, mode, thresholds, config, basePath, pathService) {
+	const envelope = buildVerdictEnvelope({
+		schemaVersion: "1.0",
+		files: {},
+		thresholds,
+		projectRoot: basePath,
+		config,
+		framework: {
+			name: "StrykerJS",
+			version: strykerVersion
+		}
+	}, mode.mode, mode.signal, stream.runId, basePath, [], pathService);
+	stream.sink({
+		kind: "verdict",
+		...envelope
+	});
 }
 /**
-* A report written by a survivors run embeds the bookkeeping key in its
-* `config` (the report helper writes the resolved options). Such a report is
-* never a valid input for another survivors run (KTD7): without this check
-* the second run would either re-read a shrunken set or re-test a stale one.
+* Emits the machine-mode output from the run's finalizer — it runs on
+* success, failure and interruption alike (R30): a failed run writes the
+* `error` terminal event as the last line of the stdout stream; a successful
+* run whose only console output was the framework's help/version rendering
+* emits that captured document as the `help` terminal event, so `--help` in
+* machine mode never leaks an ANSI document. A successful run with an empty
+* buffer (the normal verdict path) emits nothing extra — the run already
+* wrote its terminal `verdict` line through the same module — unless the
+* stream is still open, which means the run never reached a verdict (the
+* `--dryRunOnly` early return): then a null-score `verdict` closes the
+* stream so the last stdout line is always a terminal event (R5).
 */
-function wasProducedBySurvivorsRun(priorReport) {
-	const config = priorReport.config;
-	return isRecord(config) && "survivorsPriorReport" in config;
+function emitMachineModeOutput(stream, mode, exit, code, argv, basePath, pathService) {
+	return Effect.gen(function* () {
+		const captured = readCapturedConsole();
+		const value = failureValue(exit);
+		if (Exit.isFailure(exit) && S.is(CliError.ShowHelp)(value) && value.errors.length === 0) {
+			const document = {
+				kind: "help",
+				schemaVersion: "1.0",
+				code: 0,
+				help: captured
+			};
+			stream.sink(document);
+			return;
+		}
+		if (Exit.isFailure(exit)) {
+			stream.sink({
+				kind: "error",
+				...buildErrorEnvelope(exit, code, captured, argv)
+			});
+			return;
+		}
+		if (captured.length > 0) {
+			const document = {
+				kind: "help",
+				schemaVersion: "1.0",
+				code: 0,
+				help: captured
+			};
+			stream.sink(document);
+			return;
+		}
+		if (stream.isOpen()) emitNullScoreVerdict(stream, mode, (yield* defaultOptions).thresholds, {}, basePath, pathService);
+	});
 }
+//#endregion
+//#region src/survivors-bookkeeping.ts
+/** The path a `--survivors` run reads when no `survivorsPriorReport` is configured. */
+const DEFAULT_SURVIVORS_PRIOR_REPORT = "reports/mutation-report.json";
+//#endregion
+//#region src/survivors-hashing.ts
+const { entries: objectEntries$1, fromEntries: objectFromEntries } = Object;
 /**
-* The sha256 content hash both sides of the admission comparison use: the
-* current run's source files and the sources the prior report embeds. The
-* digest capability is supplied by the caller.
+* The content hash of one source file.
+*
+* Thin by design: the digest is the caller's capability, and naming the call
+* keeps every hashing site in the admission path reading the same way.
 */
 function sourceContentHash(content, hash) {
 	return hash(content);
 }
 /**
-* Serializes the hash input with keys sorted at every level, so the hash is a
-* pure function of the data and not of object key insertion order. The shape
-* is pinned by a golden snapshot test: a serialization change here fails
-* loudly instead of silently invalidating every prior report in the wild.
+* The per-file source hashes of the sources a prior report embeds.
+*
+* The current run's side of the comparison is gathered by the shell from disk;
+* this is the recorded side, read back out of the report.
 */
-function serializeSurvivorsHashInput(input) {
-	return stringify(sortKeys(input));
-}
-function sortKeys(value) {
-	if (isArray(value)) return value.map(sortKeys);
-	if (isRecord(value)) return objectFromEntries(objectKeys(value).sort().map((key) => [key, sortKeys(value[key])]));
-	return value;
+function priorSourceHashes(priorReport, hashContent) {
+	return objectFromEntries(objectEntries$1(priorReport.files).map(([file, fileResult]) => [file, sourceContentHash(fileResult.source, hashContent)]));
 }
+//#endregion
+//#region src/survivors-mutants.ts
+const { entries: objectEntries } = Object;
 /**
 * Converts a report mutant (1-based schema location) into the internal mutant
 * shape a run consumes (0-based positions, absolute file name) — the exact
@@ -711,11 +1057,11 @@ function extractSurvivors(priorReport, resolveAbsolutePath) {
 * ranges: the report's 1-based lines with the internal 0-based columns,
 * relative file names, deduplicated in first-seen order.
 */
-function survivorMutateSpans(survivors) {
+function survivorMutateSpans(survivors, basePath, pathService) {
 	const spans = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const survivor of survivors) {
-		const file = toRelativeNormalizedFileName(survivor.fileName);
+		const file = toRelativeNormalizedFileName(survivor.fileName, basePath, pathService);
 		const { start, end } = survivor.location;
 		const span = `${file}:${start.line + 1}:${start.column}-${end.line + 1}:${end.column}`;
 		if (!seen.has(span)) {
@@ -725,58 +1071,8 @@ function survivorMutateSpans(survivors) {
 	}
 	return spans;
 }
-/**
-* The mutant shape the admission carries, named once because both the decision's
-* `Admitted` payload and the command's precomputed survivor list are the same shape.
-*/
-const MutantShape = S.Struct({
-	id: S.String,
-	fileName: S.String,
-	mutatorName: S.String,
-	replacement: S.String,
-	location: S.Struct({
-		start: S.Struct({
-			line: S.Finite,
-			column: S.Finite
-		}),
-		end: S.Struct({
-			line: S.Finite,
-			column: S.Finite
-		})
-	})
-});
-/**
-* The prior report as a document, decoded at the boundary. Module-internal: consumers
-* get {@link decodePriorReport}, not the schema, so the report's wire shape is not a
-* surface commitment and the codec has exactly one caller.
-*
-* `status` is a bare string rather than the closed status set on purpose: the decide only
-* compares it to `'Survived'`, so a report written by a newer engine that added a status
-* must not be refused for carrying one.
-*/
-const PriorReportDocument = S.Struct({
-	config: S.optional(S.Record(S.String, S.Unknown)),
-	framework: S.optional(S.Struct({ version: S.optional(S.String) })),
-	files: S.Record(S.String, S.Struct({
-		source: S.String,
-		mutants: S.Array(S.Struct({
-			id: S.String,
-			mutatorName: S.String,
-			replacement: S.optional(S.String),
-			status: S.String,
-			location: S.Struct({
-				start: S.Struct({
-					line: S.Finite,
-					column: S.Finite
-				}),
-				end: S.Struct({
-					line: S.Finite,
-					column: S.Finite
-				})
-			})
-		}))
-	}))
-});
+//#endregion
+//#region src/survivors-report.ts
 /**
 * Decodes a prior report read from disk. Pure, so it runs in the decode phase, whose
 * `Left` is fatal by construction — it reaches the derived error channel and no write
@@ -784,166 +1080,11 @@ const PriorReportDocument = S.Struct({
 * a third-party report type.
 */
 const decodePriorReport = S.decodeUnknownResult(PriorReportDocument);
-/**
-* The prior report's facts the decision reads: its embedded configuration, which carries
-* both the compared options and the survivors-run provenance marker, and the engine
-* version it recorded. The report's files are not here — the survivors and the per-file
-* source hashes derived from them need capabilities the command cannot hold, so they
-* arrive already computed.
-*/
-var PriorReportFacts = class extends S.Class("PriorReportFacts")({
-	config: S.Record(S.String, S.Unknown),
-	frameworkVersion: S.UndefinedOr(S.String)
-}) {};
-/**
-* The command of the admission workflow: a schema class, because `Workflow.make`
-* constrains its first argument on the class value and a declared interface produces no
-* value to pass. Every field is pure data — the two capabilities the previous shape
-* carried, a digest function and a path resolver, can never be schema fields, so their
-* results arrive precomputed from the decode phase instead.
-*/
-var AdmitSurvivorsRunCommand = class extends S.Class("AdmitSurvivorsRunCommand")({
-	/**
-	* The prior run's report facts, `undefined` when no report exists — the run cannot be
-	* admitted without one ('no-report'). Explicitly nullable rather than key-optional: a
-	* missing report is a state the edge determined and states, not a key it forgot.
-	*/
-	priorReport: S.UndefinedOr(PriorReportFacts),
-	/** The current run's resolved options (defaults + config file + CLI). */
-	currentConfig: S.Record(S.String, S.Unknown),
-	/** The current CLI/framework version (`strykerVersion`). */
-	frameworkVersion: S.String,
-	/**
-	* Per-file content hashes of the current source, keyed by the prior report's relative
-	* file keys. The prior side is hashed from the sources the report embeds, so an editor
-	* save that shifts line ranges — which would silently re-test a different mutant than
-	* the one that survived — is caught here.
-	*/
-	sourceContentHashes: S.Record(S.String, S.String),
-	/** The same hashes for the sources the prior report embeds, computed at the edge. */
-	priorSourceHashes: S.Record(S.String, S.String),
-	/** The prior report's survivors, already converted to the internal mutant shape. */
-	priorSurvivors: S.Array(MutantShape)
-}) {};
-const NO_REPORT_DETAIL = "No prior mutation report found — a --survivors run needs the report of a previous run.";
-const SURVIVORS_RUN_SOURCE_DETAIL = "The prior mutation report was itself produced by a --survivors run, so it is not a valid input for another one.";
-const MISMATCH_DETAIL = "The prior mutation report does not match the current run (resolved options, framework version, or source content differ).";
-/** The per-file source hashes of the sources the prior report embeds. */
-function priorSourceHashes(priorReport, hashContent) {
-	return objectFromEntries(objectEntries(priorReport.files).map(([file, fileResult]) => [file, sourceContentHash(fileResult.source, hashContent)]));
-}
-/**
-* Whether the admission inputs agree: the prior report's embedded resolved options,
-* framework version and source content against the current run's.
-*
-* The comparison is on the canonical serializations rather than digests of them. Equal
-* serializations are equal runs, so the digest was a lossy restatement of the check that
-* also demanded a capability no command can carry.
-*/
-function hashesMatch(priorReport, input) {
-	return serializeSurvivorsHashInput({
-		resolvedOptions: stripSurvivorsKeys(priorReport.config),
-		frameworkVersion: priorReport.frameworkVersion,
-		sourceContentHashes: input.priorSourceHashes
-	}) === serializeSurvivorsHashInput({
-		resolvedOptions: stripSurvivorsKeys(input.currentConfig),
-		frameworkVersion: input.frameworkVersion,
-		sourceContentHashes: input.sourceContentHashes
-	});
-}
-const rejection = (reason, detail) => ({
-	kind: "reject",
-	reason,
-	remediation: `${detail} ${SURVIVORS_RUN_FIRST_REMEDIATION}`
-});
-function admissionVerdict(input) {
-	const priorReport = input.priorReport;
-	if (priorReport === void 0) return rejection("no-report", NO_REPORT_DETAIL);
-	if (wasProducedBySurvivorsRun(priorReport)) return rejection("mismatch", SURVIVORS_RUN_SOURCE_DETAIL);
-	if (input.priorSurvivors.length === 0) return { kind: "no-survivors" };
-	if (!hashesMatch(priorReport, input)) return rejection("mismatch", MISMATCH_DETAIL);
-	return {
-		kind: "admit",
-		survivors: input.priorSurvivors
-	};
-}
-const SurvivorsAdmissionTypeId = Symbol.for("@systemfsoftware/stryker-js-cli/SurvivorsAdmission");
-var Admitted = class extends S.TaggedClass()("Admitted", { survivors: S.Array(MutantShape) }) {
-	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
-};
-var NoSurvivors = class extends S.TaggedClass()("NoSurvivors", {}) {
-	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
-};
-S.Union([Admitted, NoSurvivors]);
-var SurvivorsRejection = class extends S.TaggedError()("SurvivorsRejection", {
-	reason: S.Literals(["no-report", "mismatch"]),
-	remediation: S.String
-}) {
-	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
-};
-/**
-* The survivors admission decision: the classification `admissionVerdict`
-* produces, assigned to the workflow channels — one arm per kind, no guard
-* chain. A missing report, a survivors-sourced report and a hash mismatch are
-* the same reject outcome with different reasons; only the rejection's
-* remediation names the full run to do first (R10).
-*/
-const admitSurvivorsRun = Workflow.make(AdmitSurvivorsRunCommand, (command) => Match.value(admissionVerdict(command)).pipe(Match.discriminator("kind")("reject", (verdict) => Result.fail(SurvivorsRejection.make({
-	reason: verdict.reason,
-	remediation: verdict.remediation
-}))), Match.discriminator("kind")("no-survivors", () => Result.succeed(NoSurvivors.make())), Match.discriminator("kind")("admit", (verdict) => Result.succeed(Admitted.make({ survivors: verdict.survivors }))), Match.exhaustive));
-//#endregion
-//#region src/SurvivorsExit.ts
-/** The exit class a rejected survivors run exits with (R6: exit 2). */
-const SURVIVORS_REJECT_EXIT_CLASS = ExitClass.ConfigError;
-//#endregion
-//#region src/cli-request.schema.ts
-const RunRequestSchema = S.TaggedStruct("run", {
-	options: S.Any,
-	survivors: S.Boolean
-});
-const LlmsRequestSchema = S.TaggedStruct("llms", { document: S.Any });
-S.Union([RunRequestSchema, LlmsRequestSchema]);
 //#endregion
-//#region src/StrykerCliExecutor.ts
-/**
-* The default run: binds the host-resolved run options (the sink, the mode,
-* the timing) to a fresh `Stryker` and runs mutation testing.
-*/
-const defaultRunMutationTest = (hostOptions) => (options) => new Stryker(options, hostOptions).runMutationTest();
-/**
-* The machine-mode `Console` layer, bundled so the transport (which resolves
-* the mode) can provide it without importing the state cell. Human mode
-* provides no layer — effect's own default console is the prose rendering
-* (OutputModeConsoleState.ts).
-*/
-const strykerCliConsoleLayers = { machine: machineConsoleLayer };
-const SIGNAL_NUMBERS = Object.freeze({
-	SIGINT: 2,
-	SIGTERM: 15
-});
+//#region src/cli-survivors-admission.ts
 const hashContent = (content) => createHash("sha256").update(content, "utf-8").digest("hex");
 const resolveAbsolutePath = (file) => resolve(file);
 /**
-* The host options a run is bound to: the sink, the mode, the timing and the
-* log descriptor chosen by the mode — machine mode keeps stdout exclusively
-* for the NDJSON stream, so the logging backend is pointed at stderr; human
-* mode keeps the stdout sink. The fix is the descriptor, never the log level.
-*/
-function hostOptionsOf(mode, stream) {
-	return {
-		loggerConsoleOut: mode.mode === "machine" ? process.stderr : process.stdout,
-		showColors: isColorEnabled(mode, process.env["NO_COLOR"]),
-		runEventSink: stream.sink,
-		runId: stream.runId,
-		resolvedMode: mode,
-		progressEnabled: isProgressEnabled(mode),
-		clearTextEnabled: mode.mode === "human",
-		runStartedAt: stream.startedAt,
-		reporterPluginModules: [import.meta.resolve("@systemfsoftware/stryker-js-mutation-report/stryker-plugins")]
-	};
-}
-/**
 * The survivors admission, as a description whose phases chain by type and
 * read in the order they run. The read gathers the admission's whole input
 * product — resolved options, prior report and the current source hashes —
@@ -954,68 +1095,56 @@ function hostOptionsOf(mode, stream) {
 * stashed context back and dispatches the decision to the verdict/run,
 * failing the run with a rejection.
 */
-const survivorsAdmissionDescription = (runMutationTest, stream, mode, runContext) => pipe(
-	Cell.read((cliOptions) => Effect.promise(() => resolveSurvivorsRunOptions(cliOptions)).pipe(Effect.flatMap((resolvedOptions) => {
-		const priorReportPath = priorReportPathOf(resolvedOptions);
-		const read = readPriorReport(priorReportPath);
-		return Ref.set(runContext, {
-			resolvedOptions,
-			priorReportPath
-		}).pipe(Effect.as({
-			resolvedOptions,
-			priorReportRaw: read.raw,
-			priorReportFound: read.found,
-			priorReportPath,
-			sourceContentHashes: currentSourceHashesFor(priorReportFileKeys(read.raw))
-		}));
-	}))),
-	/**
-	* The one place the prior report is decoded, and the one place the two capabilities
-	* are applied. A report that was never there yields a command with no facts, which
-	* the decider rejects as `no-report`; a report that was there and does not decode
-	* yields a `Left`, which stops the run before the decider sees it.
-	*/
-	Cell.decode(({ resolvedOptions, priorReportRaw, priorReportFound, sourceContentHashes }) => {
-		if (!priorReportFound) return Result.succeed(AdmitSurvivorsRunCommand.make({
-			priorReport: void 0,
-			currentConfig: resolvedOptions,
-			frameworkVersion: strykerVersion,
-			sourceContentHashes,
-			priorSourceHashes: {},
-			priorSurvivors: []
-		}));
-		return Result.map(decodePriorReport(priorReportRaw), (document) => AdmitSurvivorsRunCommand.make({
-			priorReport: PriorReportFacts.make({
-				config: document.config ?? {},
-				frameworkVersion: document.framework?.version
-			}),
-			currentConfig: resolvedOptions,
-			frameworkVersion: strykerVersion,
-			sourceContentHashes,
-			priorSourceHashes: priorSourceHashes(document, hashContent),
-			priorSurvivors: extractSurvivors(document, resolveAbsolutePath)
-		}));
-	}),
-	Cell.decide(admitSurvivorsRun),
-	Cell.encode((outcome) => outcome),
-	Cell.write((outcome) => Effect.flatMap(Ref.get(runContext), (context) => {
-		if (context === void 0) return Effect.die("the survivors admission read must run before its write");
-		const { resolvedOptions, priorReportPath } = context;
-		return Result.match(outcome, {
-			onSuccess: (decision) => Match.value(decision).pipe(Match.tag("NoSurvivors", () => Effect.sync(() => emitEmptySurvivorsVerdict(stream, mode, resolvedOptions))), Match.tag("Admitted", (admitted) => {
-				const restricted = {
-					...resolvedOptions,
-					survivors: admitted.survivors,
-					mutate: survivorMutateSpans(admitted.survivors),
-					survivorsPriorReport: priorReportPath,
-					incremental: false
-				};
-				return Effect.promise(() => runMutationTest(restricted));
-			}), Match.orElse(() => Effect.die("unreachable admission decision variant"))),
-			onFailure: (rejection) => Effect.fail(rejection)
-		});
-	}))
-);
+const survivorsAdmissionDescription = (runMutationTest, stream, mode, runContext, basePath) => pipe(Cell.read((cliOptions) => Effect.flatMap(Path.Path, (pathService) => resolveSurvivorsRunOptions(cliOptions, basePath).pipe(Effect.flatMap((resolvedOptions) => {
+	const priorReportPath = priorReportPathOf(resolvedOptions);
+	const read = readPriorReport(priorReportPath);
+	return Ref.set(runContext, {
+		resolvedOptions,
+		priorReportPath,
+		pathService
+	}).pipe(Effect.as({
+		resolvedOptions,
+		priorReportRaw: read.raw,
+		priorReportFound: read.found,
+		priorReportPath,
+		sourceContentHashes: currentSourceHashesFor(priorReportFileKeys(read.raw))
+	}));
+})))), Cell.decode(({ resolvedOptions, priorReportRaw, priorReportFound, sourceContentHashes }) => {
+	if (!priorReportFound) return Result.succeed(AdmitSurvivorsRunCommand.make({
+		priorReport: void 0,
+		currentConfig: resolvedOptions,
+		frameworkVersion: strykerVersion,
+		sourceContentHashes,
+		priorSourceHashes: {},
+		priorSurvivors: []
+	}));
+	return Result.map(decodePriorReport(priorReportRaw), (document) => AdmitSurvivorsRunCommand.make({
+		priorReport: PriorReportFacts.make({
+			config: document.config ?? {},
+			frameworkVersion: document.framework?.version
+		}),
+		currentConfig: resolvedOptions,
+		frameworkVersion: strykerVersion,
+		sourceContentHashes,
+		priorSourceHashes: priorSourceHashes(document, hashContent),
+		priorSurvivors: extractSurvivors(document, resolveAbsolutePath)
+	}));
+}), Cell.decide(admitSurvivorsRun), Cell.encode((outcome) => outcome), Cell.write((outcome) => Effect.flatMap(Ref.get(runContext), (context) => {
+	if (context === void 0) return Effect.die("the survivors admission read must run before its write");
+	const { resolvedOptions, priorReportPath, pathService } = context;
+	return Result.match(outcome, {
+		onSuccess: (decision) => Match.value(decision).pipe(Match.tag("NoSurvivors", () => Effect.sync(() => emitNullScoreVerdict(stream, mode, resolvedOptions.thresholds, resolvedOptions, basePath, pathService))), Match.tag("Admitted", (admitted) => {
+			return runMutationTest({
+				...resolvedOptions,
+				survivors: admitted.survivors,
+				mutate: survivorMutateSpans(admitted.survivors, basePath, pathService),
+				survivorsPriorReport: priorReportPath,
+				incremental: false
+			}).pipe(Effect.orDie);
+		}), Match.orElse(() => Effect.die("unreachable admission decision variant"))),
+		onFailure: (rejection) => Effect.fail(rejection)
+	});
+})));
 /**
 * The `--survivors` request: re-test exactly the prior report's survivor set.
 * The survivors flag was parsed as a boolean; the admission decides between
@@ -1029,292 +1158,86 @@ const survivorsAdmissionDescription = (runMutationTest, stream, mode, runContext
 * is made; it is in this signature because the phase types put it there, not because the
 * admission chose it.
 */
-function runSurvivorsAdmission(runMutationTest, stream, mode, cliOptions) {
+function runSurvivorsAdmission(runMutationTest, stream, mode, cliOptions, basePath) {
 	return Effect.gen(function* () {
 		const admissionContext = yield* Ref.make(void 0);
-		return yield* Cell.apply(survivorsAdmissionDescription(runMutationTest, stream, mode, admissionContext), cliOptions);
+		return yield* Cell.apply(survivorsAdmissionDescription(runMutationTest, stream, mode, admissionContext, basePath), cliOptions);
 	});
 }
-/**
-* Resolves the current options the same way the pipeline does — defaults +
-* config file + CLI, validated against the fork schema (which carries the
-* survivors-run properties). The admission hash compares these resolved
-* options against the prior report's embedded config.
-*/
-function resolveSurvivorsRunOptions(cliOptions) {
-	return new ConfigReader(noopLogger, new OptionsValidator(forkCoreSchema, noopLogger)).readConfig(cliOptions);
+function resolveSurvivorsRunOptions(cliOptions, basePath) {
+	return readConfig(cliOptions, noopLogger, forkCoreSchema, basePath);
 }
-/**
-* The prior report a `--survivors` run reads: the `survivorsPriorReport`
-* config option when set, else the default path. The report path is run
-* bookkeeping, never a CLI flag.
-*/
 function priorReportPathOf(resolved) {
 	const configured = resolved["survivorsPriorReport"];
 	return typeof configured === "string" ? configured : DEFAULT_SURVIVORS_PRIOR_REPORT;
 }
-/**
-* Reads the prior report without validating it. Absence and malformation are different
-* outcomes and the caller must be able to tell them apart: an absent report is the
-* `no-report` rejection the decider states, while a present-but-malformed one is a decode
-* failure that stops the run. Text that is not JSON is reported as found, carrying the
-* text itself, so the codec refuses it and names what it got.
-*/
 function readPriorReport(priorReportPath) {
 	let text;
-	try {
-		text = readFileSync(priorReportPath, "utf-8");
-	} catch {
-		return {
-			found: false,
-			raw: void 0
-		};
-	}
-	try {
-		return {
-			found: true,
-			raw: JSON.parse(text)
-		};
-	} catch {
-		return {
-			found: true,
-			raw: text
-		};
-	}
-}
-/**
-* The relative file names a report claims, read structurally rather than through the
-* codec because the current sources must be hashed before the report is decoded — the
-* read phase does the disk I/O, and the keys are what tell it which files to read. An
-* unrecognisable report yields no keys and is refused a phase later by the codec.
-*/
-function priorReportFileKeys(raw) {
-	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return [];
-	if (!("files" in raw)) return [];
-	const files = raw.files;
-	if (typeof files !== "object" || files === null || Array.isArray(files)) return [];
-	return Object.keys(files);
-}
-function readSourceFile(file) {
-	try {
-		return readFileSync(file, "utf-8");
-	} catch {
-		return "";
-	}
-}
-/**
-* The per-file content hashes of the current sources, keyed by the relative file names
-* the prior report uses — the current side of the admission comparison. The prior side is
-* hashed from the sources the report embeds, in the decode phase.
-*/
-function currentSourceHashesFor(files) {
-	const hashes = {};
-	for (const file of files) hashes[file] = sourceContentHash(readSourceFile(file), hashContent);
-	return hashes;
-}
-/**
-* Machine mode emits the U4 verdict envelope for a run that produced no
-* mutants and no report file: a `--survivors` run with zero survivors (AE3)
-* or a successful `--dryRunOnly` run that ended before the mutation
-* pipeline. The envelope carries a null score and an empty mutant list and is
-* written as the terminal `verdict` line of the stdout stream (U6), carrying
-* the run id the stream header already opened with (KTD11 — never a fresh
-* id). Human mode prints nothing (the sink drops in human mode).
-*/
-function emitNullScoreVerdict(stream, mode, thresholds, config) {
-	const report = {
-		schemaVersion: "1.0",
-		files: {},
-		thresholds,
-		projectRoot: process.cwd(),
-		config,
-		framework: {
-			name: "StrykerJS",
-			version: strykerVersion
-		}
-	};
-	const envelope = buildVerdictEnvelope(report, mode.mode, mode.signal, stream.runId);
-	stream.sink({
-		kind: "verdict",
-		...envelope
-	});
-}
-/**
-* The `--survivors` zero-survivor path: the prior report held no survivors,
-* so the run emits the null-score verdict without starting the pipeline. The
-* full resolved options ride along as the report's embedded config (KTD7).
-*/
-function emitEmptySurvivorsVerdict(stream, mode, resolved) {
-	emitNullScoreVerdict(stream, mode, resolved.thresholds, resolved);
-}
-/**
-* The contextual remediation for a failure, picked from the cause's shape:
-* signal terminations (POSIX `128 + n`) are called out as interruptions,
-* usage/parse errors point at `--help`, config errors name the offending file
-* (ConfigError messages carry it), and rejected survivors runs name the full
-* run to do first. Everything else points at the report file and the verdict
-* envelope, which is where a runtime failure's detail already is.
-*/
-function remediationFor(exit, code) {
-	if (code > 128) return "the run was interrupted by a signal; re-run it to continue";
-	const value = failureValue(exit);
-	if (value !== void 0) {
-		if (CliError.isCliError(value)) return "re-run with --help to see the full usage";
-		if (value instanceof ConfigError) return `check the config file: ${value.message}`;
-		if (S.is(SurvivorsRejection)(value)) return value.remediation;
-	}
-	return "see --reportFile or the verdict envelope on stdout";
-}
-/**
-* The failure's own text, used when the capture buffer is empty — a failure
-* stryker reported through its own logger rather than the framework's
-* `Console`. Falls back to a rendered cause.
-*/
-function describeFailure(exit) {
-	if (Exit.isFailure(exit)) {
-		const value = failureValue(exit);
-		if (value !== void 0) {
-			if (S.is(SurvivorsRejection)(value)) return value.remediation;
-			if (value instanceof Error) return value.message;
-			if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol") return String(value);
-			return Object.prototype.toString.call(value);
-		}
-		return Cause.pretty(exit.cause);
-	}
-	return "";
-}
-/**
-* The argument the framework reports it does not know, named the way the wire
-* contract spells it. The v4 parser fails wrapped in a ShowHelp whose errors
-* carry the offending flag or operand; when the unrecognized flag was given a
-* separate value (`--format text`), the value is the token the old parser
-* reported, so the token after the flag is named when one was given.
-*/
-function unrecognizedArgumentOf(exit, argv) {
-	if (!Exit.isFailure(exit)) return;
-	const value = failureValue(exit);
-	if (value === void 0 || !CliError.isCliError(value)) return;
-	const errors = S.is(CliError.ShowHelp)(value) ? value.errors : [value];
-	for (const error of errors) {
-		if (S.is(CliError.UnrecognizedOption)(error)) {
-			const at = argv.indexOf(error.option);
-			const next = at >= 0 ? argv[at + 1] : void 0;
-			return next !== void 0 && !next.startsWith("-") ? next : error.option;
-		}
-		if (S.is(CliError.UnexpectedArgument)(error)) return error.arguments[0];
-		if (S.is(CliError.UnknownSubcommand)(error)) return error.subcommand;
-	}
-}
-/**
-* The first typed error in the exit's cause. The framework fails with
-* `Cause.fail` (usage errors); the run handler is `Effect.promise`, whose
-* rejected promises surface as *defects* (`Die` reasons) rather than
-* failures — so stryker's own ConfigError/StrykerError values arrive there
-* and must be read from the cause's `Die` reasons.
-*/
-function failureValue(exit) {
-	if (!Exit.isFailure(exit)) return;
-	const failure = Cause.findErrorOption(exit.cause);
-	if (Option.isSome(failure)) return failure.value;
-	const dieReason = exit.cause.reasons.find(Cause.isDieReason);
-	return dieReason === void 0 ? void 0 : dieReason.defect;
-}
-function buildErrorEnvelope(exit, code, captured, argv) {
-	const unrecognized = unrecognizedArgumentOf(exit, argv);
-	return {
-		schemaVersion: "1.0",
-		code,
-		error: unrecognized !== void 0 ? `Received unknown argument: '${unrecognized}'` : captured.length > 0 ? captured : describeFailure(exit),
-		remediation: remediationFor(exit, code)
-	};
-}
-/**
-* Emits the machine-mode output from the run's finalizer — it runs on
-* success, failure and interruption alike (R30): a failed run writes the
-* `error` terminal event as the last line of the stdout stream; a successful
-* run whose only console output was the framework's help/version rendering
-* emits that captured document as the `help` terminal event, so `--help` in
-* machine mode never leaks an ANSI document. A successful run with an empty
-* buffer (the normal verdict path) emits nothing extra — the run already
-* wrote its terminal `verdict` line through the same module — unless the
-* stream is still open, which means the run never reached a verdict (the
-* `--dryRunOnly` early return): then a null-score `verdict` closes the
-* stream so the last stdout line is always a terminal event (R5).
-*/
-function emitMachineModeOutput(stream, mode, exit, code, argv) {
-	const captured = readCapturedConsole();
-	const value = failureValue(exit);
-	if (Exit.isFailure(exit) && S.is(CliError.ShowHelp)(value) && value.errors.length === 0) {
-		const document = {
-			kind: "help",
-			schemaVersion: "1.0",
-			code: 0,
-			help: captured
+	try {
+		text = readFileSync(priorReportPath, "utf-8");
+	} catch {
+		return {
+			found: false,
+			raw: void 0
 		};
-		stream.sink(document);
-		return;
-	}
-	if (Exit.isFailure(exit)) {
-		stream.sink({
-			kind: "error",
-			...buildErrorEnvelope(exit, code, captured, argv)
-		});
-		return;
 	}
-	if (captured.length > 0) {
-		const document = {
-			kind: "help",
-			schemaVersion: "1.0",
-			code: 0,
-			help: captured
+	try {
+		return {
+			found: true,
+			raw: JSON.parse(text)
+		};
+	} catch {
+		return {
+			found: true,
+			raw: text
 		};
-		stream.sink(document);
-		return;
 	}
-	if (stream.isOpen()) emitNullScoreVerdict(stream, mode, defaultOptions.thresholds, {});
 }
-/**
-* A rejected config reaches the finalizer as a typed failure or as a defect
-* depending on where the validator threw, and typed-inject may have wrapped
-* it, so both channels are searched and each candidate is unwrapped.
-*/
-function carriesConfigError(cause) {
-	for (const reason of cause.reasons) {
-		const candidate = Cause.isFailReason(reason) ? reason.error : Cause.isDieReason(reason) ? reason.defect : void 0;
-		if (candidate !== void 0 && (candidate instanceof ConfigError || retrieveCause(candidate) instanceof ConfigError)) return true;
+function priorReportFileKeys(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return [];
+	if (!("files" in raw)) return [];
+	const files = raw.files;
+	if (typeof files !== "object" || files === null || Array.isArray(files)) return [];
+	return Object.keys(files);
+}
+function readSourceFile(file) {
+	try {
+		return readFileSync(file, "utf-8");
+	} catch {
+		return "";
 	}
-	return false;
 }
+function currentSourceHashesFor(files) {
+	const hashes = {};
+	for (const file of files) hashes[file] = sourceContentHash(readSourceFile(file), hashContent);
+	return hashes;
+}
+//#endregion
+//#region src/cli-run.ts
+const defaultRunMutationTest = (hostOptions) => (options) => Effect.scoped(runMutationTest(defaultStages, options)).pipe(Effect.provide(makeRunLayer(hostOptions)));
 /**
-* Classifies a failed run for the finalizer: usage/parse failures
-* (`CliError` — except a bare help request, which exits 0), rejected
-* survivors runs (`SurvivorsRejection`), an unreadable prior report
-* (`S.SchemaError`) and a rejected config (`ConfigError`) all exit 2, all
-* other failures exit 1 (the framework's default). A successful run exits 0;
-* the verdict gates (U5) then resolve the final classed code.
-*
-* The report parse failure shares the survivors class deliberately. It is not a
-* verdict — the decider never sees the report — but the operator's answer is the
-* same class of answer as a rejection: the input you named cannot be used. Letting
-* it fall through to 1 would make an unusable `--survivors` input indistinguishable
-* from a crash.
+* The host options a run is bound to: the sink, the mode, the timing and the
+* log descriptor chosen by the mode — machine mode keeps stdout exclusively
+* for the NDJSON stream, so the logging backend is pointed at stderr; human
+* mode keeps the stdout sink. The fix is the descriptor, never the log level.
 */
-function resolveCliExitCode(exit) {
-	if (Exit.isSuccess(exit)) return 0;
-	if (Cause.hasInterruptsOnly(exit.cause)) return 1;
-	const failure = Cause.findErrorOption(exit.cause);
-	if (Option.isSome(failure)) {
-		const value = failure.value;
-		if (S.is(CliError.ShowHelp)(value)) return value.errors.length > 0 ? 2 : 0;
-		if (CliError.isCliError(value)) return 2;
-		if (S.is(SurvivorsRejection)(value)) return SURVIVORS_REJECT_EXIT_CLASS;
-		if (value instanceof S.SchemaError) return SURVIVORS_REJECT_EXIT_CLASS;
-	}
-	if (carriesConfigError(exit.cause)) return ExitClass.ConfigError;
-	return 1;
+function hostOptionsOf(mode, stream) {
+	return {
+		runEventSink: stream.sink,
+		runId: stream.runId,
+		resolvedMode: mode,
+		runStartedAt: stream.startedAt,
+		basePath: resolve(process.cwd()),
+		reporterPluginModules: [import.meta.resolve("@systemfsoftware/stryker-js-mutation-report/stryker-plugins")],
+		logSink: (line) => {
+			if (mode.mode === "human") process.stdout.write(line);
+			else process.stderr.write(line);
+		},
+		allowConsoleColors: isColorEnabled(mode, process.env["NO_COLOR"])
+	};
 }
 /**
-* The single operation of the CLI's executor cell: the impure shell that
+* The single operation of the CLI's run cell: the impure shell that
 * wraps the transport's command effect with the run bootstrap. It creates the
 * run's stream from the resolved mode, binds the host options a run is
 * executed with, opens the stream, runs the command effect, dispatches the
@@ -1328,22 +1251,29 @@ function resolveCliExitCode(exit) {
 */
 const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
 	const stream = yield* createRunEventStream(input.mode);
-	const runMutationTest = input.runMutationTest ?? defaultRunMutationTest(hostOptionsOf(input.mode, stream));
+	const hostOptions = hostOptionsOf(input.mode, stream);
+	const runMutationTestImpl = input.runMutationTest ?? defaultRunMutationTest(hostOptions);
+	const basePath = hostOptions.basePath;
+	const pathService = yield* Path.Path.pipe(Effect.provide(NodePath.layer));
 	let currentFiber = null;
-	let lastSignal = null;
+	const verdictOf = (value) => {
+		if (!Predicate.hasProperty(value, "verdict")) return [];
+		const candidate = value.verdict;
+		if (typeof candidate !== "number" || !isExitClass(candidate)) return [];
+		return [candidate];
+	};
 	const resolveClassedExitCode = (exit) => {
-		const signal = lastSignal;
+		const signal = input.lastSignal();
 		if (signal !== null) return 128 + signal;
 		if (Exit.isFailure(exit)) return resolveCliExitCode(exit);
-		return resolveExitCode(getPendingExitClasses(), null);
+		return resolveExitCode(verdictOf(exit.value), null);
 	};
-	const onSignal = (signal) => {
-		lastSignal = SIGNAL_NUMBERS[signal] ?? null;
+	const onSignal = () => {
 		process.removeListener("SIGINT", onSignal);
 		process.removeListener("SIGTERM", onSignal);
 		if (currentFiber !== null) currentFiber.interruptUnsafe(currentFiber.id);
 	};
-	const dispatch = (request) => Match.value(request).pipe(Match.tag("run", (runRequest) => runRequest.survivors ? runSurvivorsAdmission(runMutationTest, stream, input.mode, runRequest.options) : Effect.promise(() => runMutationTest(runRequest.options))), Match.tag("llms", (llmsRequest) => Effect.sync(() => {
+	const dispatch = (request) => Match.value(request).pipe(Match.tag("run", (runRequest) => runRequest.survivors ? runSurvivorsAdmission(runMutationTestImpl, stream, input.mode, runRequest.options, basePath).pipe(Effect.provide(makeRunLayer(hostOptions))) : runMutationTestImpl(runRequest.options).pipe(Effect.orDie)), Match.tag("llms", (llmsRequest) => Effect.sync(() => {
 		stream.ensureOpen({
 			mode: "machine",
 			signal: "flag",
@@ -1359,7 +1289,7 @@ const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
 		yield* stream.open;
 		yield* input.program;
 		const request = yield* Ref.get(input.requestRef);
-		yield* Option.match(request, {
+		return yield* Option.match(request, {
 			onNone: () => Effect.void,
 			onSome: (cliRequest) => dispatch(cliRequest)
 		});
@@ -1370,14 +1300,192 @@ const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
 	return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
 		const exit = yield* Effect.exit(restore(program));
 		const code = resolveClassedExitCode(exit);
-		input.recordExitCode(code);
-		if (input.mode.mode === "machine") emitMachineModeOutput(stream, input.mode, exit, code, input.argv);
+		if (input.mode.mode === "machine") yield* emitMachineModeOutput(stream, input.mode, exit, code, input.argv, basePath, pathService);
 		yield* stream.closeAndDrain;
 		return code;
 	}));
 });
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(node, key) {
+	const value = node[key];
+	return typeof value === "string" ? value : void 0;
+}
+function stringArrayField(node, key) {
+	const value = node[key];
+	if (!Array.isArray(value)) return [];
+	const strings = [];
+	for (const item of value) if (typeof item === "string") strings.push(item);
+	return strings;
+}
+/** The compiled shapes discriminate on `_tag`; read it once, off the record. */
+function tagOf(node) {
+	return node["_tag"];
+}
+function walkParam(param, isOptional, out) {
+	if (!isObject(param)) return;
+	switch (tagOf(param)) {
+		case "Single":
+			describeSingle(param, isOptional, out);
+			return;
+		case "Map":
+		case "Transform":
+			walkParam(param["param"], isOptional, out);
+			return;
+		case "Optional":
+			walkParam(param["param"], true, out);
+			return;
+		case "Variadic":
+			walkParam(param["param"], isOptional, out);
+			return;
+		default: return;
+	}
+}
+const PRIMITIVE_KIND = {
+	Boolean: "boolean",
+	Choice: "choice",
+	Date: "date",
+	FileParse: "file",
+	FileSchema: "file",
+	FileText: "file",
+	Float: "float",
+	Integer: "integer",
+	KeyValuePair: "key=value",
+	None: "none",
+	Path: "path",
+	Redacted: "redacted",
+	String: "text"
+};
+function kindOf(primitive) {
+	const tag = stringField(primitive, "_tag");
+	return tag === void 0 ? "unknown" : PRIMITIVE_KIND[tag] ?? tag;
+}
+function choiceValues(primitive) {
+	const keys = primitive["choiceKeys"];
+	if (!Array.isArray(keys)) return;
+	const values = [];
+	for (const key of keys) if (typeof key === "string") values.push(key);
+	return values;
+}
+/** The allowed reporter names, read from the U9 registry — the same list the plugin loader accepts. */
+const REPORTER_NAMES = strykerPlugins.filter((plugin) => plugin.kind === PluginKind.Reporter).map((plugin) => plugin.name);
+/**
+* v4 option descriptions are stored as `Option.some(string)` on the compiled
+* `Single`; the walker unwraps the option.
+*/
+function descriptionOf(single) {
+	const description = single["description"];
+	if (!isObject(description)) return "";
+	switch (tagOf(description)) {
+		case "Some": {
+			const value = description["value"];
+			return typeof value === "string" ? value : "";
+		}
+		default: return "";
+	}
+}
+function describeSingle(single, isOptional, out) {
+	const name = stringField(single, "name") ?? "";
+	const primitive = isObject(single["primitiveType"]) ? single["primitiveType"] : {};
+	const kind = kindOf(primitive);
+	const choices = name === "reporters" ? REPORTER_NAMES : kind === "choice" ? choiceValues(primitive) : void 0;
+	const description = descriptionOf(single);
+	const required = kind !== "boolean" && !isOptional;
+	const described = {
+		name,
+		aliases: stringArrayField(single, "aliases"),
+		kind,
+		required,
+		...choices !== void 0 ? { choices } : {},
+		description
+	};
+	if (single["kind"] === "argument") {
+		out.args.push({
+			name,
+			kind,
+			required,
+			description
+		});
+		return;
+	}
+	out.flags.push(described);
+}
+function walkConfigNode(node, orderedParams, out) {
+	if (!isObject(node)) return;
+	switch (tagOf(node)) {
+		case "Param": {
+			const index = node["index"];
+			const param = typeof index === "number" ? orderedParams[index] : void 0;
+			if (param !== void 0) walkParam(param, false, out);
+			return;
+		}
+		case "Array":
+			if (Array.isArray(node["children"])) for (const child of node["children"]) walkConfigNode(child, orderedParams, out);
+			return;
+		case "Nested":
+			if (isObject(node["tree"])) walkConfigTree(node["tree"], orderedParams, out);
+			return;
+		default: return;
+	}
+}
+function walkConfigTree(tree, orderedParams, out) {
+	for (const key of Object.keys(tree)) walkConfigNode(tree[key], orderedParams, out);
+}
+function describeCommandNode(node) {
+	if (!isObject(node)) return;
+	const out = {
+		flags: [],
+		args: []
+	};
+	const config = node["config"];
+	if (isObject(config) && isObject(config["tree"])) {
+		const orderedParams = Array.isArray(config["orderedParams"]) ? config["orderedParams"] : [];
+		walkConfigTree(config["tree"], orderedParams, out);
+	}
+	const subcommands = [];
+	const grouped = node["subcommands"];
+	if (Array.isArray(grouped)) for (const group of grouped) {
+		if (!isObject(group) || !Array.isArray(group["commands"])) continue;
+		for (const child of group["commands"]) {
+			const described = describeCommandNode(child);
+			if (described !== void 0) subcommands.push(described);
+		}
+	}
+	return {
+		name: stringField(node, "name") ?? "",
+		description: typeof node["description"] === "string" ? node["description"] : "",
+		options: out.flags,
+		args: out.args,
+		subcommands
+	};
+}
+/**
+* Builds the manifest document for a command, walking its compiled form (the
+* same structure the parser matches against). `version` is the tool version,
+* passed in so this module stays free of package state.
+*/
+function buildLLMSManifest(command, version) {
+	const root = describeCommandNode(command) ?? {
+		name: "",
+		description: "",
+		options: [],
+		args: [],
+		subcommands: []
+	};
+	return {
+		schemaVersion: "1.0",
+		tool: root.name,
+		version,
+		commands: [root]
+	};
+}
+/** The manifest as one JSON document, ready for stdout — the U4 convention. */
+function emitLLMSManifest(command, version) {
+	return JSON.stringify(buildLLMSManifest(command, version));
+}
 //#endregion
-//#region src/StrykerCliHandler.ts
+//#region src/stryker-cli.ts
 function createSplitter(separator) {
 	return (value) => value.split(separator).filter(Boolean);
 }
@@ -1451,7 +1559,7 @@ const runOptions = {
 		"perTest",
 		"all",
 		"off"
-	]).pipe(Flag.withDescription(`The coverage analysis strategy you want to use. Default value: "${defaultOptions.coverageAnalysis}"`), optional),
+	]).pipe(Flag.withDescription(`The coverage analysis strategy you want to use. Default value: "${RENDERED_OPTION_DEFAULTS.coverageAnalysis}"`), optional),
 	testRunner: Flag.string("testRunner").pipe(Flag.withDescription("The name of the test runner you want to use"), optional),
 	testRunnerNodeArgs: Flag.string("testRunnerNodeArgs").pipe(Flag.withDescription("A list of node args to be passed to test runner child processes. Split on spaces (commander characterization): `--testRunnerNodeArgs \"--inspect-brk --trace-warnings\"`."), Flag.map(splitOnSpace), optional),
 	reporters: Flag.string("reporters").pipe(Flag.withDescription("A comma separated list of the names of the reporter(s) you want to use"), Flag.map(splitOnComma), optional),
@@ -1464,11 +1572,11 @@ const runOptions = {
 	concurrency: Flag.string("concurrency").pipe(Flag.withAlias("c"), Flag.withDescription("Set the concurrency of workers. Stryker will always run checkers and test runners in parallel by creating worker processes (default: cpuCount - 1)"), Flag.map(parseConcurrency), optional),
 	disableBail: Flag.map(optional(Flag.boolean("disableBail")), absentWhenFalse).pipe(Flag.withDescription("Force the test runner to keep running tests, even when a mutant is already killed.")),
 	maxTestRunnerReuse: Flag.integer("maxTestRunnerReuse").pipe(Flag.withDescription("Restart each test runner worker process after `n` runs. Not recommended unless you are experiencing memory leaks that you are unable to resolve. Configuring `0` here means infinite reuse."), optional),
-	logLevel: Flag.choice("logLevel", LOG_LEVELS).pipe(Flag.withDescription(`Set the log level for the console. Possible values: fatal, error, warn, info, debug, trace and off. Default is "${defaultOptions.logLevel}"`), optional),
-	fileLogLevel: Flag.choice("fileLogLevel", LOG_LEVELS).pipe(Flag.withDescription(`Set the log level for the "stryker.log" file. Possible values: fatal, error, warn, info, debug, trace and off. Default is "${defaultOptions.fileLogLevel}"`), optional),
+	logLevel: Flag.choice("logLevel", LOG_LEVELS).pipe(Flag.withDescription(`Set the log level for the console. Possible values: fatal, error, warn, info, debug, trace and off. Default is "${RENDERED_OPTION_DEFAULTS.logLevel}"`), optional),
+	fileLogLevel: Flag.choice("fileLogLevel", LOG_LEVELS).pipe(Flag.withDescription(`Set the log level for the "stryker.log" file. Possible values: fatal, error, warn, info, debug, trace and off. Default is "${RENDERED_OPTION_DEFAULTS.fileLogLevel}"`), optional),
 	inPlace: Flag.map(optional(Flag.boolean("inPlace")), absentWhenFalse).pipe(Flag.withDescription("Determines whether or not Stryker should mutate your files in place. Note: mutating your files in place is generally not needed for mutation testing, unless you have a dependency in your project that is really dependent on the file locations (like \"app-root-path\" for example).\nWhen `true`, Stryker will override your files, but it will keep a copy of the originals in the temp directory (using `tempDirName`) and it will place the originals back after it is done. Also with `true` the `ignorePatterns` has no effect any more.\nWhen `false` (default) Stryker will work in the copy of your code inside the temp directory.")),
 	tempDirName: Flag.string("tempDirName").pipe(Flag.withDescription("Set the name of the directory that is used by Stryker as a working directory. This directory will be cleaned after a successful run"), optional),
-	cleanTempDir: Flag.string("cleanTempDir").pipe(Flag.withDescription(`Choose whether or not to clean the temp dir (which is "${defaultOptions.tempDirName}" inside the current working directory by default) after a run.\n- false: Never delete the temp dir;\n- true: Delete the tmp dir after a successful run;\n- always: Always delete the temp dir, regardless of whether the run was successful.`), Flag.map(parseCleanDirOption), optional),
+	cleanTempDir: Flag.string("cleanTempDir").pipe(Flag.withDescription(`Choose whether or not to clean the temp dir (which is "${RENDERED_OPTION_DEFAULTS.tempDirName}" inside the current working directory by default) after a run.\n- false: Never delete the temp dir;\n- true: Delete the tmp dir after a successful run;\n- always: Always delete the temp dir, regardless of whether the run was successful.`), Flag.map(parseCleanDirOption), optional),
 	survivors: Flag.map(optional(Flag.boolean("survivors")), absentWhenFalse).pipe(Flag.withDescription("Re-run only the mutants that survived a previous run. Admits against the previous run's mutation report (the `survivorsPriorReport` config option, default `reports/mutation-report.json`) and re-tests exactly the survivor set. Exits 2 with a remediation naming a full run when the report is missing, drifted, or the configuration changed; exits 0 with a null score when the report has no survivors."))
 };
 const runArgs = { configFile: Argument.optional(Argument.string("configFile")) };
@@ -1598,7 +1706,7 @@ const cliLayer = Layer.mergeAll(CliConfig.layer({ builtIns: [
 	GlobalFlag.Wizard,
 	GlobalFlag.Completions,
 	GlobalFlag.LogLevel
-] }), Path.layer, FileSystem.layerNoop({}), terminalLayer, NodeStdio.layer, Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, ChildProcessSpawner.make(() => Effect.die("no child processes"))));
+] }), Path.layer, FileSystem.layerNoop({}), terminalLayer, NodeStdio.layer, NodeChildProcessSpawner.layer.pipe(Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath$1.layer))));
 /**
 * The transport entry: builds the command tree, resolves the mode once at
 * the edge (never a second probe), provides the CLI and Console layers the
@@ -1606,19 +1714,19 @@ const cliLayer = Layer.mergeAll(CliConfig.layer({ builtIns: [
 * returns the classed exit code it computes. The executor is the I/O
 * sandwich; this function only frames it.
 */
-function strykerCliEffect(argv, runMutationTest, recordExitCode, detectMode, createRunEventStream) {
+function strykerCliEffect(argv, runMutationTest, detectMode, createRunEventStream, lastSignal) {
 	return Effect.gen(function* () {
 		const mode = detectMode();
 		const requestRef = yield* Ref.make(Option.none());
 		const command = makeStrykerCommand(requestRef);
-		const cliEffect = Command.runWith(command, { version: strykerVersion })(argv).pipe(Effect.provide(Layer.mergeAll(mode.mode === "machine" ? strykerCliConsoleLayers.machine : Layer.empty, cliLayer)));
+		const cliEffect = Command.runWith(command, { version: strykerVersion })(argv).pipe(Effect.provide(Layer.mergeAll(mode.mode === "machine" ? machineConsoleLayer : Layer.empty, cliLayer)));
 		const outcome = yield* Effect.result(runStrykerCli({
 			program: cliEffect,
 			requestRef,
 			mode,
 			runMutationTest,
-			recordExitCode,
-			argv
+			argv,
+			lastSignal
 		}, createRunEventStream));
 		return Result.isFailure(outcome) ? outcome.failure : outcome.success;
 	});
@@ -1627,19 +1735,34 @@ function strykerCliEffect(argv, runMutationTest, recordExitCode, detectMode, cre
 //#region src/main.ts
 const EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER = 1;
 process.title = "stryker";
-if (!semver.satisfies(process.version, strykerEngines.node)) throw new Error(`Node.js version ${process.version} detected. StrykerJS requires version to match ${strykerEngines.node}. Please update your Node.js version or visit https://nodejs.org/ for additional instructions`);
-const resolvedExitCode = { current: EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER };
+const lastSignal = observeTerminatingSignal();
+function isSupportedNodeVersion(version) {
+	const withoutV = version.startsWith("v") ? version.slice(1) : version;
+	const dashBase = withoutV.split("-")[0] ?? withoutV;
+	const parts = (dashBase.split("+")[0] ?? dashBase).split(".").map((p) => Number.parseInt(p, 10));
+	const major = parts[0] ?? 0;
+	const minor = parts[1] ?? 0;
+	const patch = parts[2] ?? 0;
+	if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) return false;
+	if (major !== 20) return major > 20;
+	if (minor !== 0) return minor > 0;
+	return patch >= 0;
+}
+if (!isSupportedNodeVersion(process.version)) throw new Error(`Node.js version ${process.version} detected. StrykerJS requires version to match ${strykerEngines.node}. Please update your Node.js version or visit https://nodejs.org/ for additional instructions`);
 const program = Effect.gen(function* () {
 	const outputMode = yield* OutputModeProbe;
 	const runEvents = yield* RunEventStreamPort;
-	return yield* strykerCliEffect(process.argv.slice(2), void 0, (code) => {
-		resolvedExitCode.current = code;
-	}, outputMode.detectMode, runEvents.createRunEventStream);
-}).pipe(Effect.provide(Layer.merge(OutputModeProbeLive, RunEventStreamLive).pipe(Layer.provide(NodeStdio.layer))));
+	return yield* strykerCliEffect(process.argv.slice(2), void 0, outputMode.detectMode, runEvents.createRunEventStream, lastSignal);
+}).pipe(Effect.provideService(Logger.LogToStderr, true), Effect.provide(Layer.merge(OutputModeProbeLive, RunEventStreamLive).pipe(Layer.provide(NodeStdio.layer))));
 NodeRuntime.runMain(program, {
 	disableErrorReporting: true,
-	teardown: (_exit, onExit) => {
-		onExit(resolvedExitCode.current);
+	teardown: (exit, onExit) => {
+		if (Exit.isSuccess(exit) && typeof exit.value === "number") {
+			onExit(exit.value);
+			return;
+		}
+		const signal = lastSignal();
+		onExit(signal === null ? EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER : 128 + signal);
 	}
 });
 //#endregion