@systemfsoftware/oxlint-plugin-test-discipline 4.1.0 → 6.1.3

package/dist/index.mjs

@@ -8,7 +8,7 @@ const EMIT_CALLEES = [
 ];
 const EXPECTED$3 = "a span declared once with Span.declare({ id, name, attrs }) and started through the start(attrs) it returns";
 const FIX$3 = "declare the span with Span.declare({ id, name, attrs }) and emit it with SomeSpan.start(attrs)";
-const meta$28 = {
+const meta$29 = {
 	type: "problem",
 	docs: { description: "Ban a raw span name passed to an emit API (startSpan, spanBuilder, startActiveSpan). Span names enter through Span.declare, never as a literal at the emit site." },
 	schema: [],
@@ -23,7 +23,7 @@ const memberPropertyName$1 = (callee) => {
 	if (callee.property.type !== "Identifier") return null;
 	return callee.property.name;
 };
-const calleeName$2 = (callee) => {
+const calleeName$3 = (callee) => {
 	if (callee.type === "Identifier") return callee.name;
 	if (callee.type === "MemberExpression") return memberPropertyName$1(callee);
 	return null;
@@ -39,7 +39,7 @@ const argName = (arg) => {
 	return inlineName(arg);
 };
 const inspect = (node) => {
-	const callee = calleeName$2(node.callee);
+	const callee = calleeName$3(node.callee);
 	if (callee === null || !isEmitCallee$1(callee)) return null;
 	const name = argName(node.arguments[0]);
 	if (name === null) return null;
@@ -49,7 +49,7 @@ const inspect = (node) => {
 	};
 };
 const banRawSpanNameEmit = defineRule({
-	meta: meta$28,
+	meta: meta$29,
 	create(context) {
 		return { CallExpression(node) {
 			const emitCall = inspect(node);
@@ -74,6 +74,11 @@ const TEST_BASENAME = /\.(?:test|spec)\.[cm]?tsx?$/;
 const TYPE_TEST_BASENAME = /\.tst\.[cm]?tsx?$/;
 const SANCTIONED_TEST_DIRS = /* @__PURE__ */ new Set(["tests"]);
 /**
+* The basename of a test the `effect-e2e` runner collects. Mirrors the runner's
+* default pattern `tests/**\/*.e2e.ts`, which is `.ts` only.
+*/
+const E2E_TEST_BASENAME = /\.e2e\.ts$/;
+/**
 * The only test location sanctioned under `src/`. A workflow property test
 * earns colocation with the workflow it covers, but not adjacency: it lives in
 * a `__tests__` directory beside that workflow, never as a sibling file.
@@ -81,8 +86,6 @@ const SANCTIONED_TEST_DIRS = /* @__PURE__ */ new Set(["tests"]);
 const NESTED_TEST_DIR = "__tests__";
 const TEST_TREE_DIRS = /* @__PURE__ */ new Set([...SANCTIONED_TEST_DIRS, NESTED_TEST_DIR]);
 const PROPERTY_SUFFIX = ".property.test.ts";
-const INTEGRATION_SUFFIX = ".integration.test.ts";
-const DIFFERENTIAL_SUFFIX = ".differential.test.ts";
 /**
 * Forbidden outright. A schema's laws are generated, so a hand-written
 * `*.schema.test.ts` only ever restates coverage that already exists.
@@ -110,30 +113,31 @@ const FOREIGN_RUNNERS = {
 	...FOREIGN_VITEST_SOURCES,
 	[LAWFUL_RUNNER]: true
 };
-/** Packages whose own tests drive Vitest directly: the runner and its conformance harness. */
-const RAW_VITEST_PACKAGES = {
-	"effect-spec-runtime": true,
-	"vitest": true,
-	"vitest-conformance": true
+/** fast-check calls that run a property themselves instead of handing an arbitrary to a harness. */
+const RAW_FC_METHODS = {
+	assert: true,
+	check: true,
+	property: true,
+	asyncProperty: true
 };
 const RUNNER_NAMES = /* @__PURE__ */ new Set([
 	"it",
 	"test",
 	"describe"
 ]);
-const MESSAGE$8 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const MESSAGE$6 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 const ABSENCE_MESSAGE = "{{name}} is untested. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 //#endregion
 //#region src/rules/behaviour-exercises-use-case.config.ts
-const NO_SUBJECT_IMPORT_NAME = "a *.integration.test.ts that reaches no package code";
+const NO_SUBJECT_IMPORT_NAME = "a behaviour test that reaches no package code";
 const NO_SUBJECT_IMPORT_EXPECTED = "an import of the package code under test";
-const NO_SUBJECT_IMPORT_ACTUAL = "a behaviour file whose every runtime import is vitest, @effect/vitest, @systemfsoftware/vitest, the gherkin spec package, effect, a Node builtin, or the file itself";
+const NO_SUBJECT_IMPORT_ACTUAL = "a test importing @systemfsoftware/effect-gherkin-spec whose every runtime import is vitest, @effect/vitest, @systemfsoftware/vitest, the gherkin spec package, effect, a Node builtin, or the file itself";
 const NO_SUBJECT_IMPORT_FIX = "a behaviour test exercises a use case, so it has to reach the package. A file that imports nothing but its runner and effect is asserting over values it built in the same file. Ask whether the assertion tests anything at all: if it restates a literal, delete the scenario; if it states an invariant that holds over generated inputs, move it to a *.property.test.ts beside the cell that decides it. Type-only imports never count - they are erased before anything runs - while a side-effect import (import \"../src/x.js\", import {} from \"../src/x.js\") does count, because it executes that module.";
-const meta$27 = {
+const meta$28 = {
 	type: "problem",
-	docs: { description: "A *.integration.test.ts must import the package under test, not only its runner and effect, so the scenario exercises code that ships rather than values the test built itself." },
+	docs: { description: "A behaviour test - any test file that imports @systemfsoftware/effect-gherkin-spec, whatever its name - must import the package under test, not only its runner and effect, so the scenario exercises code that ships rather than values the test built itself." },
 	schema: [],
-	messages: { noSubjectImport: MESSAGE$8 }
+	messages: { noSubjectImport: MESSAGE$6 }
 };
 //#endregion
 //#region src/rules/path.ts
@@ -143,7 +147,6 @@ const basenameOf = (filename) => Array$1.lastNonEmpty(segmentsOf(filename));
 /** Directory segments only — the basename never counts as a directory. */
 const directoriesOf = (filename) => Array$1.initNonEmpty(segmentsOf(filename));
 const isUnderSrc = (filename) => directoriesOf(filename).includes("src");
-const isRawVitestPackage = (filename) => directoriesOf(filename).some((segment) => RAW_VITEST_PACKAGES[segment] === true);
 const isInSanctionedTestDir = (filename) => directoriesOf(filename).some((segment) => SANCTIONED_TEST_DIRS.has(segment));
 const isInTestsImportScope = (filename) => {
 	const segments = segmentsOf(filename);
@@ -153,10 +156,146 @@ const isInTestsImportScope = (filename) => {
 };
 const isInConfiguredTestDir = (filename, dirs) => directoriesOf(filename).some((segment) => dirs.includes(segment));
 const isTestFile = (basename) => TEST_BASENAME.test(basename);
-const isBehaviourBasename = (basename) => basename.endsWith(INTEGRATION_SUFFIX);
+/**
+* A file the `effect-e2e` runner collects: an `.e2e.ts` basename under a `tests`
+* directory with no `__fixtures__` directory directly beneath a `tests`
+* directory, which is the runner's `tests/__fixtures__/**` exclusion.
+*/
+const isE2eTestFile = (filename) => {
+	const directories = directoriesOf(filename);
+	return E2E_TEST_BASENAME.test(basenameOf(filename)) && directories.some((segment) => SANCTIONED_TEST_DIRS.has(segment)) && !directories.some((segment, index) => segment === "__fixtures__" && SANCTIONED_TEST_DIRS.has(directories[index - 1] ?? ""));
+};
 const CELL_SUFFIX = /\.([^.]+)\.[cm]?tsx?$/;
 const cellOf = (basename) => CELL_SUFFIX.exec(basename)?.[1];
 //#endregion
+//#region src/rules/prop-call.ts
+const PROP_MODIFIERS$1 = /* @__PURE__ */ new Set([
+	"only",
+	"skip",
+	"todo"
+]);
+const isPropCallee$1 = (callee) => {
+	if (callee.type !== "MemberExpression" || callee.property.type !== "Identifier") return false;
+	if (callee.property.name === "prop") {
+		const object = callee.object;
+		if (object.type === "Identifier") return object.name === "it";
+		return object.type === "MemberExpression" && object.property.type === "Identifier" && object.property.name === "effect" && object.object.type === "Identifier" && object.object.name === "it";
+	}
+	return PROP_MODIFIERS$1.has(callee.property.name) && isPropCallee$1(callee.object);
+};
+const getPredicate = (node) => Array$1.findLast(node.arguments, (arg) => arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression");
+//#endregion
+//#region src/rules/lane.ts
+const HARNESS_LANES = [
+	[GHERKIN_PACKAGE, "behaviour"],
+	[CONFORMANCE_PACKAGE, "conformance"],
+	[DIFFERENTIAL_PACKAGE, "differential"],
+	[TRACE_SPEC_PACKAGE, "trace"]
+];
+const isPackageOrSubpath = (source, pkg) => source === pkg || source.startsWith(`${pkg}/`);
+/** The lane a harness import selects: the package itself or any subpath of it. */
+const harnessLaneOf = (source) => HARNESS_LANES.find(([pkg]) => isPackageOrSubpath(source, pkg))?.[1];
+const isTypeOnly = (node) => node.importKind === "type" || node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
+/**
+* Whether an import declaration registers end-to-end tests: it takes the
+* runner entry's `test` (an alias counts) or its namespace as a value. The
+* rest of the entry (`expect`, `describe`, hooks, the composition API, types)
+* registers no test, so importing it selects no lane.
+*/
+const importsE2eTest = (node) => node.source.value === "@systemfsoftware/effect-e2e/runner" && node.specifiers.some((specifier) => specifier.type === "ImportNamespaceSpecifier" || specifier.type === "ImportSpecifier" && specifier.importKind !== "type" && specifier.imported.type === "Identifier" && specifier.imported.name === "test");
+/**
+* Where a value import brings FastCheck in: the whole declaration for the
+* `fast-check` module (or a subpath), else each `FastCheck` named value import.
+*/
+const fastCheckImportSites = (node) => isTypeOnly(node) ? [] : isPackageOrSubpath(node.source.value, "fast-check") ? [node] : node.specifiers.filter((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind !== "type" && specifier.imported.type === "Identifier" && specifier.imported.name === "FastCheck");
+const isNode$5 = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+const childrenOf = (node, keys) => (keys[node.type] ?? []).flatMap((key) => {
+	const value = Reflect.get(node, key);
+	if (Array.isArray(value)) return value.filter(isNode$5);
+	return isNode$5(value) ? [value] : [];
+});
+const callsProperty = (program, keys) => {
+	const pending = [program];
+	for (let node = pending.pop(); node !== void 0; node = pending.pop()) {
+		if (node.type === "CallExpression" && isPropCallee$1(node.callee)) return true;
+		pending.push(...childrenOf(node, keys));
+	}
+	return false;
+};
+const derive = (program, keys) => {
+	const lanes = /* @__PURE__ */ new Set();
+	for (const statement of program.body) {
+		if (statement.type !== "ImportDeclaration" || isTypeOnly(statement)) continue;
+		const lane = harnessLaneOf(statement.source.value);
+		if (lane !== void 0) lanes.add(lane);
+		if (importsE2eTest(statement)) lanes.add("e2e");
+		if (fastCheckImportSites(statement).length > 0) lanes.add("property");
+	}
+	if (!lanes.has("property") && callsProperty(program, keys)) lanes.add("property");
+	return lanes;
+};
+const NO_LANES = /* @__PURE__ */ new Set();
+const cache = /* @__PURE__ */ new WeakMap();
+/**
+* The lanes the linted test file is in, derived once per program and shared by
+* every rule. A file is in a lane when Vitest runs it as a test (the `.test.ts` /
+* `.spec.ts` ending) or the `effect-e2e` runner collects it (`isE2eTestFile`);
+* a fixture or helper a test imports is not a test.
+* Call it from a visitor: the AST is complete once traversal starts.
+*/
+const lanesOf = (context) => {
+	if (!isTestFile(basenameOf(context.filename)) && !isE2eTestFile(context.filename)) return NO_LANES;
+	const program = context.sourceCode.ast;
+	const cached = cache.get(program);
+	if (cached !== void 0) return cached;
+	const lanes = derive(program, context.sourceCode.visitorKeys);
+	cache.set(program, lanes);
+	return lanes;
+};
+/**
+* The property lane holds a file only when no differential harness does: the
+* differential requirements already include the property ones, and a
+* differential file imports FastCheck for its arbitraries.
+*/
+const isPropertyFile = (lanes) => lanes.has("property") && !lanes.has("differential");
+/**
+* A property test beside Gherkin, conformance or trace scenarios: the property
+* belongs in its own workflow property file, never mixed into a harness test.
+*/
+const mixesPropertyIntoAHarness = (lanes) => isPropertyFile(lanes) && (lanes.has("behaviour") || lanes.has("conformance") || lanes.has("trace"));
+/**
+* What a package is, declared once in its own lint config's `settings`:
+* `vitest-runner` for the packages that are the test framework itself, `e2e`
+* for the packages that hold end-to-end suites. Every rule reads the same
+* declaration, so two rules can never disagree about it, and no rule takes a
+* role option (oxlint refuses one as a configuration error). The rule cannot
+* see how a package is wired, so it takes the declaration at its word; a
+* package that declares a role without being what it names gets that role's
+* treatment all the same, and the declaration is reviewed where it is made, in
+* the config diff.
+*/
+const SETTINGS_KEY = "@systemfsoftware/oxlint-plugin-test-discipline";
+const Role = Schema.Literals(["vitest-runner", "e2e"]);
+const PluginSettings = Schema.Struct({ [SETTINGS_KEY]: Schema.optional(Schema.Struct({ role: Schema.optional(Role) })) });
+const declaresRole = (context, role) => Option.exists(Schema.decodeUnknownOption(PluginSettings)(context.settings), (settings) => settings[SETTINGS_KEY]?.role === role);
+/**
+* Whether the linted file's package declares itself the Vitest runner. Settings
+* that do not decode declare no role, so every raw Vitest import is then refused.
+*/
+const isRunnerPackage = (context) => declaresRole(context, "vitest-runner");
+/**
+* Whether the linted file's package declares itself an end-to-end package.
+* Settings that do not decode declare no role.
+*/
+const isE2ePackage = (context) => declaresRole(context, "e2e");
+const importsARunner = (program) => program.body.some((statement) => statement.type === "ImportDeclaration" && !isTypeOnly(statement) && Object.keys(FOREIGN_RUNNERS).some((runner) => isPackageOrSubpath(statement.source.value, runner)));
+/**
+* The runner lane: a test in a package that declares the `vitest-runner` role
+* and imports a Vitest runner module (`vitest`, `@effect/vitest`, the fork, or a
+* subpath of one). Outside such a package the same imports select no lane.
+*/
+const isInRunnerLane = (context) => isTestFile(basenameOf(context.filename)) && isRunnerPackage(context) && importsARunner(context.sourceCode.ast);
+//#endregion
 //#region src/rules/behaviour-exercises-use-case.ts
 const EFFECT_PACKAGE = "effect";
 const FOUNDATION_PACKAGES = /* @__PURE__ */ new Set([
@@ -184,7 +323,7 @@ const isFoundationImport = (source, filename) => {
 	return FOUNDATION_PACKAGES.has(source) || source.startsWith(`${EFFECT_PACKAGE}/`) || source.startsWith("node:");
 };
 /** The stem of a path with its final extension stripped, for identity comparisons. */
-const stemOf = (file) => file.replace(/\.[^/]+$/, "");
+const stemOf = (file) => file.replace(/\.[^./]+$/, "");
 /**
 * A relative module specifier resolved against the linted file's directory,
 * with `..` segments collapsed. Existence is never checked: one file cannot
@@ -244,7 +383,7 @@ const DIST_SEGMENT = /(?:^|\/)dist\//;
 * rule the same way a real one does.
 */
 const behaviourExercisesUseCase = defineRule({
-	meta: meta$27,
+	meta: meta$28,
 	create(context) {
 		let reached = false;
 		return {
@@ -259,7 +398,7 @@ const behaviourExercisesUseCase = defineRule({
 				if (typeof node.value === "string" && DIST_SEGMENT.test(node.value)) reached = true;
 			},
 			"Program:exit"(node) {
-				if (!isBehaviourBasename(basenameOf(context.filename))) return;
+				if (!lanesOf(context).has("behaviour")) return;
 				if (reached) return;
 				for (const statement of node.body) {
 					if (statement.type !== "ImportDeclaration") continue;
@@ -286,21 +425,21 @@ const behaviourExercisesUseCase = defineRule({
 });
 //#endregion
 //#region src/rules/behaviour-one-feature-per-file.config.ts
-const TOO_FEW_FEATURES_NAME = "a *.integration.test.ts that constructs no Feature";
+const TOO_FEW_FEATURES_NAME = "a behaviour test that constructs no Feature";
 const TOO_FEW_FEATURES_EXPECTED = "exactly one Feature(...) — the capability the file proves";
-const TOO_FEW_FEATURES_ACTUAL = "a behaviour file with zero Feature(...) calls";
+const TOO_FEW_FEATURES_ACTUAL = "a test importing @systemfsoftware/effect-gherkin-spec with zero Feature(...) calls";
 const TOO_FEW_FEATURES_FIX = "one file, one capability. A Feature is what the file is for; if there is none, the file is not a behaviour test — delete it or add the missing Feature call.";
-const TOO_MANY_FEATURES_NAME = "a *.integration.test.ts accumulating multiple Feature(...) calls";
+const TOO_MANY_FEATURES_NAME = "a behaviour test accumulating multiple Feature(...) calls";
 const TOO_MANY_FEATURES_EXPECTED = "exactly one Feature(...) — every additional one signals a junk drawer";
-const TOO_MANY_FEATURES_ACTUAL = "a behaviour file with two or more Feature(...) calls";
+const TOO_MANY_FEATURES_ACTUAL = "a test importing @systemfsoftware/effect-gherkin-spec with two or more Feature(...) calls";
 const TOO_MANY_FEATURES_FIX = "splitting a junk drawer into several smaller junk drawers is not an improvement. When separating scenarios surfaces assertions that restate a pure function return value — change detectors against a lookup table or constant — those get deleted, not rehoused. Each surviving capability keeps its own file with exactly one Feature.";
-const meta$26 = {
+const meta$27 = {
 	type: "problem",
-	docs: { description: "A *.integration.test.ts must contain exactly one Feature(...) call. Zero or two-or-more is the junk-drawer signal that produced 41 scenarios of pure-function assertions in a single file." },
+	docs: { description: "A behaviour test - any test file that imports @systemfsoftware/effect-gherkin-spec, whatever its name - must contain exactly one Feature(...) call. Zero or two-or-more is the junk-drawer signal that produced 41 scenarios of pure-function assertions in a single file." },
 	schema: [],
 	messages: {
-		tooFewFeatures: MESSAGE$8,
-		tooManyFeatures: MESSAGE$8
+		tooFewFeatures: MESSAGE$6,
+		tooManyFeatures: MESSAGE$6
 	}
 };
 //#endregion
@@ -338,10 +477,10 @@ const hasAnyFeatureCall = (program) => {
 	return false;
 };
 const behaviourOneFeaturePerFile = defineRule({
-	meta: meta$26,
+	meta: meta$27,
 	create(context) {
 		return { "Program:exit"(node) {
-			if (!isBehaviourBasename(basenameOf(context.filename))) return;
+			if (!lanesOf(context).has("behaviour")) return;
 			const excess = findSecondFeatureCall(node);
 			if (excess !== null) {
 				const total = countFeatureCalls(node);
@@ -372,71 +511,26 @@ const behaviourOneFeaturePerFile = defineRule({
 });
 //#endregion
 //#region src/rules/behaviour-test-requires-gherkin.config.ts
-const FOREIGN_RUNNER_EXPECTED = "it and layer imported from @systemfsoftware/effect-gherkin-spec";
-const FOREIGN_RUNNER_ACTUAL = "a test runner imported directly from vitest, @effect/vitest or @systemfsoftware/vitest in a behaviour file";
-const FOREIGN_RUNNER_FIX = "import { it } from @systemfsoftware/effect-gherkin-spec and build the suite with makeFeature({ it })";
-const MISSING_MAKE_FEATURE_NAME = "a *.integration.test.ts without makeFeature";
+const MISSING_MAKE_FEATURE_NAME = "a behaviour test without makeFeature";
 const MISSING_MAKE_FEATURE_EXPECTED = "makeFeature imported from @systemfsoftware/effect-gherkin-spec";
-const MISSING_MAKE_FEATURE_ACTUAL = "a behaviour file that never constructs a Gherkin feature";
+const MISSING_MAKE_FEATURE_ACTUAL = "a test that imports @systemfsoftware/effect-gherkin-spec but never constructs a Gherkin feature";
 const MISSING_MAKE_FEATURE_FIX = "import { makeFeature } from @systemfsoftware/effect-gherkin-spec and declare `const Feature = makeFeature({ it, layer })`";
-const meta$25 = {
+const meta$26 = {
 	type: "problem",
-	docs: { description: "A *.integration.test.ts must drive its suite through makeFeature from @systemfsoftware/effect-gherkin-spec and must not import test runners from vitest, @effect/vitest or @systemfsoftware/vitest." },
+	docs: { description: "A test that imports @systemfsoftware/effect-gherkin-spec (the behaviour lane) drives its suite through makeFeature from that package." },
 	schema: [],
-	messages: {
-		foreignRunner: MESSAGE$8,
-		missingMakeFeature: MESSAGE$8
-	}
+	messages: { missingMakeFeature: MESSAGE$6 }
 };
 //#endregion
 //#region src/rules/behaviour-test-requires-gherkin.ts
-const ImportedIdentifier = Schema.Struct({ name: Schema.String });
-const isMakeFeatureSpecifier = (specifier) => {
-	const imported = specifier.imported;
-	return imported.type === "Identifier" && imported.name === "makeFeature";
-};
-/**
-* `null` for any specifier that cannot name a runner. The decode is unreachable
-* for a string-literal import name because the narrowing above rejects it first;
-* it exists so removing that narrowing fails loudly instead of silently.
-*/
-const foreignRunnerNameOf = (specifier) => {
-	if (specifier.imported.type !== "Identifier") return null;
-	const { name } = Schema.decodeSync(ImportedIdentifier)(specifier.imported);
-	return RUNNER_NAMES.has(name) ? name : null;
-};
+const importsMakeFeature = (statement) => harnessLaneOf(statement.source.value) === "behaviour" && statement.specifiers.some((specifier) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "makeFeature");
 const behaviourTestRequiresGherkin = defineRule({
-	meta: meta$25,
+	meta: meta$26,
 	create(context) {
-		const basename = basenameOf(context.filename);
 		return { Program(node) {
-			if (!isBehaviourBasename(basename)) return;
-			let hasMakeFeature = false;
-			for (const statement of node.body) {
-				if (statement.type !== "ImportDeclaration") continue;
-				const sourceValue = statement.source.value;
-				if (sourceValue === "@systemfsoftware/effect-gherkin-spec") for (const specifier of statement.specifiers) {
-					if (specifier.type !== "ImportSpecifier") continue;
-					if (isMakeFeatureSpecifier(specifier)) hasMakeFeature = true;
-				}
-				if (FOREIGN_RUNNERS[sourceValue] !== true) continue;
-				for (const specifier of statement.specifiers) {
-					if (specifier.type !== "ImportSpecifier") continue;
-					const runnerName = foreignRunnerNameOf(specifier);
-					if (runnerName === null) continue;
-					context.report({
-						node: specifier,
-						messageId: "foreignRunner",
-						data: {
-							name: runnerName,
-							expected: FOREIGN_RUNNER_EXPECTED,
-							actual: FOREIGN_RUNNER_ACTUAL,
-							fix: FOREIGN_RUNNER_FIX
-						}
-					});
-				}
-			}
-			if (!hasMakeFeature) context.report({
+			if (!lanesOf(context).has("behaviour")) return;
+			if (node.body.some((statement) => statement.type === "ImportDeclaration" && importsMakeFeature(statement))) return;
+			context.report({
 				node,
 				messageId: "missingMakeFeature",
 				data: {
@@ -455,33 +549,25 @@ const HARNESS_MEMBERS = {
 	released: true
 };
 const LEGACY_CHECK_MEMBER = "check";
-const HARNESS_PRESCRIPTION$2 = "import { Conformance } from @systemfsoftware/conformance-spec and express the test as Conformance.linearizable(implementation, { commands, model, run, fibers, operations }) in the scenario body";
-const meta$24 = {
+const HARNESS_PRESCRIPTION$1 = "import { Conformance } from @systemfsoftware/conformance-spec and express the test as Conformance.linearizable(implementation, { commands, model, run, fibers, operations }) in the scenario body";
+const meta$25 = {
 	type: "problem",
-	docs: { description: "Conformance tests must use the @systemfsoftware/conformance-spec Conformance barrel: Conformance.linearizable, Conformance.sequential, or Conformance.released. Raw runner calls (it, test, describe, and member forms like it.effect) and direct runner imports are forbidden in *.conformance.test.ts files; the retired Linearizable.check / SequentialModel.check / Released.check shapes are rejected, and importing Conformance without invoking a check is equally non-compliant." },
+	docs: { description: "Conformance tests must use the @systemfsoftware/conformance-spec Conformance barrel: Conformance.linearizable, Conformance.sequential, or Conformance.released. A test that imports @systemfsoftware/conformance-spec is in the conformance lane. Runner imports and calls in this lane are vitest-from-systemfsoftware-vitest findings. The retired Linearizable.check / SequentialModel.check / Released.check shapes are rejected, and importing Conformance without invoking a check is equally non-compliant." },
 	schema: [],
 	messages: {
-		rawRunnerCall: MESSAGE$8,
-		runnerImport: MESSAGE$8,
-		missingHarnessImport: MESSAGE$8,
-		legacyHarnessCall: MESSAGE$8,
-		missingHarnessUsage: MESSAGE$8
+		legacyHarnessCall: MESSAGE$6,
+		missingHarnessUsage: MESSAGE$6
 	}
 };
 //#endregion
 //#region src/rules/conformance-test-requires-harness.ts
-const memberObjectName$1 = (callee) => callee.type === "MemberExpression" && callee.object.type === "Identifier" ? callee.object.name : void 0;
+const memberObjectName$2 = (callee) => callee.type === "MemberExpression" && callee.object.type === "Identifier" ? callee.object.name : void 0;
 const memberPropertyName = (callee) => callee.type === "MemberExpression" && callee.property.type === "Identifier" ? callee.property.name : void 0;
 const memberName = (callee) => callee.type === "Identifier" ? callee.name : memberPropertyName(callee);
-const calleeName$1 = (callee) => callee.type === "Identifier" ? callee.name : memberObjectName$1(callee);
-const isRawRunnerCall = (callee) => {
-	const name = calleeName$1(callee);
-	return name !== void 0 && RUNNER_NAMES.has(name);
-};
-const isForeignRunnerImport$1 = (node) => typeof node.source.value === "string" && FOREIGN_RUNNERS[node.source.value] === true;
+const calleeName$2 = (callee) => callee.type === "Identifier" ? callee.name : memberObjectName$2(callee);
 const namesConformanceExport = (specifier) => specifier.imported.type === "Identifier" && specifier.imported.name === "Conformance";
 const recordBindings = (node, packageBindings, conformanceBindings) => {
-	if (node.source.value !== "@systemfsoftware/conformance-spec") return;
+	if (harnessLaneOf(node.source.value) !== "conformance") return;
 	for (const specifier of node.specifiers) {
 		packageBindings.add(specifier.local.name);
 		if (specifier.type === "ImportSpecifier" && namesConformanceExport(specifier)) conformanceBindings.add(specifier.local.name);
@@ -489,65 +575,40 @@ const recordBindings = (node, packageBindings, conformanceBindings) => {
 };
 const isHarnessInvocation = (callee, conformanceBindings) => {
 	const member = memberName(callee);
-	const root = calleeName$1(callee);
+	const root = calleeName$2(callee);
 	return member !== void 0 && HARNESS_MEMBERS[member] === true && root !== void 0 && conformanceBindings.has(root);
 };
 const isLegacyCheck = (callee, packageBindings) => {
-	const root = calleeName$1(callee);
+	const root = calleeName$2(callee);
 	return memberName(callee) === "check" && root !== void 0 && packageBindings.has(root);
 };
-const legacyCallText = (callee) => callee.type === "Identifier" ? callee.name : `${calleeName$1(callee)}.${LEGACY_CHECK_MEMBER}`;
+const legacyCallText = (callee) => callee.type === "Identifier" ? callee.name : `${calleeName$2(callee)}.${LEGACY_CHECK_MEMBER}`;
 const legacyCheckError = (callee) => ({
 	messageId: "legacyHarnessCall",
 	data: {
 		name: `a .${LEGACY_CHECK_MEMBER}(...) call in a conformance test file`,
-		expected: HARNESS_PRESCRIPTION$2,
+		expected: HARNESS_PRESCRIPTION$1,
 		actual: `${legacyCallText(callee)} is not a check the barrel exposes`,
-		fix: HARNESS_PRESCRIPTION$2
+		fix: HARNESS_PRESCRIPTION$1
 	}
 });
 const conformanceTestRequiresHarness = defineRule({
-	meta: meta$24,
+	meta: meta$25,
 	create(context) {
-		if (!context.filename.endsWith(".conformance.test.ts")) return {};
 		const packageBindings = /* @__PURE__ */ new Set();
 		const conformanceBindings = /* @__PURE__ */ new Set();
+		let conformance = false;
 		let violations = 0;
 		let hasHarnessInvocation = false;
 		return {
+			Program() {
+				conformance = lanesOf(context).has("conformance");
+			},
 			ImportDeclaration(node) {
-				if (isForeignRunnerImport$1(node)) {
-					context.report({
-						node,
-						messageId: "runnerImport",
-						data: {
-							name: `runner import from ${String(node.source.value)} in a conformance test file`,
-							expected: HARNESS_PRESCRIPTION$2,
-							actual: "a direct vitest / @effect/vitest / @systemfsoftware/vitest runner import bypasses the conformance check",
-							fix: `delete the runner import; ${HARNESS_PRESCRIPTION$2}`
-						}
-					});
-					violations += 1;
-					return;
-				}
-				recordBindings(node, packageBindings, conformanceBindings);
+				if (conformance) recordBindings(node, packageBindings, conformanceBindings);
 			},
 			CallExpression(node) {
-				if (isRawRunnerCall(node.callee)) {
-					const name = calleeName$1(node.callee) ?? "";
-					context.report({
-						node,
-						messageId: "rawRunnerCall",
-						data: {
-							name: `raw runner call (${name}) in a conformance test file`,
-							expected: HARNESS_PRESCRIPTION$2,
-							actual: `${name}(...) bypasses the conformance check`,
-							fix: `rewrite using ${HARNESS_PRESCRIPTION$2}`
-						}
-					});
-					violations += 1;
-					return;
-				}
+				if (!conformance) return;
 				if (isHarnessInvocation(node.callee, conformanceBindings)) {
 					hasHarnessInvocation = true;
 					return;
@@ -561,27 +622,14 @@ const conformanceTestRequiresHarness = defineRule({
 				}
 			},
 			"Program:exit"(node) {
-				if (packageBindings.size === 0) {
-					context.report({
-						node,
-						messageId: "missingHarnessImport",
-						data: {
-							name: `conformance test file without the ${CONFORMANCE_PACKAGE} import`,
-							expected: HARNESS_PRESCRIPTION$2,
-							actual: "no conformance check import found",
-							fix: HARNESS_PRESCRIPTION$2
-						}
-					});
-					return;
-				}
-				if (!hasHarnessInvocation && violations === 0) context.report({
+				if (conformance && !hasHarnessInvocation && violations === 0) context.report({
 					node,
 					messageId: "missingHarnessUsage",
 					data: {
 						name: `conformance test file imports ${CONFORMANCE_PACKAGE} but never invokes it`,
-						expected: HARNESS_PRESCRIPTION$2,
+						expected: HARNESS_PRESCRIPTION$1,
 						actual: "no Conformance.linearizable, Conformance.sequential, or Conformance.released call runs",
-						fix: HARNESS_PRESCRIPTION$2
+						fix: HARNESS_PRESCRIPTION$1
 					}
 				});
 			}
@@ -608,7 +656,7 @@ const INVALID_BEHAVIOR_CASE_FIX = "Convert behavior to PascalCase (e.g., throwEr
 const INVALID_CONDITION_CASE_FIX = "Convert condition to PascalCase (e.g., passwordInvalid → PasswordInvalid)";
 const EMPTY_BEHAVIOR_ACTUAL = "Empty string between Should_ and _When_";
 const EMPTY_CONDITION_ACTUAL = "Empty string after _When_";
-const meta$23 = {
+const meta$24 = {
 	type: "suggestion",
 	docs: { description: "Enforce DAMP (Descriptive and Meaningful Phrases) test naming format: Should_[ExpectedBehavior]_When_[Condition]" },
 	schema: [],
@@ -688,7 +736,7 @@ const isTestFunctionCall = (node) => {
 	return false;
 };
 const dampTestNaming = defineRule({
-	meta: meta$23,
+	meta: meta$24,
 	create(context) {
 		if (TYPE_TEST_BASENAME.test(basenameOf(context.filename))) return {};
 		return { CallExpression(node) {
@@ -712,92 +760,70 @@ const dampTestNaming = defineRule({
 });
 //#endregion
 //#region src/rules/differential-test-requires-harness.config.ts
-const meta$22 = {
+const HARNESS_PRESCRIPTION = "import { Differential, Metamorphic } from @systemfsoftware/differential-spec and express the test as Differential.compare({ name, reference, candidate }).on(arb).assert(oracle) or Metamorphic.on({ name, system }).relation({ transformInput, assertOutput }).on(arb)";
+const RAW_FAST_CHECK_EXPECTED$1 = "the harness owns fast-check — pass an fc.Arbitrary to the harness, never call fc.assert/fc.check directly";
+const RAW_FAST_CHECK_ACTUAL$1 = "bypasses the differential harness oracle";
+const RAW_FAST_CHECK_FIX$1 = "build the arbitrary in tests/__fixtures__ and hand it to Differential.compare(...).on(arb) or Metamorphic.on(...).relation(...).on(arb)";
+const meta$23 = {
 	type: "problem",
-	docs: { description: "Differential tests must use @systemfsoftware/differential-spec harness. Raw runner calls (it, test, describe, and member forms like it.effect) and direct runner imports are forbidden in *.differential.test.ts files; importing the harness without invoking it is equally non-compliant." },
+	docs: { description: "A test that imports @systemfsoftware/differential-spec (the differential lane) runs through that harness: raw fc.assert/fc.check/fc.property/fc.asyncProperty calls are forbidden in it, and importing the harness without invoking it is non-compliant. Runner imports and calls in this lane are vitest-from-systemfsoftware-vitest findings." },
 	schema: [],
 	messages: {
-		rawRunnerCall: "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
-		runnerImport: "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
-		missingHarnessImport: "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
-		missingHarnessUsage: "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}."
+		rawFastCheck: MESSAGE$6,
+		missingHarnessUsage: MESSAGE$6
 	}
 };
 //#endregion
 //#region src/rules/differential-test-requires-harness.ts
-const HARNESS_PRESCRIPTION$1 = "import { Differential, Metamorphic } from @systemfsoftware/differential-spec and express the test as Differential.compare({ name, reference, candidate }).on(arb).assert(oracle) or Metamorphic.on({ name, system }).relation({ transformInput, assertOutput }).on(arb)";
-const memberObjectName = (callee) => callee.type === "MemberExpression" && callee.object.type === "Identifier" ? callee.object.name : void 0;
-const calleeName = (callee) => callee.type === "Identifier" ? callee.name : memberObjectName(callee);
+const memberObjectName$1 = (callee) => callee.type === "MemberExpression" && callee.object.type === "Identifier" ? callee.object.name : void 0;
+const calleeName$1 = (callee) => callee.type === "Identifier" ? callee.name : memberObjectName$1(callee);
 const recordHarnessBindings = (node, bindings) => {
-	if (node.source.value !== "@systemfsoftware/differential-spec") return;
+	if (harnessLaneOf(node.source.value) !== "differential") return;
 	for (const specifier of node.specifiers) bindings.add(specifier.local.name);
 };
-const isForeignRunnerImport = (node) => typeof node.source.value === "string" && FOREIGN_RUNNERS[node.source.value] === true;
+/** The fast-check runner a raw `fc.assert(...)` style call names, if any. */
+const rawFastCheckMethod = (callee) => callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "fc" && callee.property.type === "Identifier" && RAW_FC_METHODS[callee.property.name] === true ? callee.property.name : void 0;
 const differentialTestRequiresHarness = defineRule({
-	meta: meta$22,
+	meta: meta$23,
 	create(context) {
-		if (!context.filename.endsWith(".differential.test.ts")) return {};
 		const harnessBindings = /* @__PURE__ */ new Set();
-		let violations = 0;
+		let differential = false;
 		let hasHarnessInvocation = false;
 		return {
+			Program() {
+				differential = lanesOf(context).has("differential");
+			},
 			ImportDeclaration(node) {
-				if (isForeignRunnerImport(node)) {
-					context.report({
-						node,
-						messageId: "runnerImport",
-						data: {
-							name: `runner import from ${String(node.source.value)} in a differential test file`,
-							expected: HARNESS_PRESCRIPTION$1,
-							actual: "a direct vitest / @effect/vitest / @systemfsoftware/vitest runner import bypasses the differential oracle",
-							fix: `delete the runner import; ${HARNESS_PRESCRIPTION$1}`
-						}
-					});
-					violations += 1;
-					return;
-				}
-				recordHarnessBindings(node, harnessBindings);
+				if (differential) recordHarnessBindings(node, harnessBindings);
 			},
 			CallExpression(node) {
-				const name = calleeName(node.callee);
-				if (name !== void 0 && RUNNER_NAMES.has(name)) {
+				if (!differential) return;
+				const method = rawFastCheckMethod(node.callee);
+				if (method !== void 0) {
 					context.report({
 						node,
-						messageId: "rawRunnerCall",
+						messageId: "rawFastCheck",
 						data: {
-							name: `raw runner call (${name}) in a differential test file`,
-							expected: HARNESS_PRESCRIPTION$1,
-							actual: `${name}(...) bypasses the differential oracle`,
-							fix: `rewrite using ${HARNESS_PRESCRIPTION$1}`
+							name: `raw fc.${method}(...) in a differential test file`,
+							expected: RAW_FAST_CHECK_EXPECTED$1,
+							actual: `fc.${method}(...) ${RAW_FAST_CHECK_ACTUAL$1}`,
+							fix: RAW_FAST_CHECK_FIX$1
 						}
 					});
-					violations += 1;
 					return;
 				}
+				const name = calleeName$1(node.callee);
 				if (name !== void 0 && harnessBindings.has(name)) hasHarnessInvocation = true;
 			},
 			"Program:exit"(node) {
-				if (harnessBindings.size === 0) {
-					context.report({
-						node,
-						messageId: "missingHarnessImport",
-						data: {
-							name: `differential test file without ${DIFFERENTIAL_PACKAGE} import`,
-							expected: HARNESS_PRESCRIPTION$1,
-							actual: "no differential harness import found",
-							fix: HARNESS_PRESCRIPTION$1
-						}
-					});
-					return;
-				}
-				if (!hasHarnessInvocation && violations === 0) context.report({
+				if (differential && !hasHarnessInvocation) context.report({
 					node,
 					messageId: "missingHarnessUsage",
 					data: {
 						name: `differential test file imports ${DIFFERENTIAL_PACKAGE} but never invokes it`,
-						expected: HARNESS_PRESCRIPTION$1,
+						expected: HARNESS_PRESCRIPTION,
 						actual: "the harness is imported but no Differential.compare or Metamorphic.on chain runs",
-						fix: HARNESS_PRESCRIPTION$1
+						fix: HARNESS_PRESCRIPTION
 					}
 				});
 			}
@@ -805,16 +831,64 @@ const differentialTestRequiresHarness = defineRule({
 	}
 });
 //#endregion
+//#region src/rules/e2e-tier-placement.config.ts
+const OUTSIDE_PACKAGE_EXPECTED = "end-to-end tests only in a package that declares the e2e role in its lint settings";
+const OUTSIDE_PACKAGE_ACTUAL = "a test registered with the effect-e2e runner in a package that declares no e2e role";
+const OUTSIDE_PACKAGE_FIX = "move the suite into an end-to-end package; if this package is one, declare the e2e role under the plugin key in its lint config settings";
+const INTEGRATION_IN_PACKAGE_EXPECTED = "only end-to-end tests in a package that declares the e2e role";
+const INTEGRATION_IN_PACKAGE_ACTUAL = "an integration test (Gherkin harness) in an end-to-end package";
+const INTEGRATION_IN_PACKAGE_FIX = "move the integration test into the package it covers, or write it with the runner test so it is an end-to-end test";
+//#endregion
+//#region src/rules/e2e-tier-placement.ts
+const e2eTierPlacement = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Reports an end-to-end test (a test file that value-imports `test`, or the namespace, from `@systemfsoftware/effect-e2e/runner`, whatever its name or location) in a package whose lint settings do not declare the `e2e` role; in a package that declares it, reports an integration test (a file importing the Gherkin harness and not in the e2e lane). The role is declared once in the package's own lint config settings under the plugin's key, and no rule takes a role option." },
+		schema: [],
+		messages: {
+			e2eOutsideE2ePackage: MESSAGE$6,
+			integrationInE2ePackage: MESSAGE$6
+		}
+	},
+	create(context) {
+		return { Program(node) {
+			const lanes = lanesOf(context);
+			const name = basenameOf(context.filename);
+			const e2ePackage = isE2ePackage(context);
+			if (lanes.has("e2e") && !e2ePackage) context.report({
+				node,
+				messageId: "e2eOutsideE2ePackage",
+				data: {
+					name,
+					expected: OUTSIDE_PACKAGE_EXPECTED,
+					actual: OUTSIDE_PACKAGE_ACTUAL,
+					fix: OUTSIDE_PACKAGE_FIX
+				}
+			});
+			if (lanes.has("behaviour") && !lanes.has("e2e") && e2ePackage) context.report({
+				node,
+				messageId: "integrationInE2ePackage",
+				data: {
+					name,
+					expected: INTEGRATION_IN_PACKAGE_EXPECTED,
+					actual: INTEGRATION_IN_PACKAGE_ACTUAL,
+					fix: INTEGRATION_IN_PACKAGE_FIX
+				}
+			});
+		} };
+	}
+});
+//#endregion
 //#region src/rules/in-source-test-prop-only.config.ts
 const NON_PROP_CALL_NAME = "a non-property test call inside an `import.meta.vitest` block";
 const NON_PROP_CALL_EXPECTED = "only `it.prop` or `it.effect.prop` member-chain calls (standard modifiers included) with boolean predicates";
 const NON_PROP_CALL_ACTUAL = "a bare or member-chain test call other than `it.prop`/`it.effect.prop`";
-const NON_PROP_CALL_FIX = "delete the block — non-property in-source tests belong nowhere in `src/`; re-home a meaningful example through the cell public export as `*.integration.test.ts`, or rewrite a real invariant as `it.prop` over a schema-derived arbitrary";
+const NON_PROP_CALL_FIX = "delete the block — non-property in-source tests belong nowhere in `src/`; re-home a meaningful example through the cell public export as a Gherkin behaviour test under tests/, or rewrite a real invariant as `it.prop` over a schema-derived arbitrary";
 const meta$21 = {
 	type: "problem",
 	docs: { description: "In-source `if (import.meta.vitest)` blocks under src/ must contain only `it.prop` or `it.effect.prop` calls; every other test call fails — delete the block or rewrite the invariant as a property." },
 	schema: [],
-	messages: { nonPropCall: MESSAGE$8 }
+	messages: { nonPropCall: MESSAGE$6 }
 };
 //#endregion
 //#region src/rules/vitest-guard.ts
@@ -841,19 +915,19 @@ const isInsideConsequent = (node, consequent) => {
 };
 //#endregion
 //#region src/rules/in-source-test-prop-only.ts
-const PROP_MODIFIERS$1 = /* @__PURE__ */ new Set([
+const PROP_MODIFIERS = /* @__PURE__ */ new Set([
 	"only",
 	"skip",
 	"todo"
 ]);
-const isPropCallee$1 = (callee) => {
+const isPropCallee = (callee) => {
 	if (callee.type !== "MemberExpression" || callee.property.type !== "Identifier") return false;
 	if (callee.property.name === "prop") {
 		const object = callee.object;
 		if (object.type === "Identifier") return object.name === "it";
 		return object.type === "MemberExpression" && object.property.type === "Identifier" && object.property.name === "effect" && object.object.type === "Identifier" && object.object.name === "it";
 	}
-	return PROP_MODIFIERS$1.has(callee.property.name) && isPropCallee$1(callee.object);
+	return PROP_MODIFIERS.has(callee.property.name) && isPropCallee(callee.object);
 };
 const BANNED_TEST_ROOTS = /* @__PURE__ */ new Set([
 	"it",
@@ -888,7 +962,7 @@ const inSourceTestPropOnly = defineRule({
 			},
 			CallExpression(node) {
 				if (guards.length === 0) return;
-				if (isPropCallee$1(node.callee)) return;
+				if (isPropCallee(node.callee)) return;
 				const root = rootNameOf(node.callee);
 				if (root === void 0 || !BANNED_TEST_ROOTS.has(root)) return;
 				if (guards.find((g) => isInsideConsequent(node, g.consequent)) === void 0) return;
@@ -918,14 +992,14 @@ const NOT_MODULE_LEVEL_FIX = "move the block to module level — a nested block
 const NO_PRIVATE_TARGET_NAME = "an `import.meta.vitest` block touching no module-level binding";
 const NO_PRIVATE_TARGET_EXPECTED = "an in-source test exercising this module's own code — a private helper, or an exported operation named in the `it.prop` `subject` slot";
 const NO_PRIVATE_TARGET_ACTUAL = "an in-source block referencing only exported-call or imported names";
-const NO_PRIVATE_TARGET_FIX = "touch this module. A private helper is referenced directly; an exported operation is named in the `it.prop` `subject` slot beside its declaration — that is the one home for its laws and the file whose mutants they run. What the block cannot hold is a behaviour binding no module-level name: test the public surface from tests/ as *.integration.test.ts instead";
+const NO_PRIVATE_TARGET_FIX = "touch this module. A private helper is referenced directly; an exported operation is named in the `it.prop` `subject` slot beside its declaration — that is the one home for its laws and the file whose mutants they run. What the block cannot hold is a behaviour binding no module-level name: test the public surface from tests/ as a Gherkin behaviour test instead";
 const meta$20 = {
 	type: "problem",
-	docs: { description: "In-source `if (import.meta.vitest)` blocks under src/ must be at module level and exercise this module's own code — a private helper, or an exported operation named in the `it.prop` `subject` slot; a public-surface test belongs in tests/ as an integration test." },
+	docs: { description: "In-source `if (import.meta.vitest)` blocks under src/ must be at module level and exercise this module's own code — a private helper, or an exported operation named in the `it.prop` `subject` slot; a public-surface test belongs in tests/ as a Gherkin behaviour test." },
 	schema: [],
 	messages: {
-		notModuleLevel: MESSAGE$8,
-		noPrivateTarget: MESSAGE$8
+		notModuleLevel: MESSAGE$6,
+		noPrivateTarget: MESSAGE$6
 	}
 };
 //#endregion
@@ -1041,8 +1115,8 @@ const meta$19 = {
 	docs: { description: "A *.model.ts fixture is the pure model a conformance check stands the implementation against, so it may not import the package whose tests it serves. The package is derived from the path: the directory the tests tree lives in. An import, re-export, dynamic import, or require of that package name — or of any subpath of it — is the implementation reaching its own oracle. A relative specifier is judged the same way lexically: resolved against the fixture directory, it must stay inside the tests tree, so ../../src/Lock.js is the implementation again while ./Locks.js is a sibling fixture." },
 	schema: [],
 	messages: {
-		subjectImport: MESSAGE$8,
-		relativeEscape: MESSAGE$8
+		subjectImport: MESSAGE$6,
+		relativeEscape: MESSAGE$6
 	}
 };
 //#endregion
@@ -1146,42 +1220,25 @@ const modelFixtureImportsSubject = defineRule({
 });
 //#endregion
 //#region src/rules/no-assert-in-property.config.ts
-const MESSAGE$7 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const MESSAGE$5 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 const meta$18 = {
 	type: "problem",
 	docs: { description: "Property predicates (it.prop / it.effect.prop) must never call expect(...), assert*(...), or raw fc.assert/fc.check. The boolean return IS the verdict — assertions fork the failure channel. assert* remains correct in normal (non-property) tests." },
 	schema: [],
 	messages: {
-		expectCall: MESSAGE$7,
-		assertCall: MESSAGE$7,
-		rawFcRun: MESSAGE$7
+		expectCall: MESSAGE$5,
+		assertCall: MESSAGE$5,
+		rawFcRun: MESSAGE$5
 	}
 };
 //#endregion
-//#region src/rules/prop-call.ts
-const PROP_MODIFIERS = /* @__PURE__ */ new Set([
-	"only",
-	"skip",
-	"todo"
-]);
-const isPropCallee = (callee) => {
-	if (callee.type !== "MemberExpression" || callee.property.type !== "Identifier") return false;
-	if (callee.property.name === "prop") {
-		const object = callee.object;
-		if (object.type === "Identifier") return object.name === "it";
-		return object.type === "MemberExpression" && object.property.type === "Identifier" && object.property.name === "effect" && object.object.type === "Identifier" && object.object.name === "it";
-	}
-	return PROP_MODIFIERS.has(callee.property.name) && isPropCallee(callee.object);
-};
-const getPredicate = (node) => Array$1.findLast(node.arguments, (arg) => arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression");
-//#endregion
 //#region src/rules/no-assert-in-property.ts
 const ASSERT_IDENTIFIER = /^assert/;
 const FC_RUN_METHODS = /* @__PURE__ */ new Set(["assert", "check"]);
 const isInsidePropPredicate = (node) => {
 	const parent = node.parent;
 	if (parent === null) return false;
-	if ((parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") && Option.fromNullishOr(parent.parent).pipe(Option.exists((grandparent) => grandparent.type === "CallExpression" && isPropCallee(grandparent.callee)))) return true;
+	if ((parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") && Option.fromNullishOr(parent.parent).pipe(Option.exists((grandparent) => grandparent.type === "CallExpression" && isPropCallee$1(grandparent.callee)))) return true;
 	return isInsidePropPredicate(parent);
 };
 const noAssertInProperty = defineRule({
@@ -1370,7 +1427,7 @@ const IO_SPECIFIERS = {
 	"node:https": true,
 	"node:dns": true,
 	"effect/FileSystem": true,
-	"effect/unstable/process/ChildProcessSpawner": true,
+	"effect/process/ChildProcessSpawner": true,
 	"@effect/platform/FileSystem": true,
 	"@effect/platform/CommandExecutor": true,
 	"@effect/platform-node": true,
@@ -1444,7 +1501,7 @@ const noIoModuleInSourceTest = defineRule({
 });
 //#endregion
 //#region src/rules/no-nested-quantification.config.ts
-const MESSAGE$6 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const MESSAGE$4 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 const Options$2 = Schema.Struct({ exempt: Schema.Array(Schema.String).pipe(Schema.annotate({ description: "File basenames this rule stays silent on. An owner who has measured the cost and accepted it names the file here; the property still runs." }), Schema.withDecodingDefaultType(Effect.succeed([]))) });
 const ITERATOR_METHODS = /* @__PURE__ */ new Set([
 	"every",
@@ -1471,7 +1528,7 @@ const meta$15 = {
 	type: "problem",
 	docs: { description: "A property predicate must not quantify over its own generated value and call out again inside that loop. Per-case cost then scales with the drawn size rather than with the draw count, which is the shape Hypothesis reports as nested_given: the suite slows superlinearly as the generator widens, and a CI budget tuned on small draws times out on large ones. Iteration over a bound the generator does not control, and a fold whose body calls nothing, are both fine." },
 	schema: [Schema.toJsonSchemaDocument(Options$2).schema],
-	messages: { nestedQuantification: MESSAGE$6 }
+	messages: { nestedQuantification: MESSAGE$4 }
 };
 //#endregion
 //#region src/rules/no-nested-quantification.ts
@@ -1631,7 +1688,7 @@ const noNestedQuantification = defineRule({
 		const basename = context.filename.slice(context.filename.lastIndexOf("/") + 1);
 		return { CallExpression(node) {
 			if (exempt.has(basename)) return;
-			if (!isPropCallee(node.callee)) return;
+			if (!isPropCallee$1(node.callee)) return;
 			Option.match(getPredicate(node), {
 				onNone: () => {},
 				onSome: (predicate) => check(context, node, predicate)
@@ -1641,15 +1698,15 @@ const noNestedQuantification = defineRule({
 });
 //#endregion
 //#region src/rules/no-pseudo-gherkin-unit-tests.config.ts
-const NO_LAYER_IN_FEATURE_NAME = "a *.integration.test.ts feature with no environment double";
+const NO_LAYER_IN_FEATURE_NAME = "a behaviour test feature with no environment double";
 const NO_LAYER_IN_FEATURE_EXPECTED = "a Feature builder chained with .withLayer(layer) or .withScenarioLayer(layer)";
 const NO_LAYER_IN_FEATURE_ACTUAL = "a Feature(...) call without .withLayer or .withScenarioLayer";
-const NO_LAYER_IN_FEATURE_FIX = "an integration test under WGI-CLS1 must declare its collaborator environment via .withLayer(...) or .withScenarioLayer(...). Chain .withLayer(Layer.empty) (or .withScenarioLayer(Layer.empty)) if the feature exercises in-memory collaborators without custom services, or provide the external boundary Layer it exercises (e.g. .withLayer(MyService.Live)).";
+const NO_LAYER_IN_FEATURE_FIX = "a behaviour test under WGI-CLS1 must declare its collaborator environment via .withLayer(...) or .withScenarioLayer(...). Chain .withLayer(Layer.empty) (or .withScenarioLayer(Layer.empty)) if the feature exercises in-memory collaborators without custom services, or provide the external boundary Layer it exercises (e.g. .withLayer(MyService.Live)).";
 const meta$14 = {
 	type: "problem",
-	docs: { description: "A *.integration.test.ts Feature builder must configure at least one environment Layer (.withLayer or .withScenarioLayer) to enforce real integration boundaries under WGI-CLS1." },
+	docs: { description: "In a behaviour test - any test file that imports @systemfsoftware/effect-gherkin-spec, whatever its name - every Feature builder must configure at least one environment Layer (.withLayer or .withScenarioLayer) to enforce real integration boundaries under WGI-CLS1." },
 	schema: [],
-	messages: { noLayerInFeature: MESSAGE$8 }
+	messages: { noLayerInFeature: MESSAGE$6 }
 };
 //#endregion
 //#region src/rules/no-pseudo-gherkin-unit-tests.ts
@@ -1681,38 +1738,44 @@ const findRootFeatureCall = (callNode) => {
 const noPseudoGherkinUnitTests = defineRule({
 	meta: meta$14,
 	create(context) {
-		if (!isBehaviourBasename(basenameOf(context.filename))) return {};
-		return { CallExpression(node) {
-			if (node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier") {
-				if (node.callee.property.name === "body") {
-					const rootFeature = findRootFeatureCall(node);
-					if (rootFeature !== null && !hasLayerInChain(node)) context.report({
-						node: rootFeature,
-						messageId: "noLayerInFeature",
-						data: {
-							name: NO_LAYER_IN_FEATURE_NAME,
-							expected: NO_LAYER_IN_FEATURE_EXPECTED,
-							actual: NO_LAYER_IN_FEATURE_ACTUAL,
-							fix: NO_LAYER_IN_FEATURE_FIX
-						}
-					});
+		let behaviour = false;
+		return {
+			Program() {
+				behaviour = lanesOf(context).has("behaviour");
+			},
+			CallExpression(node) {
+				if (!behaviour) return;
+				if (node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier") {
+					if (node.callee.property.name === "body") {
+						const rootFeature = findRootFeatureCall(node);
+						if (rootFeature !== null && !hasLayerInChain(node)) context.report({
+							node: rootFeature,
+							messageId: "noLayerInFeature",
+							data: {
+								name: NO_LAYER_IN_FEATURE_NAME,
+								expected: NO_LAYER_IN_FEATURE_EXPECTED,
+								actual: NO_LAYER_IN_FEATURE_ACTUAL,
+								fix: NO_LAYER_IN_FEATURE_FIX
+							}
+						});
+					}
 				}
 			}
-		} };
+		};
 	}
 });
 //#endregion
 //#region src/rules/no-silent-return.config.ts
-const MESSAGE$5 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const MESSAGE$3 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 const meta$13 = {
 	type: "problem",
 	docs: { description: "Property predicates (it.prop / it.effect.prop from @systemfsoftware/vitest) must return a boolean verdict on every code path. fast-check counts undefined as success, so a bare return, a non-boolean return, or falling off the end of the body is a silent pass. Opaque values (identifiers, member expressions, calls) are trusted to be boolean; literals and operators are checked." },
 	schema: [],
 	messages: {
-		bareReturn: MESSAGE$5,
-		nonBooleanReturn: MESSAGE$5,
-		missingReturn: MESSAGE$5,
-		nonBooleanBody: MESSAGE$5
+		bareReturn: MESSAGE$3,
+		nonBooleanReturn: MESSAGE$3,
+		missingReturn: MESSAGE$3,
+		nonBooleanBody: MESSAGE$3
 	}
 };
 //#endregion
@@ -1855,7 +1918,7 @@ const noSilentReturn = defineRule({
 	meta: meta$13,
 	create(context) {
 		return { CallExpression(node) {
-			if (!isPropCallee(node.callee)) return;
+			if (!isPropCallee$1(node.callee)) return;
 			Option.match(getPredicate(node), {
 				onNone: () => {},
 				onSome: (predicate) => checkFn(context, predicate)
@@ -1871,6 +1934,12 @@ const testFileInSrcDetail = (dir) => ({
 	actual: `a test file under src/ that is neither the schema-laws entry point nor a <stem>.workflow.property.test.ts inside a ${dir} directory`,
 	fix: `pick the arm matching what this file exercises. A workflow law -> rename to <stem>.workflow.property.test.ts inside src/<path>/${dir}/. A kernel/policy/schema property or characterization suite -> convert it to an in-source \`if (import.meta.vitest)\` block in the module it covers. The package public surface -> move outside src/ to tests/<name>.integration.test.ts. No arm matches -> delete this file`
 });
+/** A file with the sanctioned name and place whose content selects no property lane. */
+const notAPropertyDetail = (dir) => ({
+	expected: testFileInSrcDetail(dir).expected,
+	actual: `a <stem>.workflow.property.test.ts inside a ${dir} directory whose content is not a property test (no FastCheck import and no it.prop / it.effect.prop call, or a differential harness import)`,
+	fix: `state each workflow law as it.prop(...) / it.effect.prop(...) over FastCheck arbitraries. A scenario or differential suite -> move it outside src/ to tests/, named for the lane its imports select`
+});
 const propertyTestLocationDetail = (dir) => ({
 	expected: `src/**/${dir}/<stem>.workflow.property.test.ts — a property test one directory down from the workflow it covers, never beside it`,
 	actual: `a property test under src/ that is not a single-segment <stem>.workflow.property.test.ts inside a ${dir} directory`,
@@ -1883,12 +1952,12 @@ const SCHEMA_TEST_DETAIL = {
 };
 const meta$12 = {
 	type: "problem",
-	docs: { description: "Under src/, the only sanctioned test file is a single-segment <stem>.workflow.property.test.ts inside a sanctioned test directory, plus the generated schema-laws.test.ts entry point. Every other test file is banned: a kernel, policy, or schema suite becomes an in-source import.meta.vitest block, and a public-surface test moves outside src/ as an integration test. The sanctioned directory list is the sanctionedDirs option, defaulting to the one directory this repo runs." },
+	docs: { description: "Under src/, the only sanctioned test file is a single-segment <stem>.workflow.property.test.ts inside a sanctioned test directory whose content is a property test (it imports FastCheck or calls it.prop / it.effect.prop), plus the generated schema-laws.test.ts entry point. Every other test file is banned: a kernel, policy, or schema suite becomes an in-source import.meta.vitest block, and a public-surface test moves outside src/ as a Gherkin behaviour test. The sanctioned directory list is the sanctionedDirs option, defaulting to the one directory this repo runs." },
 	schema: [Schema.toJsonSchemaDocument(Options$1).schema],
 	messages: {
-		testFileInSrc: MESSAGE$8,
-		schemaTestInSrc: MESSAGE$8,
-		propertyTestOutsideTestsDir: MESSAGE$8
+		testFileInSrc: MESSAGE$6,
+		schemaTestInSrc: MESSAGE$6,
+		propertyTestOutsideTestsDir: MESSAGE$6
 	}
 };
 //#endregion
@@ -1905,9 +1974,10 @@ const noTestFileInSrc = defineRule({
 		const isPropertyTest = basename.endsWith(PROPERTY_SUFFIX);
 		const isSchemaTest = basename.endsWith(SCHEMA_SUFFIX);
 		const colocated = isInConfiguredTestDir(context.filename, sanctionedDirs);
-		if (!isSchemaTest && WORKFLOW_TEST_BASENAME.test(basename) && colocated) return {};
-		const [messageId, detail] = violationOf(basename, isPropertyTest, sanctionedDirs[0]);
+		const sanctionedName = !isSchemaTest && WORKFLOW_TEST_BASENAME.test(basename) && colocated;
+		const [messageId, detail] = sanctionedName ? ["testFileInSrc", notAPropertyDetail(sanctionedDirs[0])] : violationOf(basename, isPropertyTest, sanctionedDirs[0]);
 		return { Program(node) {
+			if (sanctionedName && isPropertyFile(lanesOf(context))) return;
 			context.report({
 				node,
 				messageId,
@@ -2085,7 +2155,7 @@ const pbtNaming = defineRule({
 });
 //#endregion
 //#region src/rules/prop-arbitrary-schema-origin.config.ts
-const MESSAGE$4 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const MESSAGE$2 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 const VIOLATION_NAME$2 = "a hand-built fast-check arbitrary with no schema underneath";
 const EXPECTED$1 = "every in-source it.prop arbitrary derives from an Effect Schema — a schema reference, a schema-attached arbitrary annotation, or a pipe/map/oneof chain rooted in one; an input with no schema grows one first";
 const ACTUAL$1 = "the arbitrary is assembled from fast-check constructors alone, so the generator can emit shapes the schema never declared and the suite stays green while exercising almost nothing";
@@ -2106,8 +2176,8 @@ const meta$10 = {
 	docs: { description: "Inside an import.meta.vitest in-source block, every it.prop / it.effect.prop arbitrary must derive from an Effect Schema — a schema reference, a schema-attached arbitrary annotation, or a chain rooted in one. A hand-built fast-check construction with no schema underneath reports; statically opaque arbitraries (unresolved or foreign bindings) fail open into the runtime domain audit." },
 	schema: [],
 	messages: {
-		handBuiltArbitrary: MESSAGE$4,
-		stockDerivedArbitrary: MESSAGE$4
+		handBuiltArbitrary: MESSAGE$2,
+		stockDerivedArbitrary: MESSAGE$2
 	}
 };
 //#endregion
@@ -2188,7 +2258,7 @@ const dynamicEdgeOf = (declarator, init, name) => {
 };
 const vocabularyOf = (edge) => {
 	if (SCHEMA_SOURCE_PATTERN.test(edge.source)) return "schema";
-	if (edge.source.startsWith("effect/unstable/arbitrary")) return "schema";
+	if (edge.source === "effect/Arbitrary") return "schema";
 	if (edge.source === "effect" && edge.imported !== null) {
 		if (SCHEMA_NAMESPACE_NAMES[edge.imported] === true) return "schema";
 		if (FASTCHECK_NAMESPACE_NAMES[edge.imported] === true) return "handBuilt";
@@ -2220,7 +2290,7 @@ var Provenance = class {
 		if (resolveLocal$1(name, node, this.getScope).kind !== "import") return false;
 		const edge = this.imports.get(name);
 		if (edge === void 0) return false;
-		if (edge.source.startsWith("effect/unstable/arbitrary")) return true;
+		if (edge.source === "effect/Arbitrary") return true;
 		return edge.source === "effect" && edge.imported === "Arbitrary";
 	}
 	classifyCall(name, node) {
@@ -2417,7 +2487,7 @@ const propArbitrarySchemaOrigin = defineRule({
 			}
 			if (!isNode$2(value)) return;
 			if (value.type === "IfStatement" && mentionsImportMetaVitest$2(value.test)) return;
-			if (value.type === "CallExpression" && isPropCallee(value.callee)) out.push(value);
+			if (value.type === "CallExpression" && isPropCallee$1(value.callee)) out.push(value);
 			for (const [key, child] of Object.entries(value)) {
 				if (key === "parent") continue;
 				collect(child, out);
@@ -2466,7 +2536,7 @@ const propArbitrarySchemaOrigin = defineRule({
 });
 //#endregion
 //#region src/rules/prop-fixture-schema-origin.config.ts
-const MESSAGE$3 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const MESSAGE$1 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 const VIOLATION_NAME$1 = "a hand-rolled recursive schema fixture inside a test block";
 const EXPECTED = "a recursive fixture schema enters the block through a named local builder call, or its recursion point declares its generation with a visible toCodecArbitrary derivation or a recursionBudget ceiling";
 const ACTUAL = "the union and its recursion cycle are assembled inline, so the suite exercises a surrogate universe the shipped schema contract never declared and no budget gate grades";
@@ -2475,7 +2545,7 @@ const meta$9 = {
 	type: "problem",
 	docs: { description: "Inside an import.meta.vitest in-source block or a *.test.ts file, a recursive schema union must enter through a named local builder or an imported helper, or its recursion point must declare its generation with a visible toCodecArbitrary derivation or recursionBudget ceiling. An inline hand-rolled recursive union reports; outside test scope the rule is silent, because production schemas are the derivation-cost rule domain." },
 	schema: [],
-	messages: { handRolledRecursiveFixture: MESSAGE$3 }
+	messages: { handRolledRecursiveFixture: MESSAGE$1 }
 };
 //#endregion
 //#region src/rules/prop-fixture-schema-origin.ts
@@ -2677,7 +2747,7 @@ const propFixtureSchemaOrigin = defineRule({
 });
 //#endregion
 //#region src/rules/prop-generated-law-duplicate.config.ts
-const MESSAGE$2 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const MESSAGE = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 const COMPILER_NAME = "a runtime probe of a compile-time guarantee";
 const COMPILER_EXPECTED = "the type checker owns brand and nominal-identity contracts — a dropped brand is a compile error at the consumer brand gate, not a failing property";
 const COMPILER_ACTUAL = "the predicate reflects over brand symbols at runtime, so it re-asserts what tsc already enforces and passes whenever the type system passes";
@@ -2691,8 +2761,8 @@ const meta$8 = {
 	docs: { description: "Inside an import.meta.vitest in-source block: a predicate that reflects over brand symbols re-asserts a compile-time guarantee, and a predicate containing no module-local non-codec function call tests a schema declaration instead of code. Both report." },
 	schema: [],
 	messages: {
-		compilerDuplicate: MESSAGE$2,
-		noDomainFunction: MESSAGE$2
+		compilerDuplicate: MESSAGE,
+		noDomainFunction: MESSAGE
 	}
 };
 //#endregion
@@ -2851,7 +2921,7 @@ const propGeneratedLawDuplicate = defineRule({
 				return;
 			}
 			if (!isNode(value)) return;
-			if (value.type === "CallExpression" && isPropCallee(value.callee)) out.push(value);
+			if (value.type === "CallExpression" && isPropCallee$1(value.callee)) out.push(value);
 			for (const [key, child] of Object.entries(value)) {
 				if (key === "parent") continue;
 				collect(child, out);
@@ -2884,129 +2954,110 @@ const propGeneratedLawDuplicate = defineRule({
 });
 //#endregion
 //#region src/rules/property-file-purity.config.ts
-const PROPERTY_TEST_SUFFIX = ".property.test.ts";
-const MESSAGE$1 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const PLAIN_EXPECTED = "it.prop(...) or it.effect.prop(...) — property files never mix with scenario tests";
+const PLAIN_FIX = "move the scenario test to a test file that imports no FastCheck and calls no it.prop, or rewrite it as a property with arbitraries and a boolean-returning predicate";
+const RAW_FAST_CHECK_EXPECTED = "it.prop(...) or it.effect.prop(...) from @systemfsoftware/vitest";
+const RAW_FAST_CHECK_ACTUAL = "bypasses the vitest/Effect integration";
+const RAW_FAST_CHECK_FIX = "rewrite as it.prop(name, { of, subject, runs }, holds) returning a boolean; fc.* stays for building arbitraries (fc.pre, fc.stringMatching, ...)";
+const PROPERTY_HOME = "a property test in src/<dir>/__tests__/<stem>.workflow.property.test.ts, apart from any harness test";
+const MIXED_FIX = "move the property beside the workflow it covers in its own <stem>.workflow.property.test.ts; this file keeps the harness scenarios only";
+const MIXED_FAST_CHECK_IMPORT_DATA = {
+	name: "a FastCheck import in a Gherkin, conformance or trace test",
+	expected: PROPERTY_HOME,
+	actual: "a test that imports a Gherkin, conformance or trace harness also imports FastCheck",
+	fix: MIXED_FIX
+};
+const MIXED_PROP_CALL_DATA = {
+	name: "a property test in a Gherkin, conformance or trace test",
+	expected: PROPERTY_HOME,
+	actual: "a test that imports a Gherkin, conformance or trace harness also calls it.prop / it.effect.prop",
+	fix: MIXED_FIX
+};
 const meta$7 = {
 	type: "problem",
-	docs: { description: "Property tests live ONLY in *.property.test.ts files, and those files contain ONLY property tests. In a property file: no plain it()/test()/it.effect(), no raw fc.assert/fc.check/fc.property/fc.asyncProperty. In any other test file: no FastCheck import and no it.prop/it.effect.prop — move the property to a *.property.test.ts file." },
+	docs: { description: "A test that imports FastCheck or calls it.prop / it.effect.prop is a property test file, and it holds only property tests: no plain it()/test()/it.effect(), no raw fc.assert/fc.check/fc.property/fc.asyncProperty. A test that also imports the Gherkin, conformance or trace harness is reported for each FastCheck import and each it.prop / it.effect.prop call: property tests never mix with harness scenarios. A test that imports @systemfsoftware/differential-spec is held to the differential harness rule instead." },
 	schema: [],
 	messages: {
-		plainIt: MESSAGE$1,
-		plainEffectIt: MESSAGE$1,
-		rawFastCheck: MESSAGE$1,
-		fastCheckImport: MESSAGE$1,
-		propCall: MESSAGE$1
+		plainIt: MESSAGE$6,
+		plainEffectIt: MESSAGE$6,
+		rawFastCheck: MESSAGE$6,
+		fastCheckImport: MESSAGE$6,
+		propCall: MESSAGE$6
 	}
 };
 //#endregion
 //#region src/rules/property-file-purity.ts
-const RAW_FC_METHODS = /* @__PURE__ */ new Set([
-	"assert",
-	"check",
-	"property",
-	"asyncProperty"
-]);
-const PROPERTY_FILE_KIND = {
-	suffix: PROPERTY_TEST_SUFFIX,
-	plainExpected: "it.prop(...) or it.effect.prop(...) — property files never mix with scenario tests",
-	plainFix: "move the scenario test to a plain *.test.ts file, or rewrite it as a property with arbitraries and a boolean-returning predicate",
-	rawFcExpected: "it.prop(...) or it.effect.prop(...) from @systemfsoftware/vitest",
-	rawFcActualSuffix: "bypasses the vitest/Effect integration",
-	rawFcFix: "rewrite as it.prop(name, { of, subject, runs }, holds) returning a boolean; fc.* stays for building arbitraries (fc.pre, fc.stringMatching, ...)"
-};
-const DIFFERENTIAL_FILE_KIND = {
-	suffix: DIFFERENTIAL_SUFFIX,
-	plainExpected: "the differential harness — Differential.compare(...).on(arb).assert(oracle) or Metamorphic.on(system).relation(...).on(arb)",
-	plainFix: "rewrite via @systemfsoftware/differential-spec; scenario tests do not belong in a differential file",
-	rawFcExpected: "the harness owns fast-check — pass an fc.Arbitrary to the harness, never call fc.assert/fc.check directly",
-	rawFcActualSuffix: "bypasses the differential harness oracle",
-	rawFcFix: "build the arbitrary in tests/__fixtures__ and hand it to Differential.compare(...).on(arb) or Metamorphic.on(...).relation(...).on(arb)"
-};
-const reportPlain = (context, node, messageId, actual, kind) => {
+const reportPlain = (context, node, messageId, actual) => {
 	context.report({
 		node,
 		messageId,
 		data: {
-			name: `scenario test (${actual}) in a ${kind.suffix} file`,
-			expected: kind.plainExpected,
+			name: `scenario test (${actual}) in a property test file`,
+			expected: PLAIN_EXPECTED,
 			actual: `${actual} runs a single example, not a property`,
-			fix: kind.plainFix
+			fix: PLAIN_FIX
 		}
 	});
 };
-const reportRawFc = (context, node, method, kind) => {
+const reportRawFc = (context, node, method) => {
 	context.report({
 		node,
 		messageId: "rawFastCheck",
 		data: {
-			name: `raw fc.${method}(...) in a ${kind.suffix} file`,
-			expected: kind.rawFcExpected,
-			actual: `fc.${method}(...) ${kind.rawFcActualSuffix}`,
-			fix: kind.rawFcFix
+			name: `raw fc.${method}(...) in a property test file`,
+			expected: RAW_FAST_CHECK_EXPECTED,
+			actual: `fc.${method}(...) ${RAW_FAST_CHECK_ACTUAL}`,
+			fix: RAW_FAST_CHECK_FIX
 		}
 	});
 };
-const createPropertyFileVisitors = (context, kind) => ({ CallExpression(node) {
+const checkCall = (context, node) => {
 	const callee = node.callee;
 	if (callee.type === "Identifier") {
-		if (callee.name === "it" || callee.name === "test") reportPlain(context, node, "plainIt", `${callee.name}(...)`, kind);
+		if (callee.name === "it" || callee.name === "test") reportPlain(context, node, "plainIt", `${callee.name}(...)`);
 		return;
 	}
 	if (callee.type !== "MemberExpression" || callee.property.type !== "Identifier") return;
 	const object = callee.object;
-	if (object.type === "Identifier" && object.name === "fc" && RAW_FC_METHODS.has(callee.property.name)) {
-		reportRawFc(context, node, callee.property.name, kind);
+	if (object.type === "Identifier" && object.name === "fc" && RAW_FC_METHODS[callee.property.name] === true) {
+		reportRawFc(context, node, callee.property.name);
 		return;
 	}
 	if (object.type === "Identifier" && object.name === "it") {
-		if (callee.property.name === "effect") reportPlain(context, node, "plainEffectIt", "it.effect(...)", kind);
-		else if (PROP_MODIFIERS.has(callee.property.name)) reportPlain(context, node, "plainIt", `it.${callee.property.name}(...)`, kind);
+		if (callee.property.name === "effect") reportPlain(context, node, "plainEffectIt", "it.effect(...)");
+		else if (PROP_MODIFIERS$1.has(callee.property.name)) reportPlain(context, node, "plainIt", `it.${callee.property.name}(...)`);
 		return;
 	}
-	if (PROP_MODIFIERS.has(callee.property.name) && object.type === "MemberExpression" && object.object.type === "Identifier" && object.object.name === "it" && object.property.type === "Identifier" && object.property.name === "effect") reportPlain(context, node, "plainEffectIt", `it.effect.${callee.property.name}(...)`, kind);
-} });
-const FAST_CHECK_IMPORT_DATA = {
-	name: "FastCheck import in a scenario test file",
-	expected: `property tests (and every FastCheck usage) live in ${PROPERTY_TEST_SUFFIX} files`,
-	actual: `FastCheck imported by a file that is not ${PROPERTY_TEST_SUFFIX}`,
-	fix: "move the property test to a *.property.test.ts file; this file keeps plain it() scenario tests only"
-};
-const reportFastCheckImport = (context, node) => {
-	context.report({
-		node,
-		messageId: "fastCheckImport",
-		data: FAST_CHECK_IMPORT_DATA
-	});
+	if (PROP_MODIFIERS$1.has(callee.property.name) && object.type === "MemberExpression" && object.object.type === "Identifier" && object.object.name === "it" && object.property.type === "Identifier" && object.property.name === "effect") reportPlain(context, node, "plainEffectIt", `it.effect.${callee.property.name}(...)`);
 };
-const createScenarioFileVisitors = (context) => ({
-	ImportDeclaration(node) {
-		if (node.source.value === "fast-check" || node.source.value.startsWith("fast-check/")) {
-			reportFastCheckImport(context, node);
-			return;
-		}
-		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "FastCheck") reportFastCheckImport(context, specifier);
-	},
-	CallExpression(node) {
-		if (!isPropCallee(node.callee)) return;
-		context.report({
-			node,
-			messageId: "propCall",
-			data: {
-				name: "property test in a non-property test file",
-				expected: `it.prop / it.effect.prop calls live in ${PROPERTY_TEST_SUFFIX} files`,
-				actual: "a property test mixed into a test file that is not a property file",
-				fix: "move this test to a *.property.test.ts file — property and non-property tests never mix"
-			}
-		});
-	}
-});
-const kindOf = (filename) => filename.endsWith(".differential.test.ts") ? DIFFERENTIAL_FILE_KIND : PROPERTY_FILE_KIND;
 const propertyFilePurity = defineRule({
 	meta: meta$7,
 	create(context) {
-		if (!isTestFile(basenameOf(context.filename))) return {};
-		if (context.filename.endsWith(".property.test.ts") || context.filename.endsWith(".differential.test.ts")) return createPropertyFileVisitors(context, kindOf(context.filename));
-		return createScenarioFileVisitors(context);
+		let property = false;
+		let mixed = false;
+		return {
+			Program() {
+				const lanes = lanesOf(context);
+				mixed = mixesPropertyIntoAHarness(lanes);
+				property = !mixed && isPropertyFile(lanes);
+			},
+			ImportDeclaration(node) {
+				if (!mixed) return;
+				for (const site of fastCheckImportSites(node)) context.report({
+					node: site,
+					messageId: "fastCheckImport",
+					data: MIXED_FAST_CHECK_IMPORT_DATA
+				});
+			},
+			CallExpression(node) {
+				if (mixed && isPropCallee$1(node.callee)) context.report({
+					node,
+					messageId: "propCall",
+					data: MIXED_PROP_CALL_DATA
+				});
+				else if (property) checkCall(context, node);
+			}
+		};
 	}
 });
 //#endregion
@@ -3023,7 +3074,7 @@ const meta$6 = {
 	docs: { description: "A property test under src/ must be a single-segment <stem>.workflow.property.test.ts beside the <stem>.workflow.ts it covers; every other property-test basename is unsanctioned. A source file whose suffix names a cell listed in the cellsRequiringTest option must additionally carry an in-source vitest block; that list is empty by default, so the presence arm is opt-in per consumer." },
 	schema: [Schema.toJsonSchemaDocument(Options).schema],
 	messages: {
-		unsanctionedCell: MESSAGE$8,
+		unsanctionedCell: MESSAGE$6,
 		missingCellTest: ABSENCE_MESSAGE
 	}
 };
@@ -3084,7 +3135,7 @@ const testFileOutsideTestsDir = defineRule({
 		type: "problem",
 		docs: { description: "Test files outside src/ must live under a tests/ directory; free-standing test files have no sanctioned home." },
 		schema: [],
-		messages: { strayTestFile: MESSAGE$8 }
+		messages: { strayTestFile: MESSAGE$6 }
 	},
 	create(context) {
 		if (isUnderSrc(context.filename)) return {};
@@ -3106,34 +3157,112 @@ const testFileOutsideTestsDir = defineRule({
 });
 //#endregion
 //#region src/rules/test-suffix-outside-src.config.ts
-const UNSANCTIONED_SUFFIX_EXPECTED = "*.integration.test.ts, *.differential.test.ts, *.trace.test.ts, or *.conformance.test.ts";
-const UNSANCTIONED_SUFFIX_ACTUAL = "another test suffix outside src/";
-const UNSANCTIONED_SUFFIX_FIX = "public surface or real medium -> *.integration.test.ts; parity -> *.differential.test.ts; span graph -> *.trace.test.ts; concurrent or stateful behaviour -> *.conformance.test.ts; pure-cell property -> in-source; restated literal -> delete";
+/** The lane word each lane is named by: the dotted segment just before `.test.ts`. */
+const LANE_WORDS = {
+	behaviour: "integration",
+	conformance: "conformance",
+	differential: "differential",
+	trace: "trace",
+	runner: "runner"
+};
+/**
+* The lanes that take precedence over behaviour when a file is in several: its
+* name is a harness's. None outranks another, so a file importing several of
+* these harnesses may take the word of any one of them.
+*/
+const SPECIFIC_LANES = [
+	"conformance",
+	"differential",
+	"trace"
+];
+const suffixOf = (lane) => `.${LANE_WORDS[lane]}.test.ts`;
+/** The name the effect-e2e runner collects: a bare `.e2e.ts` suffix, not a `.<word>.test.ts` lane word. */
+const E2E_SUFFIX = ".e2e.ts";
+const LANE_MISMATCH_ACTUAL = "a lane word that names no lane its imports select";
+const LANE_MISMATCH_FIX = "rename the file for a lane it imports: conformance-spec -> *.conformance.test.ts; differential-spec -> *.differential.test.ts; trace-spec -> *.trace.test.ts (a file importing several of these may take any of their words); effect-gherkin-spec alone -> *.integration.test.ts; a runner module alone, in a vitest-runner package -> *.runner.test.ts; a test registered with the effect-e2e runner -> <subject>.e2e.ts";
+const NO_LANE_EXPECTED = "an import of @systemfsoftware/effect-gherkin-spec, conformance-spec, differential-spec or trace-spec, or of the effect-e2e runner's test";
+const NO_LANE_ACTUAL = "a test outside src/ whose imports select no lane";
+const NO_LANE_FIX = "public surface or real medium -> drive it through makeFeature from @systemfsoftware/effect-gherkin-spec; parity -> differential-spec; span graph -> trace-spec; concurrent or stateful behaviour -> conformance-spec; runner suite -> register tests with test from @systemfsoftware/effect-e2e/runner in a <subject>.e2e.ts file; restated literal -> delete";
+const PROPERTY_OUTSIDE_SRC_EXPECTED = "a property test in src/<dir>/__tests__/<stem>.workflow.property.test.ts beside the workflow it covers";
+const PROPERTY_OUTSIDE_SRC_ACTUAL = "a test outside src/ whose only lane is the property lane";
+const PROPERTY_OUTSIDE_SRC_FIX = "move the property beside the workflow it covers, or drive the behaviour through a harness and name the file for that lane";
+const meta$4 = {
+	type: "problem",
+	docs: { description: "Outside src/, a test file is named for the lanes its imports select: the dotted segment before .test.ts is integration (the Gherkin harness), conformance, differential or trace, and when a file imports a harness besides the Gherkin one it takes that harness's word; a file importing several of the conformance, differential and trace harnesses may take any of their words. In a package whose lint settings declare the vitest-runner role, a test importing a Vitest runner module and no harness is in the runner lane and is named *.runner.test.ts. A file importing the effect-e2e runner's test or its namespace is in the e2e lane and is named <subject>.e2e.ts (the runner's collection, under tests/ outside tests/__fixtures__/); that name outranks every other lane word, and *.e2e.test.ts is not that name. A test whose imports select no lane, or only the property lane, is reported. The name triggers no requirement; the imports do." },
+	schema: [],
+	messages: {
+		laneMismatch: MESSAGE$6,
+		noLane: MESSAGE$6,
+		propertyOutsideSrc: MESSAGE$6
+	}
+};
 //#endregion
 //#region src/rules/test-suffix-outside-src.ts
+/** The lane word: the dotted segment immediately before `.test.ts`; earlier segments name the subject. */
+const LANE_WORD = /\.([^.]+)\.test\.ts$/;
+/**
+* The lanes the file may be named for: every conformance, differential or trace
+* lane it selects (any one of their words will do), else behaviour, else the
+* runner lane a `vitest-runner` package grants.
+*/
+const nameableLanes = (lanes, runner) => {
+	const specific = SPECIFIC_LANES.filter((lane) => lanes.has(lane));
+	if (specific.length > 0) return specific;
+	if (lanes.has("behaviour")) return ["behaviour"];
+	return runner ? ["runner"] : [];
+};
 const testSuffixOutsideSrc = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Outside src/, a test file ends .integration.test.ts, .differential.test.ts, .trace.test.ts, or .conformance.test.ts. A runner-driving package (Vitest itself, the fork, effect-spec-runtime) keeps plain *.test.ts runners and nested-run probes, so the lane taxonomy does not apply there." },
-		schema: [],
-		messages: { unsanctionedSuffix: MESSAGE$8 }
-	},
+	meta: meta$4,
 	create(context) {
 		const filename = context.filename;
-		if (isUnderSrc(filename)) return {};
-		if (isRawVitestPackage(filename)) return {};
 		const basename = basenameOf(filename);
-		if (!isTestFile(basename)) return {};
-		if (isBehaviourBasename(basename) || basename.endsWith(".differential.test.ts") || basename.endsWith(".trace.test.ts") || basename.endsWith(".conformance.test.ts")) return {};
+		if (isUnderSrc(filename) || !(isTestFile(basename) || isE2eTestFile(filename))) return {};
 		return { Program(node) {
+			const lanes = lanesOf(context);
+			if (lanes.has("e2e")) {
+				if (E2E_TEST_BASENAME.test(basename)) return;
+				context.report({
+					node,
+					messageId: "laneMismatch",
+					data: {
+						name: basename,
+						expected: E2E_SUFFIX,
+						actual: LANE_MISMATCH_ACTUAL,
+						fix: LANE_MISMATCH_FIX
+					}
+				});
+				return;
+			}
+			const nameable = nameableLanes(lanes, isInRunnerLane(context));
+			if (nameable.length === 0) {
+				const property = lanes.has("property");
+				context.report({
+					node,
+					messageId: property ? "propertyOutsideSrc" : "noLane",
+					data: property ? {
+						name: basename,
+						expected: PROPERTY_OUTSIDE_SRC_EXPECTED,
+						actual: PROPERTY_OUTSIDE_SRC_ACTUAL,
+						fix: PROPERTY_OUTSIDE_SRC_FIX
+					} : {
+						name: basename,
+						expected: NO_LANE_EXPECTED,
+						actual: NO_LANE_ACTUAL,
+						fix: NO_LANE_FIX
+					}
+				});
+				return;
+			}
+			const word = LANE_WORD.exec(basename)?.[1];
+			if (nameable.some((lane) => LANE_WORDS[lane] === word)) return;
 			context.report({
 				node,
-				messageId: "unsanctionedSuffix",
+				messageId: "laneMismatch",
 				data: {
 					name: basename,
-					expected: UNSANCTIONED_SUFFIX_EXPECTED,
-					actual: UNSANCTIONED_SUFFIX_ACTUAL,
-					fix: UNSANCTIONED_SUFFIX_FIX
+					expected: nameable.map(suffixOf).join(" or "),
+					actual: LANE_MISMATCH_ACTUAL,
+					fix: LANE_MISMATCH_FIX
 				}
 			});
 		} };
@@ -3149,15 +3278,15 @@ const HELPER_FIX = "move it under tests/__fixtures__/ — *.schema.ts if it decl
 const testsDirHelpersInFixtures = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Under tests/, the only non-test modules are helpers and fixtures, and they live inside tests/__fixtures__/." },
+		docs: { description: "Under tests/, the only non-test modules are helpers and fixtures, and they live inside tests/__fixtures__/; the .e2e.ts files the effect-e2e runner collects are tests, not helpers." },
 		schema: [],
-		messages: { helperOutsideFixtures: MESSAGE$8 }
+		messages: { helperOutsideFixtures: MESSAGE$6 }
 	},
 	create(context) {
 		const filename = context.filename;
 		if (isUnderSrc(filename)) return {};
 		const basename = basenameOf(filename);
-		if (isTestFile(basename)) return {};
+		if (isTestFile(basename) || isE2eTestFile(filename)) return {};
 		const dirs = directoriesOf(filename);
 		if (!dirs.includes("tests")) return {};
 		if (dirs.includes("__fixtures__")) return {};
@@ -3184,7 +3313,7 @@ const meta$2 = {
 	type: "problem",
 	docs: { description: "Forbid package-level tests from relative-importing src or climbing into an internal folder" },
 	schema: [],
-	messages: { sourceReachIn: MESSAGE$8 }
+	messages: { sourceReachIn: MESSAGE$6 }
 };
 //#endregion
 //#region src/rules/tests-import-public-api.ts
@@ -3240,8 +3369,6 @@ const testsImportPublicApi = defineRule({
 });
 //#endregion
 //#region src/rules/trace-test-requires-taxonomy.config.ts
-const HARNESS_PRESCRIPTION = "import { Suite, Case, Rel, Graph, Observe, Stimulus } from @systemfsoftware/trace-spec and terminate every case on a relation hold — .holds(Rel.all(Rel.exists(PlaceOrder), Rel.child(PlaceOrder, PaymentCapture)))";
-const MISSING_HARNESS_ACTUAL = "no trace-spec import found in a file named as a trace spec";
 const HTTP_MEMBERS = {
 	body: true,
 	status: true,
@@ -3262,12 +3389,11 @@ const RAW_EMIT_ACTUAL = "a raw span emit call inside a trace spec";
 const RAW_EMIT_FIX = "delete the emit; declare the span with Span.declare in the system under test and assert on the graph the spec receives";
 const meta$1 = {
 	type: "problem",
-	docs: { description: "A *.trace.test.ts must import its harness from @systemfsoftware/trace-spec and terminate cases on relation holds over the declared span graph. Raw emit calls (startSpan, spanBuilder, startActiveSpan) and HTTP status, statusText, or body assertions (expect(res.status).toBe(200), expect(res).toHaveProperty(\"status\", 200), expect(res).resolves.toMatchObject({ status: 200 }), expect(res).toEqual(expect.objectContaining({ status: 200 }))) are forbidden — replacing that altitude is what a trace spec exists for." },
+	docs: { description: "A test that imports @systemfsoftware/trace-spec (the trace lane) terminates its cases on relation holds over the declared span graph. Raw emit calls (startSpan, spanBuilder, startActiveSpan) and HTTP status, statusText, or body assertions (expect(res.status).toBe(200), expect(res).toHaveProperty(\"status\", 200), expect(res).resolves.toMatchObject({ status: 200 }), expect(res).toEqual(expect.objectContaining({ status: 200 }))) are forbidden — replacing that altitude is what a trace spec exists for." },
 	schema: [],
 	messages: {
-		missingHarnessImport: MESSAGE$8,
-		httpTermination: MESSAGE$8,
-		rawEmitCall: MESSAGE$8
+		httpTermination: MESSAGE$6,
+		rawEmitCall: MESSAGE$6
 	}
 };
 //#endregion
@@ -3304,7 +3430,6 @@ const rawEmitName = (node) => {
 	if (name === null || !isEmitCallee(name)) return null;
 	return name;
 };
-const hasHarnessBinding = (node) => node.source.value === "@systemfsoftware/trace-spec" && node.specifiers.length > 0;
 const literalValueOf = (node) => {
 	if (node === void 0 || node.type !== "Literal") return null;
 	return node.value;
@@ -3436,58 +3561,68 @@ const reportHttpTermination = (context, node) => {
 const traceTestRequiresTaxonomy = defineRule({
 	meta: meta$1,
 	create(context) {
-		if (!context.filename.endsWith(".trace.test.ts")) return {};
-		let hasHarnessImport = false;
+		let trace = false;
 		return {
-			ImportDeclaration(node) {
-				if (hasHarnessBinding(node)) hasHarnessImport = true;
+			Program() {
+				trace = lanesOf(context).has("trace");
 			},
 			CallExpression(node) {
+				if (!trace) return;
 				reportRawEmit(context, node);
 				reportHttpTermination(context, node);
-			},
-			"Program:exit"(node) {
-				if (hasHarnessImport) return;
-				context.report({
-					node,
-					messageId: "missingHarnessImport",
-					data: {
-						name: `a *.trace.test.ts without ${TRACE_SPEC_PACKAGE}`,
-						expected: HARNESS_PRESCRIPTION,
-						actual: MISSING_HARNESS_ACTUAL,
-						fix: HARNESS_PRESCRIPTION
-					}
-				});
 			}
 		};
 	}
 });
 //#endregion
 //#region src/rules/vitest-from-systemfsoftware-vitest.config.ts
-const MESSAGE = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 const VIOLATION_NAME = "a value import from a foreign vitest runner";
 const VIOLATION_EXPECTED = "every test value imported from @systemfsoftware/vitest, which re-exports all of Vitest";
 const VIOLATION_ACTUAL = "a named, namespace, default, side-effect or dynamic value import from vitest or @effect/vitest";
 const VIOLATION_FIX = "import it from @systemfsoftware/vitest instead of vitest or @effect/vitest";
+const RUNNER_LANES = [
+	"conformance",
+	"differential",
+	"behaviour"
+];
+/** The lanes in which a plain runner call bypasses the harness. */
+const CALL_LANES = {
+	conformance: true,
+	differential: true,
+	behaviour: false
+};
+const PRESCRIPTIONS = {
+	conformance: HARNESS_PRESCRIPTION$1,
+	differential: HARNESS_PRESCRIPTION,
+	behaviour: "import { it } from @systemfsoftware/effect-gherkin-spec and build the suite with makeFeature({ it, layer })"
+};
 const meta = {
 	type: "problem",
-	docs: { description: "Every value a test uses from Vitest is imported from @systemfsoftware/vitest, which re-exports all of Vitest. Any value import from vitest or the upstream @effect/vitest — named, namespace, default, side-effect or dynamic — is refused; a type-only import stays legal." },
+	docs: { description: "Every value a test uses from Vitest is imported from @systemfsoftware/vitest, which re-exports all of Vitest. Any value import from vitest or the upstream @effect/vitest — named, namespace, default, side-effect or dynamic — is refused; a type-only import stays legal. A package whose config declares { role: \"vitest-runner\" } is the test framework itself, so its raw Vitest imports are its own lane and are not refused; the rule takes the declaration at its word, and a package that declares the role without being the runner is treated the same. In a test that imports the Gherkin, differential or conformance harness, that harness owns the runner: it, test and describe imported from any runner package are refused, and in the differential and conformance lanes so is a plain runner call." },
 	schema: [],
-	messages: { vitestImport: MESSAGE }
+	messages: {
+		vitestImport: MESSAGE$6,
+		runnerImport: MESSAGE$6,
+		rawRunnerCall: MESSAGE$6
+	}
 };
 //#endregion
 //#region src/rules/vitest-from-systemfsoftware-vitest.ts
-const isTypeOnly = (node) => {
-	if (node.importKind === "type") return true;
-	if (node.specifiers.length === 0) return false;
-	return node.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
-};
 const isForeignVitestLiteral = (node) => node.type === "Literal" && typeof node.value === "string" && FOREIGN_VITEST_SOURCES[node.value] === true;
+/** The runner a value import specifier names; a string-literal import name never names one. */
+const runnerNameOf = (specifier) => specifier.type === "ImportSpecifier" && specifier.importKind !== "type" && specifier.imported.type === "Identifier" && RUNNER_NAMES.has(specifier.imported.name) ? specifier.imported.name : void 0;
+/** A value the declaration binds besides a runner: what still makes it a foreign vitest import. */
+const bindsANonRunnerValue = (node) => node.specifiers.length === 0 || node.specifiers.some((specifier) => runnerNameOf(specifier) === void 0 && !(specifier.type === "ImportSpecifier" && specifier.importKind === "type"));
+const memberObjectName = (callee) => callee.type === "MemberExpression" && callee.object.type === "Identifier" ? callee.object.name : void 0;
+const calleeName = (callee) => callee.type === "Identifier" ? callee.name : memberObjectName(callee);
 const vitestFromSystemfsoftwareVitest = defineRule({
 	meta,
 	create(context) {
-		if (isRawVitestPackage(context.filename)) return {};
+		const runnerPackage = isRunnerPackage(context);
+		const importedRunners = /* @__PURE__ */ new Set();
+		let lane;
 		const report = (node) => {
+			if (runnerPackage) return;
 			context.report({
 				node,
 				messageId: "vitestImport",
@@ -3499,12 +3634,56 @@ const vitestFromSystemfsoftwareVitest = defineRule({
 				}
 			});
 		};
+		/**
+		* In a harness lane the harness owns the runner: one finding per runner the
+		* import names, and the lane arm is the only reporter of that runner.
+		*/
+		const reportRunnerImports = (node, harness) => {
+			for (const specifier of node.specifiers) {
+				const runner = runnerNameOf(specifier);
+				if (runner === void 0) continue;
+				importedRunners.add(specifier.local.name);
+				context.report({
+					node: specifier,
+					messageId: "runnerImport",
+					data: {
+						name: `${runner} imported from ${node.source.value} in a ${harness} test`,
+						expected: PRESCRIPTIONS[harness],
+						actual: `a runner imported from a runner package bypasses the ${harness} harness`,
+						fix: `delete the runner import; ${PRESCRIPTIONS[harness]}`
+					}
+				});
+			}
+		};
 		return {
+			Program() {
+				const lanes = lanesOf(context);
+				lane = RUNNER_LANES.find((harness) => lanes.has(harness));
+			},
 			ImportDeclaration(node) {
-				if (FOREIGN_VITEST_SOURCES[node.source.value] !== true) return;
 				if (isTypeOnly(node)) return;
+				const source = node.source.value;
+				const harness = FOREIGN_RUNNERS[source] === true ? lane : void 0;
+				if (harness !== void 0) reportRunnerImports(node, harness);
+				if (FOREIGN_VITEST_SOURCES[source] !== true) return;
+				if (harness !== void 0 && !bindsANonRunnerValue(node)) return;
 				report(node);
 			},
+			CallExpression(node) {
+				if (lane === void 0 || !CALL_LANES[lane]) return;
+				const name = calleeName(node.callee);
+				if (name === void 0 || !RUNNER_NAMES.has(name) || importedRunners.has(name)) return;
+				context.report({
+					node,
+					messageId: "rawRunnerCall",
+					data: {
+						name: `raw runner call (${name}) in a ${lane} test`,
+						expected: PRESCRIPTIONS[lane],
+						actual: `${name}(...) bypasses the ${lane} harness`,
+						fix: `rewrite using ${PRESCRIPTIONS[lane]}`
+					}
+				});
+			},
 			ImportExpression(node) {
 				if (!isForeignVitestLiteral(node.source)) return;
 				report(node);
@@ -3543,6 +3722,7 @@ const recommendedRules = {
 	[rule("src-property-test-cell")]: "error",
 	[rule("test-file-outside-tests-dir")]: "error",
 	[rule("test-suffix-outside-src")]: "error",
+	[rule("e2e-tier-placement")]: "error",
 	[rule("behaviour-test-requires-gherkin")]: "error",
 	[rule("behaviour-exercises-use-case")]: "error",
 	[rule("behaviour-one-feature-per-file")]: "error",
@@ -3576,6 +3756,7 @@ var src_default = {
 		"src-property-test-cell": srcPropertyTestCell,
 		"test-file-outside-tests-dir": testFileOutsideTestsDir,
 		"test-suffix-outside-src": testSuffixOutsideSrc,
+		"e2e-tier-placement": e2eTierPlacement,
 		"behaviour-test-requires-gherkin": behaviourTestRequiresGherkin,
 		"behaviour-exercises-use-case": behaviourExercisesUseCase,
 		"behaviour-one-feature-per-file": behaviourOneFeaturePerFile,