@systemfsoftware/stryker-js-cli 3.2.0 → 4.0.0

package/dist/main.mjs

@@ -1,303 +1,123 @@
 #!/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 * as Logger from "effect/Logger";
-import { ExitClass, buildVerdictEnvelope, defaultOptions, defaultStages, forkCoreSchema, generateRunId, highestExitClass, makeRunLayer, readConfig, resolveExitCode, runMutationTest, strykerEngines, strykerVersion, toRelativeNormalizedFileName } from "@systemfsoftware/stryker-js-mutation-run";
-import * as Context from "effect/Context";
-import * as Result from "effect/Result";
-import * as CliError from "effect/unstable/cli/CliError";
-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 * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
-import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
-import * as NodePath$1 from "@effect/platform-node-shared/NodePath";
-import { RENDERED_OPTION_DEFAULTS, causeText } from "@systemfsoftware/stryker-js-plugin-api/core";
+import { 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 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 { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { NodePath } from "@effect/platform-node";
-import * as Match from "effect/Match";
+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 * as S from "effect/Schema";
 import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
-import { performance } from "node:perf_hooks";
-import { format, inspect } from "node:util";
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { noopLogger } from "@systemfsoftware/stryker-js-plugin-api/logging";
+import * as Context from "effect/Context";
 import { pipe } from "effect/Function";
-import { PluginKind } from "@systemfsoftware/stryker-js-plugin-api/plugin";
-import { strykerPlugins } from "@systemfsoftware/stryker-js-mutation-report/stryker-plugins";
-//#region src/output-mode.ts
-/**
-* The known tool variables. Narrow per the plan — exactly
-* `['CLAUDECODE', 'CODEX_SANDBOX']` — and load-bearing rather than a
-* 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 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 succeedRun(ok) {
+	return Result.succeed(ok);
 }
-//#endregion
-//#region src/output-mode-probe.ts
-var OutputModeProbeTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/output-mode-probe/OutputModeProbeTag") {};
-const OutputModeProbe = OutputModeProbeTag;
-const OutputModeProbeLive = Layer.succeed(OutputModeProbe, OutputModeProbe.of({ detectMode: () => {
-	const envMode = process.env["STRYKER_MODE"];
-	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/stream-protocol.ts
-/**
-* The heartbeat interval (R19), matching Terraform's `apply_progress`
-* cadence: long enough that a slow phase is not noisy, short enough that a
-* consumer can tell "slow" from "hung" without waiting for a mutant event.
-*/
-const TICK_INTERVAL_MS = 1e4;
-//#endregion
-//#region src/run-event-stream.ts
-var RunEventStreamPortTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/run-event-stream/RunEventStreamPortTag") {};
-const RunEventStreamPort = RunEventStreamPortTag;
-const isTerminalEvent = (event) => event.kind === "verdict" || event.kind === "error" || event.kind === "help" || event.kind === "manifest";
-/**
-* The push adapter from the run's synchronous sink to the callback mailbox.
-* `Queue.offer`/`Queue.end` on an unbounded queue never block or fail, so the
-* sync sink can drive them with `Effect.runSyncWith(ctx)` using the context
-* captured where the sink is constructed. Takes the queue and the captured
-* context, keeping the adapter pure with respect to its environment.
-*/
-function queueEmit(queue, ctx) {
-	return {
-		single: (event) => {
-			Effect.runSyncWith(ctx)(Queue.offer(queue, event));
-		},
-		end: () => {
-			Effect.runSyncWith(ctx)(Queue.end(queue));
-		}
-	};
+function failRun(error) {
+	return Result.fail(error);
 }
-/**
-* 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).
-*/
-const drainOf = (stdio, framed) => Stream.run(framed, stdio.stdout({ endOnDone: true })).pipe(Effect.ignore);
-/**
-* 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.
-*/
-const makeRunEventStream = (stdio, resolved) => Effect.gen(function* () {
-	const runId = generateRunId();
-	const startedAt = yield* Clock.currentTimeMillis;
-	const ctx = yield* Effect.context();
-	const state = {
-		mode: resolved.mode,
-		signal: resolved.signal,
-		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, ctx);
-	}).pipe(Effect.andThen(Deferred.succeed(registered, void 0))));
-	const tickStream = Stream.tick(TICK_INTERVAL_MS).pipe(Stream.filter(() => state.mode === "machine" && state.headerWritten && !state.terminalWritten), Stream.mapEffect(() => Effect.gen(function* () {
-		return {
-			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) })));
-//#endregion
-//#region src/signal-observer.ts
-const SIGNAL_NUMBERS = Object.freeze({
-	SIGINT: 2,
-	SIGTERM: 15
-});
-/**
-* Installs the listeners and returns the reader.
-*
-* The listener records and returns: interrupting the run is the runtime's job,
-* and doing it from here would race the run's own finalizer for the stream.
-* `once` per signal, because a second delivery of the same signal cannot
-* change the answer.
-*/
-function observeTerminatingSignal() {
-	let observed = null;
-	for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => {
-		observed = SIGNAL_NUMBERS[signal] ?? null;
-	});
-	return () => observed;
+function 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/survivors-report.schema.ts
+//#region src/Survivors.workflow.ts
 /**
 * The mutant shape the admission carries, named once because both the decision's
 * `Admitted` payload and the command's precomputed survivor list are the same shape.
@@ -318,15 +138,6 @@ const MutantShape = S.Struct({
 		})
 	})
 });
-/**
-* 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) })),
@@ -350,8 +161,6 @@ const PriorReportDocument = S.Struct({
 		}))
 	}))
 });
-//#endregion
-//#region src/survivors-admission.workflow.ts
 /**
 * U8 — survivor re-run admission (R10, R11, KTD6, KTD7).
 *
@@ -475,22 +284,6 @@ function hashesMatch(priorReport, input) {
 		sourceContentHashes: input.sourceContentHashes
 	});
 }
-const rejection = (reason, detail) => ({
-	kind: "reject",
-	reason,
-	remediation: `${detail} ${SURVIVORS_RUN_FIRST_REMEDIATION}`
-});
-function admissionVerdict(input) {
-	const priorReport = input.priorReport;
-	if (priorReport === void 0) return rejection("no-report", NO_REPORT_DETAIL);
-	if (wasProducedBySurvivorsRun(priorReport)) return rejection("mismatch", SURVIVORS_RUN_SOURCE_DETAIL);
-	if (input.priorSurvivors.length === 0) return { kind: "no-survivors" };
-	if (!hashesMatch(priorReport, input)) return rejection("mismatch", MISMATCH_DETAIL);
-	return {
-		kind: "admit",
-		survivors: input.priorSurvivors
-	};
-}
 const SurvivorsAdmissionTypeId = Symbol.for("@systemfsoftware/stryker-js-cli/SurvivorsAdmission");
 var Admitted = class extends S.TaggedClass()("Admitted", { survivors: S.Array(MutantShape) }) {
 	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
@@ -505,48 +298,50 @@ var SurvivorsRejection = class extends S.TaggedError()("SurvivorsRejection", {
 }) {
 	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
 };
-/**
-* The survivors admission decision: the classification `admissionVerdict`
-* produces, assigned to the workflow channels — one arm per kind, no guard
-* chain. A missing report, a survivors-sourced report and a hash mismatch are
-* the same reject outcome with different reasons; only the rejection's
-* remediation names the full run to do first (R10).
-*/
-const admitSurvivorsRun = Workflow.make(AdmitSurvivorsRunCommand, (command) => Match.value(admissionVerdict(command)).pipe(Match.discriminator("kind")("reject", (verdict) => Result.fail(SurvivorsRejection.make({
-	reason: verdict.reason,
-	remediation: verdict.remediation
-}))), Match.discriminator("kind")("no-survivors", () => Result.succeed(NoSurvivors.make())), Match.discriminator("kind")("admit", (verdict) => Result.succeed(Admitted.make({ survivors: verdict.survivors }))), Match.exhaustive));
-//#endregion
-//#region src/survivors-exit.ts
-/** The exit class a rejected survivors run exits with (R6: exit 2). */
-const SURVIVORS_REJECT_EXIT_CLASS = ExitClass.ConfigError;
-//#endregion
-//#region src/cli-exit-code.ts
-function isExitClass(value) {
-	return value === ExitClass.VerdictFail || value === ExitClass.ConfigError || value === ExitClass.RuntimeError || value === ExitClass.InternalError;
+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);
 }
+const admitSurvivorsRun = Workflow.make(AdmitSurvivorsRunCommand, admissionDecision);
+//#endregion
+//#region src/Envelope.ts
 /**
-* The `exitClass` of a tagged error, when it carries one.
+* Envelope — the failure envelope and console capture leaf.
 *
-* Every `*.schema.ts` error in `mutation-run` carries a `readonly exitClass`
-* member (or schema field) — `2` for config, `3` for runtime, `4` for
-* internal. The field is deliberately off-wire, but at the CLI edge the
-* errors are in-process objects, so it is readable via `Reflect.get`.
+* 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.
 */
+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 (typeof raw !== "number" || !isExitClass(raw)) return;
+	if (!isExitClass(raw)) return;
 	return raw;
 }
-/**
-* Collects every `exitClass` present in a value's nested `cause` chain.
-*
-* Depth-capped and cycle-safe: schema errors nest (`PrepareFailedError`
-* wrapping `ConfigFileInvalidError` wrapping a validation detail), and a
-* malformed chain must not recurse unboundedly.
-*/
 function collectExitClassesFromValue(value, out, seen, depth) {
 	if (depth > 10 || value === null || value === void 0) return;
 	if (typeof value !== "object") return;
@@ -560,105 +355,37 @@ function collectExitClassesFromValue(value, out, seen, depth) {
 		else collectExitClassesFromValue(causeVal, out, seen, depth + 1);
 	}
 }
-/**
-* Collects every `exitClass` present in the failure's `Cause` and in each
-* error's nested `cause` field.
-*
-* A `Cause` holds typed `Fail` and defect `Die` reasons
-* (`repos/effect/packages/effect/src/Cause.ts:144-196`, `isFailReason` /
-* `isDieReason`). `Effect.mapError` replaces the error value while keeping
-* only the mapped error in `cause.reasons`
-* (`repos/effect/packages/effect/src/internal/effect.ts:3253-3267`), so a
-* wrapped config error is invisible at the top level and must be found by
-* walking both the `Cause` reasons and each error's own `cause` field.
-*/
 function collectExitClasses(exit) {
 	const out = [];
 	const seen = /* @__PURE__ */ new WeakSet();
 	if (Exit.isFailure(exit)) for (const reason of exit.cause.reasons) {
-		const candidate = Cause.isFailReason(reason) ? reason.error : Cause.isDieReason(reason) ? reason.defect : void 0;
+		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);
 	}
 	return out;
 }
-/**
-* Classifies a failed run for the finalizer: usage/parse failures
-* (`CliError` — except a bare help request, which exits 0), rejected
-* survivors runs (`SurvivorsRejection`), an unreadable prior report
-* (`S.SchemaError`) all exit 2; otherwise the highest `exitClass` found by
-* walking the failure's `Cause` reasons and each error's nested `cause` field
-* wins by the precedence `4 > 3 > 2 > 1` (via `highestExitClass`); no class
-* found is 1 (the framework's default). A successful run exits 0; the verdict
-* gates (U5) then resolve the final classed code.
-*
-* The report parse failure shares the survivors class deliberately. It is not a
-* verdict — the decider never sees the report — but the operator's answer is the
-* same class of answer as a rejection: the input you named cannot be used. Letting
-* it fall through to 1 would make an unusable `--survivors` input indistinguishable
-* from a crash.
-*
-* Previously this matched only a top-level `ConfigError` via `carriesConfigError`,
-* so a `PrepareFailedError` wrapping a `ConfigFileInvalidError` was invisible
-* and classes 3 and 4 were unreachable. Walking the chain makes them reachable.
-*/
-function resolveCliExitCode(exit) {
-	if (Exit.isSuccess(exit)) return 0;
-	if (Cause.hasInterruptsOnly(exit.cause)) return 1;
-	const failure = Cause.findErrorOption(exit.cause);
-	if (Option.isSome(failure)) {
-		const value = failure.value;
-		if (S.is(CliError.ShowHelp)(value)) return value.errors.length > 0 ? 2 : 0;
-		if (CliError.isCliError(value)) return 2;
-		if (S.is(SurvivorsRejection)(value)) return SURVIVORS_REJECT_EXIT_CLASS;
-		if (S.isSchemaError(value)) return SURVIVORS_REJECT_EXIT_CLASS;
-	}
-	const classes = collectExitClasses(exit);
-	const highest = highestExitClass(classes);
-	if (highest !== null) return highest;
-	return 1;
-}
-//#endregion
-//#region src/cli-failure-text.ts
-/**
-* The reason a domain error carries, when it carries one.
-*
-* Every stage error in this engine is an `S.TaggedError` whose payload field is
-* `reason` — `DryRunNoTestsError`, `DryRunFailedError`, `PrepareFailedError`
-* and friends. Those classes extend `Error`, but nothing assigns `.message`, so
-* reading `.message` off one yields the empty string and the operator is told
-* a run failed with no indication of why. Read the field the errors actually
-* populate, and fall back only when it is absent.
-*/
 function reasonOf(value) {
 	if (!("reason" in value)) return;
 	const reason = Reflect.get(value, "reason");
 	if (typeof reason !== "string" || reason.length === 0) return;
 	const detail = causeTextOf(value);
-	return detail === void 0 ? reason : `${reason}: ${detail}`;
+	if (detail === void 0) return reason;
+	return `${reason}: ${detail}`;
 }
-/**
-* The human-readable text of a domain error's wrapped `cause`, if it has one.
-*
-* Recurses, because these errors nest: a stage error wraps a
-* `TestRunnerFailed`, which wraps the spawn or import failure that actually
-* happened. Stopping at the first layer reports a tag name — "TestRunnerFailed"
-* — and leaves the operator to guess. Each layer contributes only what it
-* knows, so the reader gets the chain down to the real fault.
-*/
 function causeTextOf(value, depth = 0) {
 	if (depth > 4 || !("cause" in value)) return;
 	const cause = Reflect.get(value, "cause");
 	return causeText(cause, depth + 1);
 }
 function configDetailOf(value) {
-	const reason = reasonOf(value);
-	if (reason !== void 0) return reason;
-	const text = causeText(value, 0);
-	if (text !== void 0 && text.length > 0) return text;
-	if ("message" in value) {
-		const msg = Reflect.get(value, "message");
-		if (typeof msg === "string" && msg.length > 0) return msg;
-	}
+	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;
@@ -679,16 +406,15 @@ function pushConfigCauses(value, depth, stack) {
 		depth: depth + 1
 	});
 }
-/**
-* The first config-class error's detail in cause-chain order, for the
-* config remediation.
-*/
 function firstConfigErrorDetail(exit) {
 	if (!Exit.isFailure(exit)) return;
 	const seen = /* @__PURE__ */ new WeakSet();
 	const stack = [];
 	for (const reason of exit.cause.reasons) {
-		const candidate = Cause.isFailReason(reason) ? reason.error : Cause.isDieReason(reason) ? reason.defect : void 0;
+		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
@@ -700,128 +426,195 @@ function firstConfigErrorDetail(exit) {
 		const { value, depth } = entry;
 		if (!shouldVisitConfigValue(value, depth, seen)) continue;
 		seen.add(value);
-		if (exitClassOf(value) === ExitClass.ConfigError) {
+		if (exitClassOf(value) === "ConfigError") {
 			const detail = configDetailOf(value);
 			if (detail !== void 0) return detail;
 		}
 		pushConfigCauses(value, depth, stack);
 	}
 }
-/**
-* The contextual remediation for a failure, picked from the class of the
-* failure whose cause chain contains an `exitClass` of `ConfigError` (2)
-* names the config file, rejected survivors runs name the full run to do
-* first. Everything else points at the report file and the verdict envelope,
-* which is where a runtime failure's detail already is. The classification
-* walks the `Cause` reasons and each error's nested `cause` field — see
-* `collectExitClasses`.
-*/
-function remediationFor(exit, code) {
-	if (code > 128) return "the run was interrupted by a signal; re-run it to continue";
+function describeFailure(exit) {
+	if (!Exit.isFailure(exit)) return "Unknown failure";
 	const value = failureValue(exit);
 	if (value !== void 0) {
-		if (CliError.isCliError(value)) return "re-run with --help to see the full usage";
 		if (S.is(SurvivorsRejection)(value)) return value.remediation;
+		if (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);
 	}
-	if (collectExitClasses(exit).includes(ExitClass.ConfigError)) {
+	if (collectExitClasses(exit).includes("ConfigError")) {
 		const detail = firstConfigErrorDetail(exit);
-		return detail !== void 0 ? `check the config file: ${detail}` : "check the config file";
+		if (detail !== void 0) return detail;
 	}
-	return "see --reportFile or the verdict envelope on stdout";
+	const rendered = Cause.pretty(exit.cause);
+	if (rendered.length > 0) return rendered;
+	return "Unknown failure";
 }
-/**
-* The failure's own text, used when the capture buffer is empty — a failure
-* stryker reported through its own logger rather than the framework's
-* `Console`. Falls back to a rendered cause.
-*/
-function describeFailure(exit) {
-	if (Exit.isFailure(exit)) {
-		const value = failureValue(exit);
-		if (value !== void 0) {
-			if (S.is(SurvivorsRejection)(value)) return value.remediation;
-			if (typeof value === "object" && value !== null) {
-				const reason = reasonOf(value);
-				if (reason !== void 0) return reason;
-			}
-			if (value instanceof Error && value.message.length > 0) return value.message;
-			if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol") return String(value);
-			return Cause.pretty(exit.cause);
-		}
-		return Cause.pretty(exit.cause);
-	}
-	return "";
-}
-/**
-* The argument the framework reports it does not know, named the way the wire
-* contract spells it. The v4 parser fails wrapped in a ShowHelp whose errors
-* carry the offending flag or operand; when the unrecognized flag was given a
-* separate value (`--format text`), the value is the token the old parser
-* reported, so the token after the flag is named when one was given.
-*/
 function unrecognizedArgumentOf(exit, argv) {
 	if (!Exit.isFailure(exit)) return;
 	const value = failureValue(exit);
 	if (value === void 0 || !CliError.isCliError(value)) return;
-	const errors = S.is(CliError.ShowHelp)(value) ? value.errors : [value];
+	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 = at >= 0 ? argv[at + 1] : void 0;
-			return next !== void 0 && !next.startsWith("-") ? next : 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;
 	}
 }
-/**
-* 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;
 }
-//#endregion
-//#region src/cli-error-envelope.ts
-function buildErrorEnvelope(exit, code, captured, argv) {
-	const unrecognized = unrecognizedArgumentOf(exit, argv);
+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",
-		code,
-		error: unrecognized !== void 0 ? `Received unknown argument: '${unrecognized}'` : captured.length > 0 ? captured : describeFailure(exit),
-		remediation: remediationFor(exit, code)
+		code: runOutcomeCode(Result.fail(error)),
+		error: errorText(error, captured),
+		remediation: remediationText(error)
 	};
 }
-//#endregion
-//#region src/console-capture.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.
-*/
+function classifyRunOutcome(exit, signal, argv) {
+	return runOutcomeWorkflow(gatherRunOutcome(exit, signal, argv));
+}
 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));
@@ -835,86 +628,352 @@ 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)
-};
+});
+const machineConsoleLayer = Layer.effect(Console.Console, Clock.clockWith((clock) => Effect.sync(() => {
+	resetCapturedConsole();
+	return makeCapturingConsole(clock);
+})));
+function readCapturedConsole() {
+	return capturedConsoleChunks.join("\n");
+}
+function resetCapturedConsole() {
+	capturedConsoleChunks.length = 0;
+	countByLabel.clear();
+	timeByLabel.clear();
+}
+//#endregion
+//#region src/Output.workflow.ts
+const TOOL_VARIABLES$1 = ["CLAUDECODE", "CODEX_SANDBOX"];
 /**
-* 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).
+* 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.
 */
-const machineConsoleLayer = Layer.effect(Console.Console, Effect.sync(() => {
-	resetCapturedConsole();
-	return capturingConsole;
-}));
+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))
+}) {};
 /**
-* 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.
+* 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 readCapturedConsole() {
-	return capturedConsoleChunks.join("\n");
+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
+	});
+}
+function modeDecision(command) {
+	return r4(command);
 }
+const resolveModeWorkflow = Workflow.make(ResolveModeCommand, modeDecision);
+//#endregion
+//#region src/Output.ts
+/**
+* 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.
+*/
+/**
+* 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.
+*/
+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 {
+		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"];
 /**
-* Clears the capture buffer and the count/time tables. Called when the
-* machine layer is constructed so every run starts empty.
+* 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 resetCapturedConsole() {
-	capturedConsoleChunks.length = 0;
-	countByLabel.clear();
-	timeByLabel.clear();
+function isColorEnabled(resolved, noColor) {
+	if (resolved.mode !== "human") return false;
+	if (noColor === void 0) return true;
+	if (noColor.length === 0) return true;
+	return false;
 }
-//#endregion
-//#region src/cli-machine-output.ts
+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({}) }));
 /**
 * 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)
@@ -935,11 +994,18 @@ function emitNullScoreVerdict(stream, mode, thresholds, config, basePath, pathSe
 			name: "StrykerJS",
 			version: strykerVersion
 		}
-	}, mode.mode, mode.signal, stream.runId, basePath, [], pathService);
-	stream.sink({
-		kind: "verdict",
-		...envelope
-	});
+	}, 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
+	}));
 }
 /**
 * Emits the machine-mode output from the run's finalizer — it runs on
@@ -954,50 +1020,70 @@ function emitNullScoreVerdict(stream, mode, thresholds, config, basePath, pathSe
 * `--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, basePath, pathService) {
+function emitMachineModeOutput(stream, mode, outcome, basePath, pathService) {
 	return Effect.gen(function* () {
 		const captured = readCapturedConsole();
-		const value = failureValue(exit);
-		if (Exit.isFailure(exit) && S.is(CliError.ShowHelp)(value) && value.errors.length === 0) {
-			const document = {
-				kind: "help",
-				schemaVersion: "1.0",
-				code: 0,
-				help: captured
-			};
-			stream.sink(document);
-			return;
-		}
-		if (Exit.isFailure(exit)) {
-			stream.sink({
-				kind: "error",
-				...buildErrorEnvelope(exit, code, captured, argv)
-			});
-			return;
-		}
-		if (captured.length > 0) {
-			const document = {
-				kind: "help",
-				schemaVersion: "1.0",
-				code: 0,
-				help: captured
-			};
-			stream.sink(document);
+		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;
 		}
-		if (stream.isOpen()) emitNullScoreVerdict(stream, mode, (yield* defaultOptions).thresholds, {}, basePath, pathService);
+		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-bookkeeping.ts
-/** The path a `--survivors` run reads when no `survivorsPriorReport` is configured. */
+//#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";
-//#endregion
-//#region src/survivors-hashing.ts
-const { entries: objectEntries$1, fromEntries: objectFromEntries } = Object;
 /**
-* The content hash of one source file.
+* 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.
+*/
+/**
+* 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
+* runs. A malformed report therefore never reaches the decider, and nothing here casts
+* a third-party report type.
+*/
+const decodePriorReport = S.decodeUnknownResult(PriorReportDocument);
+const { entries: objectEntries, fromEntries: objectFromEntries } = Object;
+/**
 * 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.
 */
@@ -1011,11 +1097,8 @@ function sourceContentHash(content, hash) {
 * this is the recorded side, read back out of the report.
 */
 function priorSourceHashes(priorReport, hashContent) {
-	return objectFromEntries(objectEntries$1(priorReport.files).map(([file, fileResult]) => [file, sourceContentHash(fileResult.source, hashContent)]));
+	return objectFromEntries(objectEntries(priorReport.files).map(([file, fileResult]) => [file, sourceContentHash(fileResult.source, hashContent)]));
 }
-//#endregion
-//#region src/survivors-mutants.ts
-const { entries: objectEntries } = Object;
 /**
 * Converts a report mutant (1-based schema location) into the internal mutant
 * shape a run consumes (0-based positions, absolute file name) — the exact
@@ -1025,7 +1108,7 @@ const { entries: objectEntries } = Object;
 * incremental differ uses.
 */
 function reportMutantToMutant(file, mutant, resolveAbsolutePath) {
-	return {
+	return Mutant.make({
 		id: mutant.id,
 		fileName: resolveAbsolutePath(file),
 		mutatorName: mutant.mutatorName,
@@ -1040,7 +1123,7 @@ function reportMutantToMutant(file, mutant, resolveAbsolutePath) {
 				column: mutant.location.end.column - 1
 			}
 		}
-	};
+	});
 }
 /**
 * The survivors of the prior report: exactly the mutants whose status is
@@ -1057,11 +1140,11 @@ function extractSurvivors(priorReport, resolveAbsolutePath) {
 * ranges: the report's 1-based lines with the internal 0-based columns,
 * relative file names, deduplicated in first-seen order.
 */
-function survivorMutateSpans(survivors, basePath, pathService) {
+function survivorMutateSpans(survivors, basePath) {
 	const spans = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const survivor of survivors) {
-		const file = toRelativeNormalizedFileName(survivor.fileName, basePath, pathService);
+		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)) {
@@ -1071,18 +1154,7 @@ function survivorMutateSpans(survivors, basePath, pathService) {
 	}
 	return spans;
 }
-//#endregion
-//#region src/survivors-report.ts
-/**
-* Decodes a prior report read from disk. Pure, so it runs in the decode phase, whose
-* `Left` is fatal by construction — it reaches the derived error channel and no write
-* runs. A malformed report therefore never reaches the decider, and nothing here casts
-* a third-party report type.
-*/
-const decodePriorReport = S.decodeUnknownResult(PriorReportDocument);
-//#endregion
-//#region src/cli-survivors-admission.ts
-const hashContent = (content) => createHash("sha256").update(content, "utf-8").digest("hex");
+const hashContent = (content) => bytesToHex(sha256(utf8ToBytes(content)));
 const resolveAbsolutePath = (file) => resolve(file);
 /**
 * The survivors admission, as a description whose phases chain by type and
@@ -1095,10 +1167,9 @@ const resolveAbsolutePath = (file) => resolve(file);
 * stashed context back and dispatches the decision to the verdict/run,
 * failing the run with a rejection.
 */
-const survivorsAdmissionDescription = (runMutationTest, stream, mode, runContext, basePath) => pipe(Cell.read((cliOptions) => Effect.flatMap(Path.Path, (pathService) => resolveSurvivorsRunOptions(cliOptions, basePath).pipe(Effect.flatMap((resolvedOptions) => {
+const 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);
-	const read = readPriorReport(priorReportPath);
-	return Ref.set(runContext, {
+	return Effect.flatMap(readPriorReport(priorReportPath), (read) => Effect.flatMap(currentSourceHashesFor(priorReportFileKeys(read.raw)), (sourceContentHashes) => Ref.set(runContext, {
 		resolvedOptions,
 		priorReportPath,
 		pathService
@@ -1107,9 +1178,9 @@ const survivorsAdmissionDescription = (runMutationTest, stream, mode, runContext
 		priorReportRaw: read.raw,
 		priorReportFound: read.found,
 		priorReportPath,
-		sourceContentHashes: currentSourceHashesFor(priorReportFileKeys(read.raw))
-	}));
-})))), Cell.decode(({ resolvedOptions, priorReportRaw, priorReportFound, sourceContentHashes }) => {
+		sourceContentHashes
+	}))));
+}))), services)), Cell.decode(({ resolvedOptions, priorReportRaw, priorReportFound, sourceContentHashes }) => {
 	if (!priorReportFound) return Result.succeed(AdmitSurvivorsRunCommand.make({
 		priorReport: void 0,
 		currentConfig: resolvedOptions,
@@ -1133,11 +1204,12 @@ const survivorsAdmissionDescription = (runMutationTest, stream, mode, runContext
 	if (context === void 0) return Effect.die("the survivors admission read must run before its write");
 	const { resolvedOptions, priorReportPath, pathService } = context;
 	return Result.match(outcome, {
-		onSuccess: (decision) => Match.value(decision).pipe(Match.tag("NoSurvivors", () => Effect.sync(() => emitNullScoreVerdict(stream, mode, resolvedOptions.thresholds, resolvedOptions, basePath, pathService))), Match.tag("Admitted", (admitted) => {
+		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: admitted.survivors,
-				mutate: survivorMutateSpans(admitted.survivors, basePath, pathService),
+				survivors: admittedMutants,
+				mutate: survivorMutateSpans(admittedMutants, basePath),
 				survivorsPriorReport: priorReportPath,
 				incremental: false
 			}).pipe(Effect.orDie);
@@ -1160,38 +1232,35 @@ const survivorsAdmissionDescription = (runMutationTest, stream, mode, runContext
 */
 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, basePath), cliOptions);
+		return yield* Cell.apply(survivorsAdmissionDescription(runMutationTest, stream, mode, admissionContext, basePath, services), cliOptions);
 	});
 }
 function resolveSurvivorsRunOptions(cliOptions, basePath) {
-	return readConfig(cliOptions, noopLogger, forkCoreSchema, basePath);
+	return readConfig(cliOptions, basePath);
 }
 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;
 }
 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
+		}))))));
+	});
 }
 function priorReportFileKeys(raw) {
 	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return [];
@@ -1201,116 +1270,43 @@ 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
+	}))));
 }
 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-run.ts
-const defaultRunMutationTest = (hostOptions) => (options) => Effect.scoped(runMutationTest(defaultStages, options)).pipe(Effect.provide(makeRunLayer(hostOptions)));
+//#region src/Cli.ts
+const SIGNAL_NUMBERS = Object.freeze({
+	SIGINT: 2,
+	SIGTERM: 15
+});
 /**
-* 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.
+* 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 hostOptionsOf(mode, stream) {
-	return {
-		runEventSink: stream.sink,
-		runId: stream.runId,
-		resolvedMode: mode,
-		runStartedAt: stream.startedAt,
-		basePath: resolve(process.cwd()),
-		reporterPluginModules: [import.meta.resolve("@systemfsoftware/stryker-js-mutation-report/stryker-plugins")],
-		logSink: (line) => {
-			if (mode.mode === "human") process.stdout.write(line);
-			else process.stderr.write(line);
-		},
-		allowConsoleColors: isColorEnabled(mode, process.env["NO_COLOR"])
-	};
+function observeTerminatingSignal() {
+	let observed = null;
+	for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => {
+		observed = SIGNAL_NUMBERS[signal] ?? null;
+	});
+	return () => observed;
 }
-/**
-* The single operation of the CLI's run cell: the impure shell that
-* wraps the transport's command effect with the run bootstrap. It creates the
-* run's stream from the resolved mode, binds the host options a run is
-* executed with, opens the stream, runs the command effect, dispatches the
-* 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 hostOptions = hostOptionsOf(input.mode, stream);
-	const runMutationTestImpl = input.runMutationTest ?? defaultRunMutationTest(hostOptions);
-	const basePath = hostOptions.basePath;
-	const pathService = yield* Path.Path.pipe(Effect.provide(NodePath.layer));
-	let currentFiber = null;
-	const verdictOf = (value) => {
-		if (!Predicate.hasProperty(value, "verdict")) return [];
-		const candidate = value.verdict;
-		if (typeof candidate !== "number" || !isExitClass(candidate)) return [];
-		return [candidate];
-	};
-	const resolveClassedExitCode = (exit) => {
-		const signal = input.lastSignal();
-		if (signal !== null) return 128 + signal;
-		if (Exit.isFailure(exit)) return resolveCliExitCode(exit);
-		return resolveExitCode(verdictOf(exit.value), null);
-	};
-	const onSignal = () => {
-		process.removeListener("SIGINT", onSignal);
-		process.removeListener("SIGTERM", onSignal);
-		if (currentFiber !== null) currentFiber.interruptUnsafe(currentFiber.id);
-	};
-	const dispatch = (request) => Match.value(request).pipe(Match.tag("run", (runRequest) => runRequest.survivors ? runSurvivorsAdmission(runMutationTestImpl, stream, input.mode, runRequest.options, basePath).pipe(Effect.provide(makeRunLayer(hostOptions))) : runMutationTestImpl(runRequest.options).pipe(Effect.orDie)), Match.tag("llms", (llmsRequest) => Effect.sync(() => {
-		stream.ensureOpen({
-			mode: "machine",
-			signal: "flag",
-			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);
-		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 exit = yield* Effect.exit(restore(program));
-		const code = resolveClassedExitCode(exit);
-		if (input.mode.mode === "machine") yield* emitMachineModeOutput(stream, input.mode, exit, code, input.argv, basePath, pathService);
-		yield* stream.closeAndDrain;
-		return code;
-	}));
-});
 function isObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringField(node, key) {
 	const value = node[key];
-	return typeof value === "string" ? value : void 0;
+	return (() => {
+		if (typeof value === "string") return value;
+	})();
 }
 function stringArrayField(node, key) {
 	const value = node[key];
@@ -1359,7 +1355,10 @@ const PRIMITIVE_KIND = {
 };
 function kindOf(primitive) {
 	const tag = stringField(primitive, "_tag");
-	return tag === void 0 ? "unknown" : PRIMITIVE_KIND[tag] ?? tag;
+	return (() => {
+		if (tag === void 0) return "unknown";
+		return PRIMITIVE_KIND[tag] ?? tag;
+	})();
 }
 function choiceValues(primitive) {
 	const keys = primitive["choiceKeys"];
@@ -1368,8 +1367,13 @@ function choiceValues(primitive) {
 	for (const key of keys) if (typeof key === "string") values.push(key);
 	return values;
 }
-/** The allowed reporter names, read from the U9 registry — the same list the plugin loader accepts. */
-const REPORTER_NAMES = strykerPlugins.filter((plugin) => plugin.kind === PluginKind.Reporter).map((plugin) => plugin.name);
+const REPORTER_NAMES = [
+	"clear-text",
+	"progress",
+	"html",
+	"json",
+	"progress-stream"
+];
 /**
 * v4 option descriptions are stored as `Option.some(string)` on the compiled
 * `Single`; the walker unwraps the option.
@@ -1380,16 +1384,25 @@ function descriptionOf(single) {
 	switch (tagOf(description)) {
 		case "Some": {
 			const value = description["value"];
-			return typeof value === "string" ? value : "";
+			return (() => {
+				if (typeof value === "string") return value;
+				return "";
+			})();
 		}
 		default: return "";
 	}
 }
 function describeSingle(single, isOptional, out) {
 	const name = stringField(single, "name") ?? "";
-	const primitive = isObject(single["primitiveType"]) ? single["primitiveType"] : {};
+	const primitive = (() => {
+		if (isObject(single["primitiveType"])) return single["primitiveType"];
+		return {};
+	})();
 	const kind = kindOf(primitive);
-	const choices = name === "reporters" ? REPORTER_NAMES : kind === "choice" ? choiceValues(primitive) : void 0;
+	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 = {
@@ -1397,7 +1410,10 @@ function describeSingle(single, isOptional, out) {
 		aliases: stringArrayField(single, "aliases"),
 		kind,
 		required,
-		...choices !== void 0 ? { choices } : {},
+		...(() => {
+			if (choices !== void 0) return { choices };
+			return {};
+		})(),
 		description
 	};
 	if (single["kind"] === "argument") {
@@ -1416,7 +1432,9 @@ function walkConfigNode(node, orderedParams, out) {
 	switch (tagOf(node)) {
 		case "Param": {
 			const index = node["index"];
-			const param = typeof index === "number" ? orderedParams[index] : void 0;
+			const param = (() => {
+				if (typeof index === "number") return orderedParams[index];
+			})();
 			if (param !== void 0) walkParam(param, false, out);
 			return;
 		}
@@ -1440,7 +1458,9 @@ function describeCommandNode(node) {
 	};
 	const config = node["config"];
 	if (isObject(config) && isObject(config["tree"])) {
-		const orderedParams = Array.isArray(config["orderedParams"]) ? config["orderedParams"] : [];
+		let orderedParams = [];
+		const maybeOrdered = config["orderedParams"];
+		if (Array.isArray(maybeOrdered)) orderedParams = maybeOrdered;
 		walkConfigTree(config["tree"], orderedParams, out);
 	}
 	const subcommands = [];
@@ -1454,17 +1474,28 @@ function describeCommandNode(node) {
 	}
 	return {
 		name: stringField(node, "name") ?? "",
-		description: typeof node["description"] === "string" ? node["description"] : "",
+		description: (() => {
+			if (typeof node["description"] === "string") return node["description"];
+			return "";
+		})(),
 		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 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 [];
+	}
+}
 function buildLLMSManifest(command, version) {
 	const root = describeCommandNode(command) ?? {
 		name: "",
@@ -1477,15 +1508,14 @@ function buildLLMSManifest(command, version) {
 		schemaVersion: "1.0",
 		tool: root.name,
 		version,
-		commands: [root]
+		commands: [root],
+		entries: readCoreEntries()
 	};
 }
 /** The manifest as one JSON document, ready for stdout — the U4 convention. */
 function emitLLMSManifest(command, version) {
 	return JSON.stringify(buildLLMSManifest(command, version));
 }
-//#endregion
-//#region src/stryker-cli.ts
 function createSplitter(separator) {
 	return (value) => value.split(separator).filter(Boolean);
 }
@@ -1498,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
@@ -1516,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),
@@ -1572,8 +1586,24 @@ 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 "${RENDERED_OPTION_DEFAULTS.logLevel}"`), optional),
-	fileLogLevel: Flag.choice("fileLogLevel", LOG_LEVELS).pipe(Flag.withDescription(`Set the log level for the "stryker.log" file. Possible values: fatal, error, warn, info, debug, trace and off. Default is "${RENDERED_OPTION_DEFAULTS.fileLogLevel}"`), optional),
+	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 "${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),
@@ -1658,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)
@@ -1706,21 +1736,18 @@ const cliLayer = Layer.mergeAll(CliConfig.layer({ builtIns: [
 	GlobalFlag.Wizard,
 	GlobalFlag.Completions,
 	GlobalFlag.LogLevel
-] }), Path.layer, FileSystem.layerNoop({}), terminalLayer, NodeStdio.layer, NodeChildProcessSpawner.layer.pipe(Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath$1.layer))));
-/**
-* The transport entry: builds the command tree, resolves the mode once at
-* the edge (never a second probe), provides the CLI and Console layers the
-* 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.
-*/
+] }), 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" ? machineConsoleLayer : 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,
@@ -1728,18 +1755,105 @@ function strykerCliEffect(argv, runMutationTest, detectMode, createRunEventStrea
 			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";
 const lastSignal = observeTerminatingSignal();
 function isSupportedNodeVersion(version) {
-	const withoutV = version.startsWith("v") ? version.slice(1) : version;
-	const dashBase = withoutV.split("-")[0] ?? withoutV;
-	const parts = (dashBase.split("+")[0] ?? dashBase).split(".").map((p) => Number.parseInt(p, 10));
+	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;
@@ -1753,7 +1867,7 @@ const program = Effect.gen(function* () {
 	const outputMode = yield* OutputModeProbe;
 	const runEvents = yield* RunEventStreamPort;
 	return yield* strykerCliEffect(process.argv.slice(2), void 0, outputMode.detectMode, runEvents.createRunEventStream, lastSignal);
-}).pipe(Effect.provideService(Logger.LogToStderr, true), Effect.provide(Layer.merge(OutputModeProbeLive, RunEventStreamLive).pipe(Layer.provide(NodeStdio.layer))));
+}).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) => {
@@ -1762,7 +1876,8 @@ NodeRuntime.runMain(program, {
 			return;
 		}
 		const signal = lastSignal();
-		onExit(signal === null ? EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER : 128 + signal);
+		if (signal === null) onExit(EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER);
+		else onExit(128 + signal);
 	}
 });
 //#endregion