@systemfsoftware/stryker-js-cli 3.1.0 → 4.0.0

package/dist/main.mjs

@@ -1,493 +1,620 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
+import * as NodePath from "@effect/platform-node-shared/NodePath";
 import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
 import * as NodeStdio from "@effect/platform-node/NodeStdio";
+import { ConfigFileUnreadableError, buildVerdictEnvelope, defaultOptions, generateRunId, makeRunLayer, readConfig, runMutationTest, strykerEngines, strykerVersion, toRelativeNormalizedFileName } from "@systemfsoftware/stryker-js-platform-node";
 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 Context from "effect/Context";
-import * as Result from "effect/Result";
-import * as CliError from "effect/unstable/cli/CliError";
+import * as Logger from "effect/Logger";
+import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
+import { Heartbeat, HelpRendered, ManifestRendered, RunEvents, RunFailed, RunStarted, VerdictReached } from "@systemfsoftware/stryker-js/Run";
+import { RENDERED_OPTION_DEFAULTS } from "@systemfsoftware/stryker-js/Schema";
 import * as Cause from "effect/Cause";
-import * as Clock from "effect/Clock";
-import * as Deferred from "effect/Deferred";
-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 Console from "effect/Console";
+import * as Fiber from "effect/Fiber";
 import * as FileSystem from "effect/FileSystem";
+import * as Match from "effect/Match";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
+import * as Queue from "effect/Queue";
 import * as Ref from "effect/Ref";
+import * as Result from "effect/Result";
+import * as S from "effect/Schema";
 import * as Terminal from "effect/Terminal";
 import * as Argument from "effect/unstable/cli/Argument";
 import * as CliConfig from "effect/unstable/cli/CliConfig";
+import * as CliError from "effect/unstable/cli/CliError";
 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 { ExitClass, highestExitClass } from "@systemfsoftware/stryker-js/ExitClass";
+import { Mutant, causeText } from "@systemfsoftware/stryker-js/Mutant";
+import * as Clock from "effect/Clock";
+import * as Formatter from "effect/Formatter";
+import * as Predicate from "effect/Predicate";
 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 * as Context from "effect/Context";
 import { pipe } from "effect/Function";
-import * as Match from "effect/Match";
-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 { 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
-/**
-* The known tool variables. Narrow per the plan — exactly
-* `['CLAUDECODE', 'CODEX_SANDBOX']` — and load-bearing rather than a
-* fallback: they cover the PTY-allocating harnesses a stdin condition would
-* have rescued.
-*/
-const TOOL_VARIABLES = ["CLAUDECODE", "CODEX_SANDBOX"];
-/**
-* Resolves the output mode by R4 precedence. Pure — reads nothing, so it is
-* fully testable; the caller supplies every input once at startup. The
-* mutually-exclusive-flags case is a caller error, returned as a `failure` so
-* the function stays total.
-*/
-function resolveMode(input) {
-	if (input.text === true && input.json === true) return Result.fail(CliError.InvalidValue.make({
-		option: "json",
-		value: "text",
-		expected: "the \"--format text\" and \"--json\" flags are mutually exclusive — use one or the other",
-		kind: "flag"
-	}));
-	if (input.text === true) return Result.succeed({
-		mode: "human",
-		signal: "flag",
-		stdoutIsTTY: input.stdoutIsTTY
-	});
-	if (input.json === true) return Result.succeed({
-		mode: "machine",
-		signal: "flag",
-		stdoutIsTTY: input.stdoutIsTTY
-	});
-	if (input.envMode !== void 0 && input.envMode.length > 0) return Result.succeed({
-		mode: input.envMode === "machine" ? "machine" : "human",
-		signal: "env",
-		stdoutIsTTY: input.stdoutIsTTY
-	});
-	if (!input.stdoutIsTTY) return Result.succeed({
-		mode: "machine",
-		signal: "tty",
-		stdoutIsTTY: false
-	});
-	if (input.agent !== void 0 && input.agent.length > 0) return Result.succeed({
-		mode: "machine",
-		signal: "agent",
-		stdoutIsTTY: true
+import * as Stdio from "effect/Stdio";
+import * as Stream from "effect/Stream";
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
+//#region src/RunOutcome.workflow.ts
+var RunOutcomeCommand = class extends S.TaggedClass()("RunOutcomeCommand", {
+	succeeded: S.Boolean,
+	signal: S.optional(S.Finite),
+	interrupted: S.Boolean,
+	helpErrorCount: S.optional(S.Finite),
+	cliError: S.Boolean,
+	unrecognized: S.optional(S.String),
+	survivorsReason: S.optional(S.Literals(["no-report", "mismatch"])),
+	survivorsDiagnostic: S.optional(S.String),
+	schemaError: S.Boolean,
+	successExitClass: S.optional(ExitClass),
+	highestExitClass: S.optional(ExitClass),
+	configDetail: S.optional(S.String),
+	diagnostic: S.optional(S.String)
+}) {};
+const CONFIG_CODE$1 = 2;
+const classCode = (exitClass) => Match.value(exitClass).pipe(Match.when("VerdictFail", () => 1), Match.when("ConfigError", () => CONFIG_CODE$1), Match.when("RuntimeError", () => 3), Match.when("InternalError", () => 4), Match.exhaustive);
+var RunOk = class extends S.TaggedClass()("RunOk", { help: S.Boolean }) {};
+var RunInterrupted = class extends S.TaggedError()("RunInterrupted", { code: S.Finite }) {};
+var RunParseFailed = class extends S.TaggedError()("RunParseFailed", { unrecognized: S.optional(S.String) }) {};
+var RunSurvivorsRejected = class extends S.TaggedError()("RunSurvivorsRejected", {
+	reason: S.Literals(["no-report", "mismatch"]),
+	diagnostic: S.optional(S.String)
+}) {};
+var RunConfigFailed = class extends S.TaggedError()("RunConfigFailed", { detail: S.optional(S.String) }) {};
+var RunFailed$1 = class extends S.TaggedError()("RunFailed", {
+	code: S.Finite,
+	diagnostic: S.optional(S.String)
+}) {};
+function classify(command) {
+	if (command.signal !== void 0) return RunInterrupted.make({ code: 128 + command.signal });
+	if (command.succeeded) {
+		if (command.successExitClass !== void 0) return RunFailed$1.make({
+			code: classCode(command.successExitClass),
+			diagnostic: command.diagnostic
+		});
+		return RunOk.make({ help: false });
+	}
+	if (command.interrupted) return RunInterrupted.make({ code: 1 });
+	if (command.helpErrorCount !== void 0) {
+		if (command.helpErrorCount > 0) return RunParseFailed.make({ unrecognized: command.unrecognized });
+		return RunOk.make({ help: true });
+	}
+	if (command.cliError) return RunParseFailed.make({ unrecognized: command.unrecognized });
+	if (command.survivorsReason !== void 0) return RunSurvivorsRejected.make({
+		reason: command.survivorsReason,
+		diagnostic: command.survivorsDiagnostic
 	});
-	for (const variable of TOOL_VARIABLES) {
-		const value = input.toolVars?.[variable];
-		if (value !== void 0 && value.length > 0) return Result.succeed({
-			mode: "machine",
-			signal: "tool",
-			stdoutIsTTY: true
+	if (command.schemaError) return RunConfigFailed.make({ detail: command.configDetail });
+	if (command.highestExitClass !== void 0) {
+		if (command.highestExitClass === "ConfigError") return RunConfigFailed.make({ detail: command.configDetail });
+		return RunFailed$1.make({
+			code: classCode(command.highestExitClass),
+			diagnostic: command.diagnostic
 		});
 	}
-	return Result.succeed({
-		mode: "human",
-		signal: "tty",
-		stdoutIsTTY: true
+	return RunFailed$1.make({
+		code: 1,
+		diagnostic: command.diagnostic
 	});
 }
-/**
-* 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;
+function succeedRun(ok) {
+	return Result.succeed(ok);
 }
-/**
-* 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
-* other than an unset or empty variable disables colour.
-*/
-function isColorEnabled(resolved, noColor) {
-	return resolved.mode === "human" && (noColor === void 0 || noColor.length === 0);
+function failRun(error) {
+	return Result.fail(error);
 }
+function runOutcomeDecision(command) {
+	return Match.value(classify(command)).pipe(Match.tag("RunOk", succeedRun), Match.tag("RunInterrupted", failRun), Match.tag("RunParseFailed", failRun), Match.tag("RunSurvivorsRejected", failRun), Match.tag("RunConfigFailed", failRun), Match.tag("RunFailed", failRun), Match.exhaustive);
+}
+const runOutcomeWorkflow = Workflow.make(RunOutcomeCommand, runOutcomeDecision);
 //#endregion
-//#region src/OutputModeAdapter.ts
-var OutputModeProbeTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/OutputModeAdapter/OutputModeProbeTag") {};
-const OutputModeProbe = OutputModeProbeTag;
-const OutputModeProbeLive = Layer.succeed(OutputModeProbe, OutputModeProbe.of({ detectMode: () => {
-	const envMode = process.env["STRYKER_MODE"];
-	const agent = process.env["AGENT"];
-	return Result.getOrThrow(resolveMode({
-		stdoutIsTTY: process.stdout.isTTY === true,
-		...envMode !== void 0 ? { envMode } : {},
-		...agent !== void 0 ? { agent } : {},
-		toolVars: Object.fromEntries(TOOL_VARIABLES.map((variable) => [variable, process.env[variable]]))
-	}));
-} }));
-//#endregion
-//#region src/StreamProtocol.ts
+//#region src/Survivors.workflow.ts
 /**
-* The heartbeat interval (R19), matching Terraform's `apply_progress`
-* cadence: long enough that a slow phase is not noisy, short enough that a
-* consumer can tell "slow" from "hung" without waiting for a mutant event.
+* 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
+		})
+	})
+});
+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
+				})
+			})
+		}))
+	}))
+});
+/**
+* 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).
 */
-const TICK_INTERVAL_MS = 1e4;
-//#endregion
-//#region src/RunEventStreamAdapter.ts
-var RunEventStreamPortTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/RunEventStreamAdapter/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.
+* 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.
 */
-function queueEmit(queue) {
-	return {
-		single: (event) => {
-			Effect.runSync(Queue.offer(queue, event));
-		},
-		end: () => {
-			Effect.runSync(Queue.end(queue));
-		}
-	};
+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);
 }
+const SURVIVORS_RUN_FIRST_REMEDIATION = "run a full `stryker run` first, then re-run with --survivors";
+const SURVIVORS_BOOKKEEPING_KEYS = ["survivorsPriorReport"];
 /**
-* The drain writes the framed lines through the platform's `Stdio` stdout
-* sink — `NodeStdio.layer` at the composition root supplies the service, and
-* the sink owns the writable's backpressure, the scoped `'error'` listener a
-* closed consumer raises, and the final `'finish'` wait (`endOnDone`). A
-* write failure surfaces as a `PlatformError` which this catch swallows — a
-* consumer closing the pipe must not replace the run's classed exit code
-* (R31) — and the drain still completes only after every byte was handed to
-* the OS (R30).
+* The resolved options without the survivors-run bookkeeping keys, so both
+* sides of the admission comparison describe the same configuration.
 */
-const drainOf = (stdio, framed) => Stream.run(framed, stdio.stdout({ endOnDone: true })).pipe(Effect.ignore);
+function stripSurvivorsKeys(config) {
+	if (!isRecord(config)) return {};
+	const rest = { ...config };
+	for (const key of SURVIVORS_BOOKKEEPING_KEYS) delete rest[key];
+	return rest;
+}
 /**
-* Creates a run's stream. The drain is an Effect the composition root forks
-* before the run; until then the sink is unbound and every push is dropped,
-* which is what makes human mode — or an absent drain — inert without
-* per-call probing (R2). The run's clock zero is read from the runtime so
-* the adapter never touches the wall clock directly.
+* 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.
 */
-const makeRunEventStream = (stdio, resolved) => Effect.gen(function* () {
-	const runId = generateRunId();
-	const startedAt = yield* Clock.currentTimeMillis;
-	const state = {
-		mode: resolved.mode,
-		signal: resolved.signal,
-		emit: null,
-		headerWritten: false,
-		terminalWritten: false,
-		progress: {
-			completed: 0,
-			total: null
-		}
-	};
-	const registered = yield* Deferred.make();
-	const eventStream = Stream.callback((queue) => Effect.sync(() => {
-		state.emit = queueEmit(queue);
-	}).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 {
-			kind: "tick",
-			elapsedMs: (yield* Clock.currentTimeMillis) - startedAt,
-			completed: state.progress.completed,
-			total: state.progress.total
-		};
-	})));
-	let terminalSeen = false;
-	const framed = Stream.merge(eventStream, tickStream, { haltStrategy: "either" }).pipe(Stream.filter((event) => {
-		if (terminalSeen) return false;
-		if (isTerminalEvent(event)) terminalSeen = true;
-		return true;
-	}), Stream.map((event) => `${JSON.stringify(event)}\n`));
-	const drain = drainOf(stdio, framed);
-	let drainFiber = null;
-	const sink = (event) => {
-		const emit = state.emit;
-		if (emit === null || state.terminalWritten || state.mode !== "machine") return;
-		if (!state.headerWritten) {
-			state.headerWritten = true;
-			emit.single({
-				kind: "stream",
-				schemaVersion: "1.0",
-				runId,
-				mode: state.mode,
-				signal: state.signal
-			});
-		}
-		switch (event.kind) {
-			case "stream":
-			case "tick": return;
-			case "phase": break;
-			case "plan":
-				state.progress = {
-					...state.progress,
-					total: event.total
-				};
-				break;
-			case "mutant":
-				state.progress = {
-					completed: event.completed,
-					total: event.total
-				};
-				break;
-			case "verdict":
-			case "error":
-			case "help":
-			case "manifest":
-				emit.single(event);
-				state.terminalWritten = true;
-				emit.end();
-				return;
-		}
-		emit.single(event);
-	};
-	return {
-		sink,
-		runId,
-		startedAt,
-		isOpen: () => state.emit !== null && state.mode === "machine" && !state.terminalWritten,
-		ensureOpen: (openResolved) => {
-			if (state.headerWritten) return;
-			state.mode = openResolved.mode;
-			state.signal = openResolved.signal;
-		},
-		open: Effect.gen(function* () {
-			if (drainFiber === null) {
-				drainFiber = yield* Effect.forkDetach(drain);
-				yield* Effect.race(Deferred.await(registered), Fiber.await(drainFiber));
-			}
-		}),
-		closeAndDrain: Effect.gen(function* () {
-			state.terminalWritten = true;
-			state.emit?.end();
-			if (drainFiber !== null) yield* Fiber.join(drainFiber);
-		})
-	};
-});
-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;
-}
-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 wasProducedBySurvivorsRun(priorReport) {
+	const config = priorReport.config;
+	return isRecord(config) && "survivorsPriorReport" in config;
 }
-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;
-	}
+/**
+* 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));
 }
-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 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;
 }
-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 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).";
+/**
+* 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 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;
+};
+function reject(reason, detail) {
+	return Result.fail(SurvivorsRejection.make({
+		reason,
+		remediation: `${detail} ${SURVIVORS_RUN_FIRST_REMEDIATION}`
+	}));
+}
+function decideAdmission(input) {
+	const priorReport = input.priorReport;
+	if (priorReport === void 0) return reject("no-report", NO_REPORT_DETAIL);
+	if (wasProducedBySurvivorsRun(priorReport)) return reject("mismatch", SURVIVORS_RUN_SOURCE_DETAIL);
+	if (input.priorSurvivors.length === 0) return Result.succeed(NoSurvivors.make());
+	if (!hashesMatch(priorReport, input)) return reject("mismatch", MISMATCH_DETAIL);
+	return Result.succeed(Admitted.make({ survivors: input.priorSurvivors }));
+}
+function admissionDecision(command) {
+	return decideAdmission(command);
 }
-/** 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);
+const admitSurvivorsRun = Workflow.make(AdmitSurvivorsRunCommand, admissionDecision);
+//#endregion
+//#region src/Envelope.ts
 /**
-* v4 option descriptions are stored as `Option.some(string)` on the compiled
-* `Single`; the walker unwraps the option.
+* Envelope — the failure envelope and console capture leaf.
+*
+* Extracted from Cli.ts to break the import cycle Cli <-> Output.
+* Both Cli and Output import from this leaf, so neither depends on the other
+* for these values. This file imports only from external packages and from
+* StreamVersion (leaf) and Survivors.workflow (leaf), never from Cli or Output
+* themselves.
 */
-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 "";
+const CONFIG_CODE = 2;
+function runOutcomeCode(result) {
+	if (Result.isSuccess(result)) return 0;
+	return Match.value(result.failure).pipe(Match.tag("RunInterrupted", (error) => error.code), Match.tag("RunParseFailed", () => CONFIG_CODE), Match.tag("RunSurvivorsRejected", () => CONFIG_CODE), Match.tag("RunConfigFailed", () => CONFIG_CODE), Match.tag("RunFailed", (error) => error.code), Match.exhaustive);
+}
+function isExitClass(value) {
+	return S.is(ExitClass)(value);
+}
+function exitClassOf(value) {
+	if (typeof value !== "object" || value === null) return;
+	if (!("exitClass" in value)) return;
+	const raw = Reflect.get(value, "exitClass");
+	if (!isExitClass(raw)) return;
+	return raw;
+}
+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);
 	}
 }
-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;
+function collectExitClasses(exit) {
+	const out = [];
+	const seen = /* @__PURE__ */ new WeakSet();
+	if (Exit.isFailure(exit)) for (const reason of exit.cause.reasons) {
+		let candidate;
+		if (Cause.isFailReason(reason)) candidate = reason.error;
+		else if (Cause.isDieReason(reason)) candidate = reason.defect;
+		else candidate = void 0;
+		if (candidate !== void 0) collectExitClassesFromValue(candidate, out, seen, 0);
 	}
-	out.flags.push(described);
+	return out;
+}
+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);
+	if (detail === void 0) return reason;
+	return `${reason}: ${detail}`;
+}
+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) {
+	if (!("reason" in value) && !("message" in value)) return;
+	const reason = Reflect.get(value, "reason");
+	if (typeof reason === "string" && reason.length > 0) return reason;
+	const message = Reflect.get(value, "message");
+	if (typeof message === "string" && message.length > 0) return message;
+}
+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
+	});
 }
-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;
+function firstConfigErrorDetail(exit) {
+	if (!Exit.isFailure(exit)) return;
+	const seen = /* @__PURE__ */ new WeakSet();
+	const stack = [];
+	for (const reason of exit.cause.reasons) {
+		let candidate;
+		if (Cause.isFailReason(reason)) candidate = reason.error;
+		else if (Cause.isDieReason(reason)) candidate = reason.defect;
+		else candidate = 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) === "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);
-}
-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);
+function describeFailure(exit) {
+	if (!Exit.isFailure(exit)) return "Unknown failure";
+	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);
 	}
-	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);
+	if (collectExitClasses(exit).includes("ConfigError")) {
+		const detail = firstConfigErrorDetail(exit);
+		if (detail !== void 0) return detail;
+	}
+	const rendered = Cause.pretty(exit.cause);
+	if (rendered.length > 0) return rendered;
+	return "Unknown failure";
+}
+function unrecognizedArgumentOf(exit, argv) {
+	if (!Exit.isFailure(exit)) return;
+	const value = failureValue(exit);
+	if (value === void 0 || !CliError.isCliError(value)) return;
+	const errors = (() => {
+		if (S.is(CliError.ShowHelp)(value)) return value.errors;
+		return [value];
+	})();
+	for (const error of errors) {
+		if (S.is(CliError.UnrecognizedOption)(error)) {
+			const at = argv.indexOf(error.option);
+			const next = (() => {
+				if (at >= 0) return argv[at + 1];
+			})();
+			if (next !== void 0 && !next.startsWith("-")) return next;
+			return 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.
-*/
-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 SIGNAL_REMEDIATION = "the run was interrupted by a signal; re-run it to continue";
+const PARSE_REMEDIATION = "re-run with --help to see the full usage";
+const DEFAULT_REMEDIATION = "see --reportFile or the verdict envelope on stdout";
+function successExitClassOf(exit) {
+	if (!Exit.isSuccess(exit)) return;
+	const value = exit.value;
+	if (!Predicate.hasProperty(value, "verdict")) return;
+	const candidate = value.verdict;
+	if (!isExitClass(candidate)) return;
+	return candidate;
+}
+function helpErrorCountOf(value) {
+	if (value === void 0) return;
+	if (!S.is(CliError.ShowHelp)(value)) return;
+	return value.errors.length;
+}
+function survivorsRejectionOf(value) {
+	if (value === void 0) return;
+	if (!S.is(SurvivorsRejection)(value)) return;
+	return value;
+}
+function present(value) {
+	if (value === null) return;
+	return value;
+}
+function survivorsReasonOf(survivors) {
+	if (survivors === void 0) return;
+	return survivors.reason;
+}
+function survivorsDiagnosticOf(survivors) {
+	if (survivors === void 0) return;
+	return survivors.remediation;
+}
+function omitUnknownFailure(diagnostic) {
+	if (diagnostic === "Unknown failure") return;
+	return diagnostic;
+}
+function capturedOrUnknown(captured) {
+	if (captured.length > 0) return captured;
+	return "Unknown failure";
+}
+function gatherRunOutcome(exit, signal, argv) {
+	const value = failureValue(exit);
+	const survivors = survivorsRejectionOf(value);
+	return RunOutcomeCommand.make({
+		succeeded: Exit.isSuccess(exit),
+		signal: present(signal),
+		interrupted: Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause),
+		helpErrorCount: helpErrorCountOf(value),
+		cliError: value !== void 0 && CliError.isCliError(value),
+		unrecognized: unrecognizedArgumentOf(exit, argv),
+		survivorsReason: survivorsReasonOf(survivors),
+		survivorsDiagnostic: survivorsDiagnosticOf(survivors),
+		schemaError: value !== void 0 && S.isSchemaError(value),
+		successExitClass: successExitClassOf(exit),
+		highestExitClass: present(highestExitClass(collectExitClasses(exit))),
+		configDetail: firstConfigErrorDetail(exit),
+		diagnostic: omitUnknownFailure(describeFailure(exit))
+	});
+}
+function errorText(error, captured) {
+	return Match.value(error).pipe(Match.tag("RunParseFailed", (failed) => {
+		if (failed.unrecognized !== void 0) return `Received unknown argument: '${failed.unrecognized}'`;
+		return capturedOrUnknown(captured);
+	}), Match.tag("RunSurvivorsRejected", (failed) => {
+		if (failed.diagnostic !== void 0) return failed.diagnostic;
+		return "Unknown failure";
+	}), Match.tag("RunInterrupted", () => capturedOrUnknown(captured)), Match.tag("RunConfigFailed", (failed) => {
+		if (captured.length > 0) return captured;
+		if (failed.detail !== void 0) return failed.detail;
+		return "Unknown failure";
+	}), Match.tag("RunFailed", (failed) => {
+		if (captured.length > 0) return captured;
+		if (failed.diagnostic !== void 0) return failed.diagnostic;
+		return "Unknown failure";
+	}), Match.exhaustive);
+}
+function remediationText(error) {
+	return Match.value(error).pipe(Match.tag("RunInterrupted", (failed) => {
+		if (failed.code > 128) return SIGNAL_REMEDIATION;
+		return DEFAULT_REMEDIATION;
+	}), Match.tag("RunParseFailed", () => PARSE_REMEDIATION), Match.tag("RunSurvivorsRejected", (failed) => {
+		if (failed.diagnostic !== void 0) return failed.diagnostic;
+		return DEFAULT_REMEDIATION;
+	}), Match.tag("RunConfigFailed", (failed) => {
+		if (failed.detail !== void 0) return `check the config file: ${failed.detail}`;
+		return "check the config file";
+	}), Match.tag("RunFailed", () => DEFAULT_REMEDIATION), Match.exhaustive);
+}
+function shapeEnvelope(error, captured) {
 	return {
 		schemaVersion: "1.0",
-		tool: root.name,
-		version,
-		commands: [root]
+		code: runOutcomeCode(Result.fail(error)),
+		error: errorText(error, captured),
+		remediation: remediationText(error)
 	};
 }
-/** The manifest as one JSON document, ready for stdout — the U4 convention. */
-function emitLLMSManifest(command, version) {
-	return JSON.stringify(buildLLMSManifest(command, version));
+function classifyRunOutcome(exit, signal, argv) {
+	return runOutcomeWorkflow(gatherRunOutcome(exit, signal, argv));
 }
-//#endregion
-//#region src/OutputModeConsoleState.ts
-/**
-* U6 — the machine-mode `Console` layer (KTD3, R7).
-*
-* The v4 CLI renders help and errors through an ANSI renderer and prints them
-* with the `Console` reference — and there is no seam to intercept: the
-* document is written *before* the failure propagates. Machine mode therefore
-* replaces the `Console` reference itself with a capturing implementation:
-* every write lands in an in-memory buffer instead of the real stdout/stderr,
-* and the terminating bootstrap (StrykerCliHandler.ts) emits the buffer as
-* one JSON envelope at teardown. Human mode keeps the default console so the
-* framework's prose rendering is untouched.
-*
-* The v4 `Console.Console` interface is the sync `globalThis.console` shape
-* (the v3 service's effect-returning surface became the module-level
-* wrapper functions), so the capture implementation needs no `unsafe`
-* mirror — every method stores into the buffer directly.
-*/
 const capturedConsoleChunks = [];
 const countByLabel = /* @__PURE__ */ new Map();
 const timeByLabel = /* @__PURE__ */ new Map();
+function inspectValue(value) {
+	if (typeof value === "string") return value;
+	return Formatter.format(value);
+}
 function formatArgs(args) {
-	return format(...args);
+	if (args.length === 0) return "";
+	const first = args[0];
+	if (typeof first === "string") {
+		let index = 1;
+		let result = first.replace(/%[sdijfopO%]/g, (match) => {
+			if (match === "%%") return "%";
+			if (index >= args.length) return match;
+			const arg = args[index++];
+			switch (match) {
+				case "%s": return String(arg);
+				case "%d":
+				case "%i":
+				case "%f": return Number(arg).toString();
+				case "%j": try {
+					return String(JSON.stringify(arg));
+				} catch {
+					return "[Circular]";
+				}
+				case "%o":
+				case "%O":
+				case "%p": return inspectValue(arg);
+				default: return match;
+			}
+		});
+		for (; index < args.length; index++) result += ` ${inspectValue(args[index])}`;
+		return result;
+	}
+	return args.map(inspectValue).join(" ");
 }
 function captureSync(args) {
 	capturedConsoleChunks.push(formatArgs(args));
@@ -501,282 +628,453 @@ function captureCount(label) {
 	countByLabel.set(key, next);
 	capturedConsoleChunks.push(`${key}: ${next}`);
 }
-function captureTimeEnd(label, now) {
+function captureTimeEnd(label, nowNanos) {
 	const key = label ?? "default";
 	const started = timeByLabel.get(key);
 	if (started !== void 0) {
 		timeByLabel.delete(key);
-		capturedConsoleChunks.push(`${key}: ${now - started}ms`);
+		const diffMs = Number(nowNanos - started) / 1e6;
+		capturedConsoleChunks.push(`${key}: ${diffMs}ms`);
 	}
 }
 function captureTrace(args) {
 	capturedConsoleChunks.push(`Trace: ${formatArgs(args)}\n${(/* @__PURE__ */ new Error()).stack ?? ""}`);
 }
-const capturingConsole = {
+const makeCapturingConsole = (clock) => ({
 	assert: (condition, ...args) => captureAssert(condition, args),
 	clear: () => {},
 	count: (label) => captureCount(label),
 	countReset: (label) => countByLabel.delete(label ?? "default"),
 	debug: (...args) => captureSync(args),
-	dir: (item, options) => capturedConsoleChunks.push(inspect(item, options)),
-	dirxml: (item) => capturedConsoleChunks.push(inspect(item)),
+	dir: (item, _options) => capturedConsoleChunks.push(Formatter.format(item)),
+	dirxml: (item) => capturedConsoleChunks.push(Formatter.format(item)),
 	error: (...args) => captureSync(args),
 	group: () => {},
 	groupCollapsed: () => {},
 	groupEnd: () => {},
 	info: (...args) => captureSync(args),
 	log: (...args) => captureSync(args),
-	table: (tabularData) => capturedConsoleChunks.push(inspect(tabularData, {
-		colors: false,
-		depth: null
-	})),
-	time: (label) => timeByLabel.set(label ?? "default", performance.now()),
-	timeEnd: (label) => captureTimeEnd(label, performance.now()),
+	table: (tabularData) => capturedConsoleChunks.push(Formatter.format(tabularData)),
+	time: (label) => timeByLabel.set(label ?? "default", clock.monotonicTimeNanosUnsafe()),
+	timeEnd: (label) => captureTimeEnd(label, clock.monotonicTimeNanosUnsafe()),
 	timeLog: (label, ...args) => {
 		const key = label ?? "default";
 		const started = timeByLabel.get(key);
-		if (started !== void 0) capturedConsoleChunks.push(`${key}: ${performance.now() - started}ms ${formatArgs(args)}`);
+		if (started === void 0) return;
+		const diffMs = Number(clock.monotonicTimeNanosUnsafe() - started) / 1e6;
+		if (args.length === 0) {
+			capturedConsoleChunks.push(`${key}: ${diffMs}ms`);
+			return;
+		}
+		capturedConsoleChunks.push(`${key}: ${diffMs}ms ${formatArgs(args)}`);
 	},
 	trace: (...args) => captureTrace(args),
 	warn: (...args) => captureSync(args)
-};
-/**
-* The machine-mode `Console` layer. Building it clears the capture buffer so
-* every run starts empty; the terminating bootstrap reads the buffer back
-* through `readCapturedConsole` at teardown. A `Layer` is already lazy, so
-* the layer is a value: the reset effect runs when the layer is built.
-*
-* The layer must replace the `Console` reference the module-level
-* `Console.log`/`Console.error` wrappers read through their fiber context;
-* v4 reads the override the same way it reads any provided service, so a
-* plain provide is sufficient — no special `setConsole`-style primitive
-* exists any more. The reference's identifier is `never` (it carries no
-* requirement), so the layer's type is too.
-*
-* Human mode provides no Console binding at all: effect's own default
-* console delegates every method to the global console, which is exactly the
-* prose rendering a human-mode run uses. Mirroring it here would reimplement
-* the library default (V.7).
-*/
-const machineConsoleLayer = Layer.effect(Console.Console, Effect.sync(() => {
+});
+const machineConsoleLayer = Layer.effect(Console.Console, Clock.clockWith((clock) => Effect.sync(() => {
 	resetCapturedConsole();
-	return capturingConsole;
-}));
-/**
-* The text captured so far by the machine console layer, joined into one
-* document the way a terminal would have rendered it (one console call per
-* line). Empty in human mode.
-*/
+	return makeCapturingConsole(clock);
+})));
 function readCapturedConsole() {
 	return capturedConsoleChunks.join("\n");
 }
-/**
-* Clears the capture buffer and the count/time tables. Called when the
-* machine layer is constructed so every run starts empty.
-*/
 function resetCapturedConsole() {
 	capturedConsoleChunks.length = 0;
 	countByLabel.clear();
 	timeByLabel.clear();
 }
 //#endregion
-//#region src/Survivors.workflow.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.
-*/
-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);
-}
+//#region src/Output.workflow.ts
+const TOOL_VARIABLES$1 = ["CLAUDECODE", "CODEX_SANDBOX"];
 /**
-* The resolved options without the survivors-run bookkeeping keys, so both
-* sides of the admission hash describe the same configuration.
+* The command of the output-mode workflow: a schema class, because `Workflow.make`
+* derives the command type from it and pins the error channel at the construction site.
 */
-function stripSurvivorsKeys(config) {
-	if (!isRecord(config)) return {};
-	const rest = { ...config };
-	for (const key of SURVIVORS_BOOKKEEPING_KEYS) delete rest[key];
-	return rest;
-}
+var ResolveModeCommand = class extends S.TaggedClass()("ResolveModeCommand", {
+	stdoutIsTTY: S.Boolean,
+	text: S.optional(S.Boolean),
+	json: S.optional(S.Boolean),
+	envMode: S.optional(S.String),
+	agent: S.optional(S.String),
+	toolVars: S.optional(S.Record(S.String, S.String))
+}) {};
 /**
-* 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.
+* The conflict error for mutually exclusive format flags. Defined locally so the
+* workflow decision remains pure — the sealed effect surface does not include
+* `effect/unstable/cli/CliError`, so the decision returns this local error and
+* the shell maps it to `CliError.InvalidValue` at the boundary.
 */
-function wasProducedBySurvivorsRun(priorReport) {
-	const config = priorReport.config;
-	return isRecord(config) && "survivorsPriorReport" in config;
+var ModeConflictError = class extends S.TaggedError()("ModeConflictError", {
+	option: S.String,
+	value: S.String,
+	expected: S.String
+}) {};
+const CONFLICT_EXPECTED = "the \"--format text\" and \"--json\" flags are mutually exclusive — use one or the other";
+function r4(command) {
+	if (command.text === true && command.json === true) return Result.fail(ModeConflictError.make({
+		option: "json",
+		value: "text",
+		expected: CONFLICT_EXPECTED
+	}));
+	if (command.text === true) return Result.succeed({
+		mode: "human",
+		signal: "flag",
+		stdoutIsTTY: command.stdoutIsTTY
+	});
+	if (command.json === true) return Result.succeed({
+		mode: "machine",
+		signal: "flag",
+		stdoutIsTTY: command.stdoutIsTTY
+	});
+	if (command.envMode !== void 0 && command.envMode.length > 0) {
+		if (command.envMode === "machine") return Result.succeed({
+			mode: "machine",
+			signal: "env",
+			stdoutIsTTY: command.stdoutIsTTY
+		});
+		return Result.succeed({
+			mode: "human",
+			signal: "env",
+			stdoutIsTTY: command.stdoutIsTTY
+		});
+	}
+	if (!command.stdoutIsTTY) return Result.succeed({
+		mode: "machine",
+		signal: "tty",
+		stdoutIsTTY: false
+	});
+	if (command.agent !== void 0 && command.agent.length > 0) return Result.succeed({
+		mode: "machine",
+		signal: "agent",
+		stdoutIsTTY: true
+	});
+	const toolVars = command.toolVars ?? {};
+	for (const variable of TOOL_VARIABLES$1) {
+		const value = toolVars[variable];
+		if (typeof value === "string" && value.length > 0) return Result.succeed({
+			mode: "machine",
+			signal: "tool",
+			stdoutIsTTY: true
+		});
+	}
+	return Result.succeed({
+		mode: "human",
+		signal: "tty",
+		stdoutIsTTY: true
+	});
 }
-/**
-* 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.
-*/
-function sourceContentHash(content, hash) {
-	return hash(content);
+function modeDecision(command) {
+	return r4(command);
 }
+const resolveModeWorkflow = Workflow.make(ResolveModeCommand, modeDecision);
+//#endregion
+//#region src/Output.ts
 /**
-* 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.
+* Output — the machine/human output capability.
+*
+* The NDJSON run-event stream, wire protocol constants, mode resolution probes,
+* and machine-mode terminal output. Pure mode resolution lives in
+* Output.workflow.ts.
 */
-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;
-}
 /**
-* Converts a report mutant (1-based schema location) into the internal mutant
-* shape a run consumes (0-based positions, absolute file name) — the exact
-* inverse of `objectUtils.toSchemaLocation` and the same shift the
-* incremental report reader applies (`project-reader.ts`). Mutants without a
-* replacement fall back to their mutator name, the same convention the
-* incremental differ uses.
+* The heartbeat interval (R19), matching Terraform's `apply_progress`
+* cadence: long enough that a slow phase is not noisy, short enough that a
+* consumer can tell "slow" from "hung" without waiting for a mutant event.
 */
-function reportMutantToMutant(file, mutant, resolveAbsolutePath) {
+const TICK_INTERVAL_MS = 1e4;
+var RunEventStreamPortTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/Output/RunEventStreamPortTag") {};
+const RunEventStreamPort = RunEventStreamPortTag;
+const isTerminalEvent = (event) => Match.value(event).pipe(Match.tag("verdict", () => true), Match.tag("error", () => true), Match.tag("help", () => true), Match.tag("manifest", () => true), Match.orElse(() => false));
+const wireKind = (event) => Match.value(event).pipe(Match.tag("stream", () => "stream"), Match.tag("phase", () => "phase"), Match.tag("plan", () => "plan"), Match.tag("mutant", () => "mutant"), Match.tag("tick", () => "tick"), Match.tag("verdict", () => "verdict"), Match.tag("error", () => "error"), Match.tag("help", () => "help"), Match.tag("manifest", () => "manifest"), Match.exhaustive);
+const toWireLine = (event) => {
+	const fields = Object.fromEntries(Object.entries(event).filter(([key]) => key !== "_tag"));
+	return JSON.stringify({
+		kind: wireKind(event),
+		...fields
+	});
+};
+function numberText(value, fallback) {
+	if (typeof value === "number") return String(value);
+	return fallback;
+}
+function phaseLine(phase) {
+	if (typeof phase === "string") return `phase ${phase}`;
+	return "phase ";
+}
+const stderrProgressLine = (event, alreadyClosed) => {
+	if (alreadyClosed) return;
+	return Match.value(event).pipe(Match.tag("plan", (e) => `plan ${numberText(e.total, "0")} mutants`), Match.tag("phase", (e) => phaseLine(e.phase)), Match.tag("tick", (e) => `${numberText(e.completed, "0")}/${numberText(e.total, "?")} elapsed ${numberText(e.elapsedMs, "0")}ms`), Match.tag("verdict", (e) => `score ${numberText(e.score, "n/a")} killed ${numberText(e.counts.killed, "0")} survived ${numberText(e.counts.survived, "0")}`), Match.tag("error", (e) => {
+		if (typeof e.error === "string") return `error ${e.error}`;
+		return "error ";
+	}), Match.orElse(() => void 0));
+};
+const writeStderr = (stdio, line) => Stream.run(Stream.succeed(`${line}\n`), stdio.stderr({ endOnDone: false })).pipe(Effect.ignore);
+const drainOf = (stdio, framed) => Stream.run(framed, stdio.stdout({ endOnDone: true })).pipe(Effect.ignore);
+const makeRunEventStream = (stdio, resolved, drainFramed = drainOf.bind(null, stdio)) => Effect.gen(function* () {
+	const runId = generateRunId();
+	const startedAt = yield* Clock.currentTimeMillis;
+	const queue = yield* Queue.unbounded();
+	const state = {
+		mode: resolved.mode,
+		signal: resolved.signal,
+		headerWritten: false,
+		terminalWritten: false,
+		progress: {
+			completed: 0,
+			total: null
+		},
+		findingsPrinted: 0
+	};
+	const queueStream = Stream.fromQueue(queue).pipe(Stream.tap((event) => Effect.sync(() => {
+		Match.value(event).pipe(Match.tag("plan", (e) => {
+			state.progress = {
+				...state.progress,
+				total: e.total
+			};
+		}), Match.tag("mutant", (e) => {
+			state.progress = {
+				completed: e.completed,
+				total: e.total
+			};
+		}), Match.orElse(() => {}));
+	})));
+	const tickStream = Stream.tick(TICK_INTERVAL_MS).pipe(Stream.drop(1), Stream.filter(() => state.headerWritten && !state.terminalWritten), Stream.mapEffect(() => Effect.gen(function* () {
+		const now = yield* Clock.currentTimeMillis;
+		return Heartbeat.make({
+			elapsedMs: now - startedAt,
+			completed: state.progress.completed,
+			total: state.progress.total
+		});
+	})));
+	let terminalSeen = false;
+	const drain = drainFramed(Stream.merge(queueStream, tickStream, { haltStrategy: "either" }).pipe(Stream.tap((event) => {
+		const line = stderrProgressLine(event, state.terminalWritten);
+		if (isTerminalEvent(event)) state.terminalWritten = true;
+		if (line === void 0) return Effect.void;
+		return writeStderr(stdio, line);
+	})).pipe(Stream.filter((event) => {
+		if (state.mode !== "machine") return false;
+		if (terminalSeen) return false;
+		if (isTerminalEvent(event)) terminalSeen = true;
+		return true;
+	}), Stream.map((event) => `${toWireLine(event)}\n`)));
+	let drainFiber = null;
 	return {
-		id: mutant.id,
-		fileName: resolveAbsolutePath(file),
-		mutatorName: mutant.mutatorName,
-		replacement: mutant.replacement ?? mutant.mutatorName,
-		location: {
-			start: {
-				line: mutant.location.start.line - 1,
-				column: mutant.location.start.column - 1
-			},
-			end: {
-				line: mutant.location.end.line - 1,
-				column: mutant.location.end.column - 1
+		queue,
+		runId,
+		startedAt,
+		isOpen: () => state.mode === "machine" && !state.terminalWritten && drainFiber !== null,
+		ensureOpen: (openResolved) => {
+			if (state.headerWritten) return;
+			state.mode = openResolved.mode;
+			state.signal = openResolved.signal;
+		},
+		open: Effect.gen(function* () {
+			if (drainFiber === null) {
+				if (!state.headerWritten) {
+					state.headerWritten = true;
+					if (state.mode === "machine") yield* Queue.offer(queue, RunStarted.make({
+						schemaVersion: "1.0",
+						runId,
+						mode: state.mode,
+						signal: state.signal
+					}));
+				}
+				drainFiber = yield* Effect.forkDetach(drain);
 			}
-		}
+		}),
+		closeAndDrain: Effect.gen(function* () {
+			state.terminalWritten = true;
+			yield* Queue.end(queue);
+			if (drainFiber !== null) yield* Fiber.join(drainFiber);
+		})
 	};
-}
+});
+Layer.effect(RunEventStreamPort, Effect.map(Stdio.Stdio, (stdio) => RunEventStreamPort.of({ createRunEventStream: (resolved) => makeRunEventStream(stdio, resolved) })));
+const TOOL_VARIABLES = ["CLAUDECODE", "CODEX_SANDBOX"];
 /**
-* The survivors of the prior report: exactly the mutants whose status is
-* `Survived`, converted to the internal mutant shape so a run can re-test
-* them.
+* 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
+* other than an unset or empty variable disables colour.
 */
-function extractSurvivors(priorReport, resolveAbsolutePath) {
-	const survivors = [];
-	for (const [file, fileResult] of objectEntries(priorReport.files)) for (const mutant of fileResult.mutants) if (mutant.status === "Survived") survivors.push(reportMutantToMutant(file, mutant, resolveAbsolutePath));
-	return survivors;
+function isColorEnabled(resolved, noColor) {
+	if (resolved.mode !== "human") return false;
+	if (noColor === void 0) return true;
+	if (noColor.length === 0) return true;
+	return false;
 }
+var OutputModeProbeTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/Output/OutputModeProbeTag") {};
+const OutputModeProbe = OutputModeProbeTag;
+const outputModeProbeDescription = pipe(Cell.read((command) => Effect.succeed((() => {
+	const toolVarsRecord = {};
+	for (const variable of TOOL_VARIABLES) {
+		const value = process.env[variable];
+		if (value !== void 0) toolVarsRecord[variable] = value;
+	}
+	const envMode = process.env["STRYKER_MODE"];
+	const agent = process.env["AGENT"];
+	let result = { stdoutIsTTY: process.stdout.isTTY === true };
+	if (Object.keys(toolVarsRecord).length > 0) result = {
+		...result,
+		toolVars: toolVarsRecord
+	};
+	if (envMode !== void 0) result = {
+		...result,
+		envMode
+	};
+	if (agent !== void 0) result = {
+		...result,
+		agent
+	};
+	if (command.text !== void 0) result = {
+		...result,
+		text: command.text
+	};
+	if (command.json !== void 0) result = {
+		...result,
+		json: command.json
+	};
+	return result;
+})())), Cell.decode((raw) => Result.succeed((() => {
+	const filteredToolVars = {};
+	if (raw.toolVars !== void 0) {
+		for (const [key, value] of Object.entries(raw.toolVars)) if (value !== void 0) filteredToolVars[key] = value;
+	}
+	let commandInput = { stdoutIsTTY: raw.stdoutIsTTY };
+	if (raw.text !== void 0) commandInput = {
+		...commandInput,
+		text: raw.text
+	};
+	if (raw.json !== void 0) commandInput = {
+		...commandInput,
+		json: raw.json
+	};
+	if (raw.envMode !== void 0) commandInput = {
+		...commandInput,
+		envMode: raw.envMode
+	};
+	if (raw.agent !== void 0) commandInput = {
+		...commandInput,
+		agent: raw.agent
+	};
+	if (Object.keys(filteredToolVars).length > 0) commandInput = {
+		...commandInput,
+		toolVars: filteredToolVars
+	};
+	return ResolveModeCommand.make(commandInput);
+})())), Cell.decide(resolveModeWorkflow), Cell.encode((outcome) => outcome), Cell.write((outcome) => Result.match(outcome, {
+	onFailure: (error) => Effect.fail(error),
+	onSuccess: (mode) => Effect.succeed(mode)
+})));
+const detectModeWithProbe = (flags = {}) => Cell.apply(outputModeProbeDescription, flags).pipe(Effect.mapError((error) => CliError.InvalidValue.make({
+	option: error.option,
+	value: error.value,
+	expected: error.expected,
+	kind: "flag"
+})));
+const OutputModeProbeLive = Layer.succeed(OutputModeProbe, OutputModeProbe.of({ detectMode: detectModeWithProbe({}) }));
 /**
-* The survivor spans as `file:startLine:startCol-endLine:endCol` mutate
-* ranges: the report's 1-based lines with the internal 0-based columns,
-* relative file names, deduplicated in first-seen order.
+* 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 survivorMutateSpans(survivors) {
-	const spans = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const survivor of survivors) {
-		const file = toRelativeNormalizedFileName(survivor.fileName);
-		const { start, end } = survivor.location;
-		const span = `${file}:${start.line + 1}:${start.column}-${end.line + 1}:${end.column}`;
-		if (!seen.has(span)) {
-			seen.add(span);
-			spans.push(span);
+function emitNullScoreVerdict(stream, mode, thresholds, config, basePath, pathService) {
+	const envelope = buildVerdictEnvelope({
+		schemaVersion: "1.0",
+		files: {},
+		thresholds,
+		projectRoot: basePath,
+		config,
+		framework: {
+			name: "StrykerJS",
+			version: strykerVersion
 		}
-	}
-	return spans;
+	}, mode.mode, mode.signal, stream.runId, basePath, pathService);
+	return Queue.offer(stream.queue, VerdictReached.make({
+		schemaVersion: envelope.schemaVersion,
+		runId: envelope.runId,
+		mode: envelope.mode,
+		signal: envelope.signal,
+		score: envelope.score,
+		thresholds: envelope.thresholds,
+		reportFile: envelope.reportFile,
+		counts: envelope.counts,
+		mutants: envelope.mutants
+	}));
 }
 /**
-* 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.
+* 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, outcome, basePath, pathService) {
+	return Effect.gen(function* () {
+		const captured = readCapturedConsole();
+		if (Result.isSuccess(outcome)) {
+			if (outcome.success.help) {
+				yield* Queue.offer(stream.queue, HelpRendered.make({
+					schemaVersion: "1.0",
+					code: 0,
+					help: captured
+				}));
+				return;
+			}
+			if (captured.length > 0) {
+				yield* Queue.offer(stream.queue, HelpRendered.make({
+					schemaVersion: "1.0",
+					code: 0,
+					help: captured
+				}));
+				return;
+			}
+			if (stream.isOpen()) yield* emitNullScoreVerdict(stream, mode, (yield* defaultOptions).thresholds, {}, basePath, pathService);
+			return;
+		}
+		const envelope = shapeEnvelope(outcome.failure, captured);
+		yield* Queue.offer(stream.queue, RunFailed.make({
+			schemaVersion: envelope.schemaVersion,
+			code: envelope.code,
+			error: envelope.error,
+			remediation: envelope.remediation
+		}));
+	});
+}
+//#endregion
+//#region src/Survivors.ts
+/**
+* Survivors — the survivors-admission capability.
+*
+* The prior-report decoding, source hashing, mutant conversion, and admission
+* pipeline for --survivors runs. Pure admission decision lives in
+* Survivors.workflow.ts.
+*/
+const DEFAULT_SURVIVORS_PRIOR_REPORT = "reports/mutation-report.json";
+/**
+* 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.
+*/
+/**
+* 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
-				})
-			})
-		}))
-	}))
-});
 /**
 * 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,165 +1082,80 @@ const PriorReportDocument = S.Struct({
 * a third-party report type.
 */
 const decodePriorReport = S.decodeUnknownResult(PriorReportDocument);
+const { entries: objectEntries, fromEntries: objectFromEntries } = Object;
 /**
-* 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.
+* 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.
 */
-var PriorReportFacts = class extends S.Class("PriorReportFacts")({
-	config: S.Record(S.String, S.Unknown),
-	frameworkVersion: S.UndefinedOr(S.String)
-}) {};
+function sourceContentHash(content, hash) {
+	return hash(content);
+}
 /**
-* 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.
+* 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.
 */
-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.
+* Converts a report mutant (1-based schema location) into the internal mutant
+* shape a run consumes (0-based positions, absolute file name) — the exact
+* inverse of `objectUtils.toSchemaLocation` and the same shift the
+* incremental report reader applies (`project-reader.ts`). Mutants without a
+* replacement fall back to their mutator name, the same convention the
+* incremental differ uses.
 */
-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 reportMutantToMutant(file, mutant, resolveAbsolutePath) {
+	return Mutant.make({
+		id: mutant.id,
+		fileName: resolveAbsolutePath(file),
+		mutatorName: mutant.mutatorName,
+		replacement: mutant.replacement ?? mutant.mutatorName,
+		location: {
+			start: {
+				line: mutant.location.start.line - 1,
+				column: mutant.location.start.column - 1
+			},
+			end: {
+				line: mutant.location.end.line - 1,
+				column: mutant.location.end.column - 1
+			}
+		}
 	});
 }
-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).
+* The survivors of the prior report: exactly the mutants whose status is
+* `Survived`, converted to the internal mutant shape so a run can re-test
+* them.
 */
-const strykerCliConsoleLayers = { machine: machineConsoleLayer };
-const SIGNAL_NUMBERS = Object.freeze({
-	SIGINT: 2,
-	SIGTERM: 15
-});
-const hashContent = (content) => createHash("sha256").update(content, "utf-8").digest("hex");
-const resolveAbsolutePath = (file) => resolve(file);
+function extractSurvivors(priorReport, resolveAbsolutePath) {
+	const survivors = [];
+	for (const [file, fileResult] of objectEntries(priorReport.files)) for (const mutant of fileResult.mutants) if (mutant.status === "Survived") survivors.push(reportMutantToMutant(file, mutant, resolveAbsolutePath));
+	return survivors;
+}
 /**
-* 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.
+* The survivor spans as `file:startLine:startCol-endLine:endCol` mutate
+* ranges: the report's 1-based lines with the internal 0-based columns,
+* relative file names, deduplicated in first-seen order.
 */
-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")]
-	};
+function survivorMutateSpans(survivors, basePath) {
+	const spans = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const survivor of survivors) {
+		const file = toRelativeNormalizedFileName(survivor.fileName, basePath);
+		const { start, end } = survivor.location;
+		const span = `${file}:${start.line + 1}:${start.column}-${end.line + 1}:${end.column}`;
+		if (!seen.has(span)) {
+			seen.add(span);
+			spans.push(span);
+		}
+	}
+	return spans;
 }
+const hashContent = (content) => bytesToHex(sha256(utf8ToBytes(content)));
+const resolveAbsolutePath = (file) => resolve(file);
 /**
 * 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
@@ -954,68 +1167,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, services) => pipe(Cell.read((cliOptions) => Effect.provideContext(Effect.flatMap(Path.Path, (pathService) => resolveSurvivorsRunOptions(cliOptions, basePath).pipe(Effect.flatMap((resolvedOptions) => {
+	const priorReportPath = priorReportPathOf(resolvedOptions);
+	return Effect.flatMap(readPriorReport(priorReportPath), (read) => Effect.flatMap(currentSourceHashesFor(priorReportFileKeys(read.raw)), (sourceContentHashes) => Ref.set(runContext, {
+		resolvedOptions,
+		priorReportPath,
+		pathService
+	}).pipe(Effect.as({
+		resolvedOptions,
+		priorReportRaw: read.raw,
+		priorReportFound: read.found,
+		priorReportPath,
+		sourceContentHashes
+	}))));
+}))), services)), 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", () => emitNullScoreVerdict(stream, mode, resolvedOptions.thresholds, resolvedOptions, basePath, pathService)), Match.tag("Admitted", (admitted) => {
+			const admittedMutants = admitted.survivors.map((s) => Mutant.make(s));
+			return runMutationTest({
+				...resolvedOptions,
+				survivors: admittedMutants,
+				mutate: survivorMutateSpans(admittedMutants, basePath),
+				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,65 +1230,38 @@ 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 services = yield* Effect.context();
 		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, services), 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, 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;
+	if (typeof configured === "string") return configured;
+	return 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 {
+	return Effect.gen(function* () {
+		return yield* (yield* FileSystem.FileSystem).readFileString(priorReportPath).pipe(Effect.map((text) => ({
+			found: true,
+			raw: Result.match(S.decodeResult(S.fromJsonString(S.Unknown))(text), {
+				onFailure: () => text,
+				onSuccess: (value) => value
+			})
+		})), Effect.catchTag("PlatformError", (cause) => Match.value(cause.reason).pipe(Match.tag("NotFound", () => Effect.succeed({
 			found: false,
 			raw: void 0
-		};
-	}
-	try {
-		return {
-			found: true,
-			raw: JSON.parse(text)
-		};
-	} catch {
-		return {
-			found: true,
-			raw: text
-		};
-	}
+		})), Match.orElse(() => Effect.fail(ConfigFileUnreadableError.make({
+			file: priorReportPath,
+			cause
+		}))))));
+	});
 }
-/**
-* 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 [];
@@ -1096,288 +1270,252 @@ function priorReportFileKeys(raw) {
 	return Object.keys(files);
 }
 function readSourceFile(file) {
-	try {
-		return readFileSync(file, "utf-8");
-	} catch {
-		return "";
-	}
+	return Effect.flatMap(FileSystem.FileSystem, (fs) => fs.readFileString(file).pipe(Effect.mapError((cause) => ConfigFileUnreadableError.make({
+		file,
+		cause
+	}))));
 }
-/**
-* 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;
+	return Effect.map(Effect.forEach(files, (file) => Effect.map(readSourceFile(file), (content) => [file, sourceContentHash(content, hashContent)]), { concurrency: 24 }), (pairs) => Object.fromEntries(pairs));
 }
+//#endregion
+//#region src/Cli.ts
+const SIGNAL_NUMBERS = Object.freeze({
+	SIGINT: 2,
+	SIGTERM: 15
+});
 /**
-* 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).
+* 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 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
+function observeTerminatingSignal() {
+	let observed = null;
+	for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => {
+		observed = SIGNAL_NUMBERS[signal] ?? null;
 	});
+	return () => observed;
 }
-/**
-* 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);
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/**
-* 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;
+function stringField(node, key) {
+	const value = node[key];
+	return (() => {
+		if (typeof value === "string") return value;
+	})();
+}
+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;
 	}
-	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 "";
+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 (() => {
+		if (tag === void 0) return "unknown";
+		return 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;
 }
+const REPORTER_NAMES = [
+	"clear-text",
+	"progress",
+	"html",
+	"json",
+	"progress-stream"
+];
 /**
-* 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.
+* v4 option descriptions are stored as `Option.some(string)` on the compiled
+* `Single`; the walker unwraps the option.
 */
-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;
+function descriptionOf(single) {
+	const description = single["description"];
+	if (!isObject(description)) return "";
+	switch (tagOf(description)) {
+		case "Some": {
+			const value = description["value"];
+			return (() => {
+				if (typeof value === "string") return value;
+				return "";
+			})();
 		}
-		if (S.is(CliError.UnexpectedArgument)(error)) return error.arguments[0];
-		if (S.is(CliError.UnknownSubcommand)(error)) return error.subcommand;
+		default: return "";
 	}
 }
-/**
-* 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)
+function describeSingle(single, isOptional, out) {
+	const name = stringField(single, "name") ?? "";
+	const primitive = (() => {
+		if (isObject(single["primitiveType"])) return single["primitiveType"];
+		return {};
+	})();
+	const kind = kindOf(primitive);
+	const choices = (() => {
+		if (name === "reporters") return REPORTER_NAMES;
+		if (kind === "choice") return choiceValues(primitive);
+	})();
+	const description = descriptionOf(single);
+	const required = kind !== "boolean" && !isOptional;
+	const described = {
+		name,
+		aliases: stringArrayField(single, "aliases"),
+		kind,
+		required,
+		...(() => {
+			if (choices !== void 0) return { choices };
+			return {};
+		})(),
+		description
 	};
-}
-/**
-* 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
-		};
-		stream.sink(document);
-		return;
-	}
-	if (Exit.isFailure(exit)) {
-		stream.sink({
-			kind: "error",
-			...buildErrorEnvelope(exit, code, captured, argv)
+	if (single["kind"] === "argument") {
+		out.args.push({
+			name,
+			kind,
+			required,
+			description
 		});
 		return;
 	}
-	if (captured.length > 0) {
-		const document = {
-			kind: "help",
-			schemaVersion: "1.0",
-			code: 0,
-			help: captured
-		};
-		stream.sink(document);
-		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 = (() => {
+				if (typeof index === "number") return orderedParams[index];
+			})();
+			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;
 	}
-	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 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"])) {
+		let orderedParams = [];
+		const maybeOrdered = config["orderedParams"];
+		if (Array.isArray(maybeOrdered)) orderedParams = maybeOrdered;
+		walkConfigTree(config["tree"], orderedParams, out);
 	}
-	return false;
+	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: (() => {
+			if (typeof node["description"] === "string") return node["description"];
+			return "";
+		})(),
+		options: out.flags,
+		args: out.args,
+		subcommands
+	};
 }
-/**
-* 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.
-*/
-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;
+function readCoreEntries() {
+	try {
+		const manifestPath = createRequire(import.meta.url).resolve("@systemfsoftware/stryker-js-platform-node/package.json");
+		const raw = readFileSync(manifestPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		const ExportsSchema = S.Struct({ exports: S.Record(S.String, S.Unknown) });
+		const decoded = S.decodeUnknownResult(ExportsSchema)(parsed);
+		if (Result.isSuccess(decoded)) return Object.keys(decoded.success.exports).filter((key) => key !== "./package.json");
+		return [];
+	} catch {
+		return [];
 	}
-	if (carriesConfigError(exit.cause)) return ExitClass.ConfigError;
-	return 1;
 }
-/**
-* The single operation of the CLI's executor 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
-* request the handlers left, and on every outcome — success, failure and
-* interruption alike — emits the machine-mode terminal event (error/help/
-* null verdict) and drains the stream, returning the classed exit code as its
-* value. SIGINT/SIGTERM interrupt the current fiber so the finalizer runs
-* before the process exits; the code is resolved exactly once (R6), in the
-* finalizer, where the terminal event's `code` is chosen from the same inputs
-* the teardown used before.
-*/
-const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
-	const stream = yield* createRunEventStream(input.mode);
-	const runMutationTest = input.runMutationTest ?? defaultRunMutationTest(hostOptionsOf(input.mode, stream));
-	let currentFiber = null;
-	let lastSignal = null;
-	const resolveClassedExitCode = (exit) => {
-		const signal = lastSignal;
-		if (signal !== null) return 128 + signal;
-		if (Exit.isFailure(exit)) return resolveCliExitCode(exit);
-		return resolveExitCode(getPendingExitClasses(), null);
+function buildLLMSManifest(command, version) {
+	const root = describeCommandNode(command) ?? {
+		name: "",
+		description: "",
+		options: [],
+		args: [],
+		subcommands: []
 	};
-	const onSignal = (signal) => {
-		lastSignal = SIGNAL_NUMBERS[signal] ?? null;
-		process.removeListener("SIGINT", onSignal);
-		process.removeListener("SIGTERM", onSignal);
-		if (currentFiber !== null) currentFiber.interruptUnsafe(currentFiber.id);
+	return {
+		schemaVersion: "1.0",
+		tool: root.name,
+		version,
+		commands: [root],
+		entries: readCoreEntries()
 	};
-	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(() => {
-		stream.ensureOpen({
-			mode: "machine",
-			signal: "flag",
-			stdoutIsTTY: process.stdout.isTTY === true
-		});
-		stream.sink(llmsRequest.document);
-	})), Match.orElse(() => Effect.die("unreachable cli request variant")));
-	const program = Effect.acquireUseRelease(Effect.sync(() => {
-		currentFiber = Fiber.getCurrent() ?? null;
-		process.on("SIGINT", onSignal);
-		process.on("SIGTERM", onSignal);
-	}), () => Effect.gen(function* () {
-		yield* stream.open;
-		yield* input.program;
-		const request = yield* Ref.get(input.requestRef);
-		yield* Option.match(request, {
-			onNone: () => Effect.void,
-			onSome: (cliRequest) => dispatch(cliRequest)
-		});
-	}), () => Effect.sync(() => {
-		process.removeListener("SIGINT", onSignal);
-		process.removeListener("SIGTERM", onSignal);
-	}));
-	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);
-		yield* stream.closeAndDrain;
-		return code;
-	}));
-});
-//#endregion
-//#region src/StrykerCliHandler.ts
+}
+/** The manifest as one JSON document, ready for stdout — the U4 convention. */
+function emitLLMSManifest(command, version) {
+	return JSON.stringify(buildLLMSManifest(command, version));
+}
 function createSplitter(separator) {
 	return (value) => value.split(separator).filter(Boolean);
 }
@@ -1390,7 +1528,10 @@ const splitOnSpace = createSplitter(" ");
 */
 function parseCleanDirOption(value) {
 	const v = value.toLocaleLowerCase();
-	return v === "always" ? v : v !== "false" && v !== "0";
+	return (() => {
+		if (v === "always") return v;
+		return v !== "false" && v !== "0";
+	})();
 }
 /**
 * Commander characterization: a pure integer is parsed as a number, anything
@@ -1408,31 +1549,12 @@ const optional = (option) => Flag.optional(option);
 * `Option.some(false)` for an explicit `--no-x`, so both map back to
 * `undefined` and leave the config-file default in force (KTD4).
 */
-const absentWhenFalse = (value) => Option.isSome(value) && value.value ? true : void 0;
-const LOG_LEVELS = [
-	"fatal",
-	"error",
-	"warn",
-	"info",
-	"debug",
-	"trace",
-	"off"
-];
-const LOG_LEVEL_LOOKUP = {
-	fatal: true,
-	error: true,
-	warn: true,
-	info: true,
-	debug: true,
-	trace: true,
-	off: true
+const absentWhenFalse = (value) => {
+	if (Option.isSome(value) && value.value) return true;
 };
-function isLogLevel(value) {
-	return LOG_LEVEL_LOOKUP[value] === true;
-}
 function setLogLevel(target, key, value) {
 	const unwrapped = unwrap(value);
-	if (unwrapped !== void 0 && isLogLevel(unwrapped)) target[key] = unwrapped;
+	if (unwrapped !== void 0) target[key] = unwrapped;
 }
 const runOptions = {
 	ignorePatterns: Flag.string("ignorePatterns").pipe(Flag.withDescription("A comma separated list of patterns used for specifying which files need to be ignored. This should only be used in cases where you experience a slow Stryker startup, because too many (or too large) files are copied to the sandbox that are not needed to run the tests. For example, image or movie directories. Note: This option will have NO effect when using the `--inPlace` option. The directories `node_modules`, `.git` and some others are always ignored. Example: `--ignorePatterns dist`. These patterns are ALWAYS ignored: [`node_modules`, `.git`, `/reports`, `*.tsbuildinfo`, `/stryker.log`, `.stryker-tmp`]. Because Stryker always ignores these, you should rarely have to adjust the `ignorePatterns` setting at all. This is useful to speed up Stryker by reducing the size of the sandbox directory which has a positive effect on performance."), Flag.map(splitOnComma), optional),
@@ -1451,7 +1573,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 +1586,27 @@ 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", [
+		"fatal",
+		"error",
+		"warn",
+		"info",
+		"debug",
+		"trace",
+		"off"
+	]).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", [
+		"fatal",
+		"error",
+		"warn",
+		"info",
+		"debug",
+		"trace",
+		"off"
+	]).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")) };
@@ -1550,7 +1688,7 @@ function makeStrykerCommand(requestRef) {
 	const strykerCommand = Command.make("stryker", rootConfig, (config) => {
 		if (config.llms === true) {
 			const document = {
-				kind: "manifest",
+				_tag: "manifest",
 				schemaVersion: "1.0",
 				code: 0,
 				manifest: emitLLMSManifest(strykerCommand, strykerVersion)
@@ -1598,48 +1736,148 @@ 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"))));
-/**
-* 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
-* framework renders through, delegates the whole run to the executor cell and
-* 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) {
+] }), Path.layer, FileSystem.layerNoop({}), terminalLayer, NodeStdio.layer, NodeChildProcessSpawner.layer.pipe(Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer))));
+function strykerCliEffect(argv, runMutationTest, detectMode, createRunEventStream, lastSignal) {
 	return Effect.gen(function* () {
-		const mode = detectMode();
+		const mode = yield* 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 outcome = yield* Effect.result(runStrykerCli({
+		const consoleLayer = (() => {
+			if (mode.mode === "machine") return machineConsoleLayer;
+			return Layer.empty;
+		})();
+		const cliEffect = Command.runWith(command, { version: strykerVersion })(argv).pipe(Effect.provide(Layer.mergeAll(consoleLayer, cliLayer)));
+		const result = yield* Effect.result(runStrykerCli({
 			program: cliEffect,
 			requestRef,
 			mode,
 			runMutationTest,
-			recordExitCode,
-			argv
+			argv,
+			lastSignal
 		}, createRunEventStream));
-		return Result.isFailure(outcome) ? outcome.failure : outcome.success;
-	});
+		if (Result.isFailure(result)) return result.failure;
+		return result.success;
+	}).pipe(Effect.orElseSucceed(() => 2));
 }
+const defaultRunMutationTest = (hostOptions, queue) => (options) => Effect.scoped(runMutationTest(options)).pipe(Effect.provideService(RunEvents, queue), Effect.provide(makeRunLayer(hostOptions)));
+function hostOptionsOf(mode, stream) {
+	return {
+		runId: stream.runId,
+		resolvedMode: mode,
+		runStartedAt: stream.startedAt,
+		basePath: resolve(process.cwd()),
+		reporterPluginModules: [import.meta.resolve("@systemfsoftware/stryker-js-html-reporter"), import.meta.resolve("@systemfsoftware/stryker-js-platform-node/builtin-reporters")],
+		allowConsoleColors: isColorEnabled(mode, process.env["NO_COLOR"])
+	};
+}
+const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
+	const stream = yield* createRunEventStream(input.mode);
+	const hostOptions = hostOptionsOf(input.mode, stream);
+	const runMutationTestImpl = input.runMutationTest ?? defaultRunMutationTest(hostOptions, stream.queue);
+	const basePath = hostOptions.basePath;
+	const pathService = yield* Path.Path.pipe(Effect.provide(NodePath.layer));
+	let currentFiber = 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) => (() => {
+		if (runRequest.survivors) return runSurvivorsAdmission(runMutationTestImpl, stream, input.mode, runRequest.options, basePath).pipe(Effect.provide(makeRunLayer(hostOptions)));
+		return runMutationTestImpl(runRequest.options).pipe(Effect.orDie);
+	})()), Match.tag("llms", (llmsRequest) => Effect.gen(function* () {
+		stream.ensureOpen({
+			mode: "machine",
+			signal: "flag",
+			stdoutIsTTY: process.stdout.isTTY === true
+		});
+		yield* Queue.offer(stream.queue, ManifestRendered.make({
+			schemaVersion: "1.0",
+			code: 0,
+			manifest: llmsRequest.document.manifest
+		}));
+	})), Match.orElse(() => Effect.die("unreachable cli request variant")));
+	const program = Effect.acquireUseRelease(Effect.sync(() => {
+		currentFiber = Fiber.getCurrent() ?? null;
+		process.on("SIGINT", onSignal);
+		process.on("SIGTERM", onSignal);
+	}), () => Effect.gen(function* () {
+		yield* stream.open;
+		yield* input.program;
+		const request = yield* Ref.get(input.requestRef);
+		return yield* Option.match(request, {
+			onNone: () => Effect.void,
+			onSome: (cliRequest) => dispatch(cliRequest)
+		});
+	}), () => Effect.sync(() => {
+		process.removeListener("SIGINT", onSignal);
+		process.removeListener("SIGTERM", onSignal);
+	}));
+	return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+		const outcome = classifyRunOutcome(yield* Effect.exit(restore(program)), input.lastSignal(), input.argv);
+		const code = runOutcomeCode(outcome);
+		if (input.mode.mode === "machine") yield* emitMachineModeOutput(stream, input.mode, outcome, basePath, pathService);
+		yield* stream.closeAndDrain;
+		return code;
+	}));
+});
+//#endregion
+//#region src/StreamFile.ts
+const STREAM_FILE_DIR = "reports";
+const STREAM_FILE_NAME = "mutation-stream.jsonl";
+const encodeUtf8 = (line) => new TextEncoder().encode(line);
+const drainStreamFile = (framed) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const file = (yield* Path.Path).join(STREAM_FILE_DIR, STREAM_FILE_NAME);
+	yield* fs.makeDirectory(STREAM_FILE_DIR, { recursive: true }).pipe(Effect.orDie);
+	yield* Stream.run(framed.pipe(Stream.map(encodeUtf8)), fs.sink(file, { flag: "w" })).pipe(Effect.orDie);
+});
+const RunEventStreamFileLive = Layer.effect(RunEventStreamPort, Effect.gen(function* () {
+	const stdio = yield* Stdio.Stdio;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const drainFramed = (framed) => drainStreamFile(framed).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
+	return RunEventStreamPort.of({ createRunEventStream: (resolved) => makeRunEventStream(stdio, resolved, drainFramed) });
+}));
 //#endregion
 //#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) {
+	let withoutV = version;
+	if (version.startsWith("v")) withoutV = version.slice(1);
+	const dashBaseRaw = withoutV.split("-")[0];
+	let dashBase = withoutV;
+	if (dashBaseRaw !== void 0) dashBase = dashBaseRaw;
+	const baseRaw = dashBase.split("+")[0];
+	let base = dashBase;
+	if (baseRaw !== void 0) base = baseRaw;
+	const parts = base.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, RunEventStreamFileLive).pipe(Layer.provide(Layer.mergeAll(NodeStdio.layer, NodeFileSystem.layer, NodePath.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();
+		if (signal === null) onExit(EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER);
+		else onExit(128 + signal);
 	}
 });
 //#endregion