@systemfsoftware/oxlint-plugin-test-discipline 3.6.0 → 3.8.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @systemfsoftware/oxlint-plugin-test-discipline
 
+## 3.8.0
+
+### Minor Changes
+
+- New rule `ban-raw-span-name-emit` at error: a raw span name can no longer enter through an emit API. Calls to `startSpan`, `spanBuilder`, or `startActiveSpan` — bare or as a member call — are flagged when the first argument is a string literal or a template literal, interpolated templates included. The declared-span spelling is untouched: `Span.declare({ id, name, attrs })` and the `start(attrs)` it returns never trigger the rule, and emit calls given a dynamic name are left alone. The recommended preset enables it at error.
+
+- New rule `trace-test-requires-taxonomy` at error: a test file named with the `trace.test` suffix is a trace spec, and a trace spec cannot quietly assert HTTP status. It requires an import binding from `@systemfsoftware/trace-spec`, forbids raw emit calls (`startSpan`, `spanBuilder`, `startActiveSpan`), and forbids terminating a case on an HTTP status or body assertion in these shapes: `expect(res.status)`, `toHaveProperty('status')` (also `statusText`, `body`, dotted paths under them, and segment arrays like `['body', 'items']`), or an object matcher (`toMatchObject`, `toEqual`, `toStrictEqual`, `expect.objectContaining`) whose object literal carries one of those keys at any depth (nested objects and array elements), also through `.resolves`, `.rejects`, and `.not`. `test-suffix-outside-src` now admits the `trace.test` suffix. The recommended preset enables the new rule at error.
+
+## 3.7.0
+
+### Minor Changes
+
+- Enable `no-pseudo-gherkin-unit-tests` in the recommended rule set: every `*.integration.test.ts` Feature builder must declare its collaborator environment with `.withLayer(...)` or `.withScenarioLayer(...)`. The diagnostic now names `Layer.empty` as the remedy for features whose collaborators are in memory.
+
 ## 3.6.0
 
 ### Minor Changes

package/README.md

@@ -9,7 +9,7 @@ Oxlint rules enforcing property-based test laws, test placement, and test naming
 | `no-test-file-in-src`                | 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. |
 | `src-property-test-cell`             | A property test under `src/` must be a single-segment `<stem>.workflow.property.test.ts` beside the `<stem>.workflow.ts` it covers. A source file whose suffix names a cell listed in `cellsRequiringTest` must also carry an in-source vitest block; that list is empty by default.                                                                                                    |
 | `test-file-outside-tests-dir`        | A test file outside `src/` must live under `tests/`.                                                                                                                                                                                                                                                                                                                                    |
-| `test-suffix-outside-src`            | Outside `src/`, a test file must end `.integration.test.ts` or `.differential.test.ts` — the two behaviour suffixes.                                                                                                                                                                                                                                                                    |
+| `test-suffix-outside-src`            | Outside `src/`, a test file must end `.integration.test.ts`, `.differential.test.ts`, or `.trace.test.ts` — the three behaviour suffixes.                                                                                                                                                                                                                                               |
 | `tests-dir-helpers-in-fixtures`      | Under `tests/`, the only non-test modules are helpers and fixtures, and they live inside `tests/__fixtures__/`.                                                                                                                                                                                                                                                                         |
 | `no-io-module-in-source-test`        | An in-source `import.meta.vitest` test block is forbidden in a module that performs I/O — decided from the module's own syntax (a non-type import from a filesystem, process or network module, called at least once), never from its filename. Only the in-source-test idiom is judged: a module whose tests live in separate files is a no-op for this rule.                          |
 | `behaviour-test-requires-gherkin`    | A `.integration.test.ts` must import `makeFeature` from `@systemfsoftware/effect-gherkin-spec` and must not import test runners directly from `vitest` or `@effect/vitest`.                                                                                                                                                                                                             |
@@ -23,6 +23,7 @@ Oxlint rules enforcing property-based test laws, test placement, and test naming
 | `*.workflow.property.test.ts` | Property     | none — pure core         | ONLY under `src/`  |
 | `*.integration.test.ts`       | Behaviour    | permitted, at ports only | NEVER under `src/` |
 | `*.differential.test.ts`      | Differential | permitted, at ports only | NEVER under `src/` |
+| `*.trace.test.ts`             | Trace spec   | none — observes graphs   | NEVER under `src/` |
 
 ## Enrollment
 

package/dist/index.d.ts

@@ -28,6 +28,8 @@ declare const _default: {
     'no-io-module-in-source-test': import("@oxlint/plugins").Rule;
     'tests-import-public-api': import("@oxlint/plugins").Rule;
     'differential-test-requires-harness': import("@oxlint/plugins").Rule;
+    'ban-raw-span-name-emit': import("@oxlint/plugins").Rule;
+    'trace-test-requires-taxonomy': import("@oxlint/plugins").Rule;
   };
   configs: {
     recommended: {

package/dist/index.mjs

@@ -1,5 +1,74 @@
 import { defineRule } from "@oxlint/plugins";
 import { Array as Array$1, Effect, Option, Schema } from "effect";
+//#region src/rules/ban-raw-span-name-emit.config.ts
+const EMIT_CALLEES = [
+	"startActiveSpan",
+	"spanBuilder",
+	"startSpan"
+];
+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$25 = {
+	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: [],
+	messages: { banRawSpanName: "'{{name}}' is forbidden at {{callee}}. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}." }
+};
+//#endregion
+//#region src/rules/ban-raw-span-name-emit.ts
+const INTERPOLATION = "${}";
+const isEmitCallee$1 = (name) => EMIT_CALLEES.some((emit) => emit === name);
+const memberPropertyName = (callee) => {
+	if (callee.computed) return null;
+	if (callee.property.type !== "Identifier") return null;
+	return callee.property.name;
+};
+const calleeName$1 = (callee) => {
+	if (callee.type === "Identifier") return callee.name;
+	if (callee.type === "MemberExpression") return memberPropertyName(callee);
+	return null;
+};
+const templateName = (node) => node.quasis.map((quasi) => quasi.value.raw).join(INTERPOLATION);
+const inlineName = (arg) => {
+	if (arg.type === "Literal") return typeof arg.value === "string" ? arg.value : null;
+	if (arg.type === "TemplateLiteral") return templateName(arg);
+	return null;
+};
+const argName = (arg) => {
+	if (arg === void 0) return null;
+	return inlineName(arg);
+};
+const inspect = (node) => {
+	const callee = calleeName$1(node.callee);
+	if (callee === null || !isEmitCallee$1(callee)) return null;
+	const name = argName(node.arguments[0]);
+	if (name === null) return null;
+	return {
+		callee,
+		name
+	};
+};
+const banRawSpanNameEmit = defineRule({
+	meta: meta$25,
+	create(context) {
+		return { CallExpression(node) {
+			const emitCall = inspect(node);
+			if (emitCall === null) return;
+			context.report({
+				node,
+				messageId: "banRawSpanName",
+				data: {
+					name: emitCall.name,
+					callee: emitCall.callee,
+					expected: EXPECTED$3,
+					actual: emitCall.name,
+					fix: FIX$3
+				}
+			});
+		} };
+	}
+});
+//#endregion
 //#region src/rules/path.config.ts
 const TEST_BASENAME = /\.(?:test|spec)\.[cm]?tsx?$/;
 const SANCTIONED_TEST_DIRS = /* @__PURE__ */ new Set(["tests"]);
@@ -28,6 +97,7 @@ const SCHEMA_SUFFIX = ".schema.test.ts";
 const WORKFLOW_TEST_BASENAME = /^[^.]+\.workflow\.property\.test\.ts$/;
 const GHERKIN_PACKAGE = "@systemfsoftware/effect-gherkin-spec";
 const DIFFERENTIAL_PACKAGE = "@systemfsoftware/differential-spec";
+const TRACE_SPEC_PACKAGE = "@systemfsoftware/trace-spec";
 const FOREIGN_RUNNERS = /* @__PURE__ */ new Set(["vitest", "@effect/vitest"]);
 const RUNNER_NAMES = /* @__PURE__ */ new Set([
 	"it",
@@ -42,7 +112,7 @@ const NO_SUBJECT_IMPORT_NAME = "a *.integration.test.ts that reaches no package
 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, 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$23 = {
+const meta$24 = {
 	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." },
 	schema: [],
@@ -155,7 +225,7 @@ const DIST_SEGMENT = /(?:^|\/)dist\//;
 * path names nothing satisfies the rule the same way a real one does.
 */
 const behaviourExercisesUseCase = defineRule({
-	meta: meta$23,
+	meta: meta$24,
 	create(context) {
 		let reached = false;
 		return {
@@ -205,7 +275,7 @@ const TOO_MANY_FEATURES_NAME = "a *.integration.test.ts accumulating multiple Fe
 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_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$22 = {
+const meta$23 = {
 	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." },
 	schema: [],
@@ -250,7 +320,7 @@ const hasAnyFeatureCall = (program) => {
 	return false;
 };
 const behaviourOneFeaturePerFile = defineRule({
-	meta: meta$22,
+	meta: meta$23,
 	create(context) {
 		return { "Program:exit"(node) {
 			if (!isBehaviourTest$2(basenameOf(context.filename))) return;
@@ -291,7 +361,7 @@ const MISSING_MAKE_FEATURE_NAME = "a *.integration.test.ts 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_FIX = "import { makeFeature } from @systemfsoftware/effect-gherkin-spec and declare `const Feature = makeFeature({ it, layer })`";
-const meta$21 = {
+const meta$22 = {
 	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 or @effect/vitest." },
 	schema: [],
@@ -319,7 +389,7 @@ const foreignRunnerNameOf = (specifier) => {
 };
 const isBehaviourTest$1 = (basename) => basename.endsWith(INTEGRATION_SUFFIX);
 const behaviourTestRequiresGherkin = defineRule({
-	meta: meta$21,
+	meta: meta$22,
 	create(context) {
 		const basename = basenameOf(context.filename);
 		return { Program(node) {
@@ -382,7 +452,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$20 = {
+const meta$21 = {
 	type: "suggestion",
 	docs: { description: "Enforce DAMP (Descriptive and Meaningful Phrases) test naming format: Should_[ExpectedBehavior]_When_[Condition]" },
 	schema: [],
@@ -462,7 +532,7 @@ const isTestFunctionCall = (node) => {
 	return false;
 };
 const dampTestNaming = defineRule({
-	meta: meta$20,
+	meta: meta$21,
 	create(context) {
 		return { CallExpression(node) {
 			if (!isTestFunctionCall(node)) return;
@@ -485,7 +555,7 @@ const dampTestNaming = defineRule({
 });
 //#endregion
 //#region src/rules/differential-test-requires-harness.config.ts
-const meta$19 = {
+const meta$20 = {
 	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." },
 	schema: [],
@@ -498,7 +568,7 @@ const meta$19 = {
 };
 //#endregion
 //#region src/rules/differential-test-requires-harness.ts
-const HARNESS_PRESCRIPTION = "import { Differential, Metamorphic } from @systemfsoftware/differential-spec and express the test as Differential.compare({ reference, candidate }).on(arb).assert(oracle) or Metamorphic.on(system).relation({ transformInput, assertOutput }).on(arb)";
+const HARNESS_PRESCRIPTION$1 = "import { Differential, Metamorphic } from @systemfsoftware/differential-spec and express the test as Differential.compare({ reference, candidate }).on(arb).assert(oracle) or Metamorphic.on(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 recordHarnessBindings = (node, bindings) => {
@@ -507,7 +577,7 @@ const recordHarnessBindings = (node, bindings) => {
 };
 const isForeignRunnerImport = (node) => typeof node.source.value === "string" && FOREIGN_RUNNERS.has(node.source.value);
 const differentialTestRequiresHarness = defineRule({
-	meta: meta$19,
+	meta: meta$20,
 	create(context) {
 		if (!context.filename.endsWith(".differential.test.ts")) return {};
 		const harnessBindings = /* @__PURE__ */ new Set();
@@ -521,9 +591,9 @@ const differentialTestRequiresHarness = defineRule({
 						messageId: "runnerImport",
 						data: {
 							name: `runner import from ${String(node.source.value)} in a differential test file`,
-							expected: HARNESS_PRESCRIPTION,
+							expected: HARNESS_PRESCRIPTION$1,
 							actual: "a direct vitest / @effect/vitest runner import bypasses the differential oracle",
-							fix: `delete the runner import; ${HARNESS_PRESCRIPTION}`
+							fix: `delete the runner import; ${HARNESS_PRESCRIPTION$1}`
 						}
 					});
 					violations += 1;
@@ -539,9 +609,9 @@ const differentialTestRequiresHarness = defineRule({
 						messageId: "rawRunnerCall",
 						data: {
 							name: `raw runner call (${name}) in a differential test file`,
-							expected: HARNESS_PRESCRIPTION,
+							expected: HARNESS_PRESCRIPTION$1,
 							actual: `${name}(...) bypasses the differential oracle`,
-							fix: `rewrite using ${HARNESS_PRESCRIPTION}`
+							fix: `rewrite using ${HARNESS_PRESCRIPTION$1}`
 						}
 					});
 					violations += 1;
@@ -556,9 +626,9 @@ const differentialTestRequiresHarness = defineRule({
 						messageId: "missingHarnessImport",
 						data: {
 							name: `differential test file without ${DIFFERENTIAL_PACKAGE} import`,
-							expected: HARNESS_PRESCRIPTION,
+							expected: HARNESS_PRESCRIPTION$1,
 							actual: "no differential harness import found",
-							fix: HARNESS_PRESCRIPTION
+							fix: HARNESS_PRESCRIPTION$1
 						}
 					});
 					return;
@@ -568,9 +638,9 @@ const differentialTestRequiresHarness = defineRule({
 					messageId: "missingHarnessUsage",
 					data: {
 						name: `differential test file imports ${DIFFERENTIAL_PACKAGE} but never invokes it`,
-						expected: HARNESS_PRESCRIPTION,
+						expected: HARNESS_PRESCRIPTION$1,
 						actual: "the harness is imported but no Differential.compare or Metamorphic.on chain runs",
-						fix: HARNESS_PRESCRIPTION
+						fix: HARNESS_PRESCRIPTION$1
 					}
 				});
 			}
@@ -583,7 +653,7 @@ const NON_PROP_CALL_NAME = "a non-property test call inside an `import.meta.vite
 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 meta$18 = {
+const meta$19 = {
 	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: [],
@@ -647,7 +717,7 @@ const rootNameOf = (node) => {
 	if (node.type === "CallExpression") return rootNameOf(node.callee);
 };
 const inSourceTestPropOnly = defineRule({
-	meta: meta$18,
+	meta: meta$19,
 	create(context) {
 		const filename = context.filename;
 		const basename = basenameOf(filename);
@@ -692,7 +762,7 @@ const NO_PRIVATE_TARGET_NAME = "an `import.meta.vitest` block touching no privat
 const NO_PRIVATE_TARGET_EXPECTED = "an in-source test exercising a non-exported module-level binding";
 const NO_PRIVATE_TARGET_ACTUAL = "an in-source block referencing only exported or imported names";
 const NO_PRIVATE_TARGET_FIX = "test the public surface from tests/ as *.integration.test.ts; in-source blocks exist for private helpers only — if the public behaviour you meant to cover is a pure function, delete the assertion: the type system already proves it";
-const meta$17 = {
+const meta$18 = {
 	type: "problem",
 	docs: { description: "In-source `if (import.meta.vitest)` blocks under src/ must be at module level and exercise at least one non-exported binding; other tests belong in tests/." },
 	schema: [],
@@ -726,7 +796,7 @@ const collectPrivateNames = (body, out) => {
 	}
 };
 const inSourceTestTargetsPrivate = defineRule({
-	meta: meta$17,
+	meta: meta$18,
 	create(context) {
 		const filename = context.filename;
 		const basename = basenameOf(filename);
@@ -785,7 +855,7 @@ const inSourceTestTargetsPrivate = defineRule({
 //#endregion
 //#region src/rules/no-assert-in-property.config.ts
 const MESSAGE$6 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
-const meta$16 = {
+const meta$17 = {
 	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: [],
@@ -823,7 +893,7 @@ const isInsidePropPredicate = (node) => {
 	return isInsidePropPredicate(parent);
 };
 const noAssertInProperty = defineRule({
-	meta: meta$16,
+	meta: meta$17,
 	create(context) {
 		return { CallExpression(node) {
 			const callee = node.callee;
@@ -876,7 +946,7 @@ const SKIP_WALK_KEYS = /* @__PURE__ */ new Set([
 	"range",
 	"parent"
 ]);
-const meta$15 = {
+const meta$16 = {
 	type: "problem",
 	docs: { description: "Flag an assertion whose subject and expectation are both built only from imported declarations and literals. Such an assertion invokes nothing, so no change to the behaviour under test can make it fail." },
 	schema: [],
@@ -944,7 +1014,7 @@ const importedNames = (program) => {
 	return names;
 };
 const noBehaviourlessAssertion = defineRule({
-	meta: meta$15,
+	meta: meta$16,
 	create(context) {
 		if (!TEST_FILE.test(context.filename)) return {};
 		const imported = importedNames(context.sourceCode.ast);
@@ -1014,7 +1084,7 @@ const IO_SOURCE_TEST_NAME = "An in-source `import.meta.vitest` test block";
 const IO_SOURCE_TEST_EXPECTED = "the tests of a module whose own source calls an I/O binding to live outside it — a separate test file, or a composition test with a double at the port";
 const IO_SOURCE_TEST_ACTUAL = "this module calls a binding imported from a filesystem, process or network module and guards tests in-source with `import.meta.vitest`";
 const IO_SOURCE_TEST_FIX = "test the module from outside its own source — a separate test file or a composition test doubling the boundary — or, when an assertion merely restates a literal the module already computes, it is a change detector: delete it. The verdict here is the file's own imports and calls, never its name";
-const meta$14 = {
+const meta$15 = {
 	type: "problem",
 	docs: { description: "Reports an in-source `import.meta.vitest` test block in a module whose own syntax shows a called, non-type import from a filesystem, process or network module. Judges only the in-source-test idiom — a module whose tests live in separate files is a no-op for this rule, whatever it imports." },
 	schema: [],
@@ -1035,7 +1105,7 @@ const bindingBase = (callee) => {
 	if (callee.type === "Identifier") return callee.name;
 };
 const noIoModuleInSourceTest = defineRule({
-	meta: meta$14,
+	meta: meta$15,
 	create(context) {
 		/** Local binding name -> specifier it was (non-type) imported from. */
 		const ioBindings = {};
@@ -1100,7 +1170,7 @@ const VIOLATION_NAME$2 = "quantification nested inside a property predicate";
 const EXPECTED$2 = "per-case cost bounded by the draw, not by the draw times a second traversal — inspect a generated value with a fold whose body calls nothing, or move the inner quantifier into the generator so the shrinker can see it";
 const ACTUAL$2 = "the predicate iterates a value derived from a generated parameter and calls a free function inside that loop, so cost scales with the drawn size times whatever that call costs";
 const FIX$2 = "hoist the inner call out of the loop when its result does not vary per element; otherwise assert one drawn element per case and let numRuns supply the quantifier, or generate the pair and compare directly. If the cost is understood and accepted, add this file's basename to the rule's exempt option";
-const meta$13 = {
+const meta$14 = {
 	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],
@@ -1251,7 +1321,7 @@ const check = (context, call, predicate) => {
 * and excluded; DISCHARGED_BY in the suite pins the unbounded recipe shape.
 */
 const noNestedQuantification = defineRule({
-	meta: meta$13,
+	meta: meta$14,
 	create(context) {
 		const options = Schema.decodeUnknownSync(Options$2)(context.options[0] ?? {});
 		const exempt = new Set(options.exempt);
@@ -1269,10 +1339,10 @@ 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_EXPECTED = "a feature builder chained with .withLayer(...) or .withScenarioLayer(...)";
-const NO_LAYER_IN_FEATURE_ACTUAL = "a Feature(...) call with no .withLayer or .withScenarioLayer builder method";
-const NO_LAYER_IN_FEATURE_FIX = "an integration test under WGI-CLS1 exercises real collaborator seams using Layer doubles (withLayer or withScenarioLayer). A test with no Layers is a pure in-memory calculation: move its laws into deterministic-universal scenarios, or provide the external boundary Layer it exercises.";
-const meta$12 = {
+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 meta$13 = {
 	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." },
 	schema: [],
@@ -1307,7 +1377,7 @@ const findRootFeatureCall = (callNode) => {
 	return null;
 };
 const noPseudoGherkinUnitTests = defineRule({
-	meta: meta$12,
+	meta: meta$13,
 	create(context) {
 		if (!isBehaviourTest(basenameOf(context.filename))) return {};
 		return { CallExpression(node) {
@@ -1332,7 +1402,7 @@ const noPseudoGherkinUnitTests = defineRule({
 //#endregion
 //#region src/rules/no-silent-return.config.ts
 const MESSAGE$4 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
-const meta$11 = {
+const meta$12 = {
 	type: "problem",
 	docs: { description: "Property predicates (it.prop / it.effect.prop from @effect/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: [],
@@ -1480,7 +1550,7 @@ const checkFn = (context, fn) => {
 	if (!Array$1.last(body.body).pipe(Option.exists(pathExits))) report(context, fn, "missingReturn", "the predicate can fall off the end without returning — undefined is a silent pass");
 };
 const noSilentReturn = defineRule({
-	meta: meta$11,
+	meta: meta$12,
 	create(context) {
 		return { CallExpression(node) {
 			if (!isPropCallee(node.callee)) return;
@@ -1509,7 +1579,7 @@ const SCHEMA_TEST_DETAIL = {
 	actual: "an authored *.schema.test.ts restating generated coverage",
 	fix: "delete it. The generated laws already state round-trip identity and encode stability. What they cannot state is rejection — every input they draw comes from the arbitrary the schema itself supplies — so a refusal belongs in an in-source if (import.meta.vitest) block in the schema file, never here"
 };
-const meta$10 = {
+const meta$11 = {
 	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." },
 	schema: [Schema.toJsonSchemaDocument(Options$1).schema],
@@ -1523,7 +1593,7 @@ const meta$10 = {
 //#region src/rules/no-test-file-in-src.ts
 const violationOf = (basename, isPropertyTest, dir) => basename.endsWith(".schema.test.ts") ? ["schemaTestInSrc", SCHEMA_TEST_DETAIL] : isPropertyTest ? ["propertyTestOutsideTestsDir", propertyTestLocationDetail(dir)] : ["testFileInSrc", testFileInSrcDetail(dir)];
 const noTestFileInSrc = defineRule({
-	meta: meta$10,
+	meta: meta$11,
 	create(context) {
 		const { sanctionedDirs } = Schema.decodeUnknownSync(Options$1)(context.options[0] ?? {});
 		const basename = basenameOf(context.filename);
@@ -1576,7 +1646,7 @@ const PREDICATE_SYMBOLS = /* @__PURE__ */ new Set([
 const NULLARY_PREDICATE_SYMBOLS = /* @__PURE__ */ new Set(["⊥"]);
 const PASCAL_CASE = /^[A-Z][a-z][a-zA-Z0-9]*$/;
 const DAMP_WORDS = /When|Should|Given|Then|Otherwise|After|Before/;
-const meta$9 = {
+const meta$10 = {
 	type: "suggestion",
 	docs: { description: "Enforce a complete formal-specification name for property-based tests (it.prop / it.effect.prop). Format: [ScopeSymbol][binder]_[Domain]_[PredicateSymbol][operand] (e.g., ∀x_DecodeEncode_=x, ∀l_Filter_⊆Input, →Shipped_Cancel_⊥Allowed). Both the quantifier and the predicate must carry an operand — a bare symbol specifies nothing." },
 	schema: [],
@@ -1620,7 +1690,7 @@ const parseSegments = (name) => {
 	};
 };
 const pbtNaming = defineRule({
-	meta: meta$9,
+	meta: meta$10,
 	create(context) {
 		return { CallExpression(node) {
 			if (!isPropCall(node)) return;
@@ -1728,7 +1798,7 @@ const SCHEMA_NAMESPACE_NAMES = {
 };
 const FASTCHECK_NAMESPACE_NAMES = { FastCheck: true };
 const COMBINATOR_CALLEES = { pipe: true };
-const meta$8 = {
+const meta$9 = {
 	type: "problem",
 	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: [],
@@ -2011,7 +2081,7 @@ const checkPropCall$1 = (provenance, context, call) => {
 	}
 };
 const propArbitrarySchemaOrigin = defineRule({
-	meta: meta$8,
+	meta: meta$9,
 	create(context) {
 		const provenance = new Provenance(context.sourceCode.getScope);
 		const collect = (value, out) => {
@@ -2075,7 +2145,7 @@ const VIOLATION_NAME = "a hand-rolled recursive schema fixture inside a test blo
 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";
 const FIX = "hoist the members into a named builder the annotated and counterfactual fixtures share, or declare the recursion point's generation in its annotation";
-const meta$7 = {
+const meta$8 = {
 	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: [],
@@ -2253,7 +2323,7 @@ const isNamedBuilderOrigin = (union, getScope) => {
 	return false;
 };
 const propFixtureSchemaOrigin = defineRule({
-	meta: meta$7,
+	meta: meta$8,
 	create(context) {
 		const getScope = context.sourceCode.getScope;
 		return { CallExpression(node) {
@@ -2290,7 +2360,7 @@ const NO_FUNCTION_NAME = "a property that tests no function";
 const NO_FUNCTION_EXPECTED = "every in-source property exercises domain logic — at least one call to a module-local function that is not a schema codec accessor — because a predicate that only feeds values through encode or decode tests the schema declaration, not code, and decode acceptance and refusal alike are generated or declared elsewhere";
 const NO_FUNCTION_ACTUAL = "no call in the predicate reaches module code — every call is a codec accessor, a schema wrapper, or an iteration combinator — so the property cannot fail unless the declaration it restates changes meaning";
 const NO_FUNCTION_FIX = "delete the prop; test the function that owns the decision — the workflow or a private helper in this module — with its input derived from a domain schema";
-const meta$6 = {
+const meta$7 = {
 	type: "problem",
 	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: [],
@@ -2436,7 +2506,7 @@ const checkPropCall = (provenance, context, call) => {
 	});
 };
 const propGeneratedLawDuplicate = defineRule({
-	meta: meta$6,
+	meta: meta$7,
 	create(context) {
 		const provenance = new Provenance(context.sourceCode.getScope);
 		const collect = (value, out) => {
@@ -2480,7 +2550,7 @@ const propGeneratedLawDuplicate = defineRule({
 //#region src/rules/property-file-purity.config.ts
 const PROPERTY_TEST_SUFFIX = ".property.test.ts";
 const MESSAGE = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
-const meta$5 = {
+const meta$6 = {
 	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." },
 	schema: [],
@@ -2596,7 +2666,7 @@ const createScenarioFileVisitors = (context) => ({
 });
 const kindOf = (filename) => filename.endsWith(".differential.test.ts") ? DIFFERENTIAL_FILE_KIND : PROPERTY_FILE_KIND;
 const propertyFilePurity = defineRule({
-	meta: meta$5,
+	meta: meta$6,
 	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));
@@ -2612,7 +2682,7 @@ const UNSANCTIONED_CELL_FIX = "rename it <stem>.workflow.property.test.ts beside
 const MISSING_CELL_TEST_EXPECTED = "a test for every cell suffix the consumer lists in cellsRequiringTest";
 const MISSING_CELL_TEST_ACTUAL = "a declared cell whose own module carries no `if (import.meta.vitest)` block";
 const MISSING_CELL_TEST_FIX = "add an `if (import.meta.vitest)` block to this module, or drop this cell from cellsRequiringTest and cover it with a colocated test in a sanctioned test directory — the rule reads the file it is given, so a sibling test file is invisible to it and a declared cell must satisfy the requirement from its own source";
-const meta$4 = {
+const meta$5 = {
 	type: "problem",
 	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],
@@ -2625,7 +2695,7 @@ const meta$4 = {
 //#region src/rules/src-property-test-cell.ts
 const carriesInSourceBlock = (body) => body.some((statement) => statement.type === "IfStatement" && isVitestGuard(statement.test));
 const srcPropertyTestCell = defineRule({
-	meta: meta$4,
+	meta: meta$5,
 	create(context) {
 		const { cellsRequiringTest } = Schema.decodeUnknownSync(Options)(context.options[0] ?? {});
 		const filename = context.filename;
@@ -2700,15 +2770,15 @@ const testFileOutsideTestsDir = defineRule({
 });
 //#endregion
 //#region src/rules/test-suffix-outside-src.config.ts
-const UNSANCTIONED_SUFFIX_EXPECTED = "exactly *.integration.test.ts or *.differential.test.ts outside src/";
-const UNSANCTIONED_SUFFIX_ACTUAL = "an unsanctioned test suffix outside src/";
-const UNSANCTIONED_SUFFIX_FIX = "name what this file exercises. Every scenario restates a literal from a pure cell (a lookup-table entry, a constant, a mapping) -> it is a change detector, not a test: delete it. It drives the package through its public surface -> rename it *.integration.test.ts, the one behaviour suffix, whether or not a layer doubles at a port. It proves parity or a metamorphic relation between implementations -> rename it *.differential.test.ts and express it through @systemfsoftware/differential-spec. It is a property over a pure cell -> it does not belong outside src/: convert it to an in-source if (import.meta.vitest) block in the module it covers";
+const UNSANCTIONED_SUFFIX_EXPECTED = "*.integration.test.ts, *.differential.test.ts, or *.trace.test.ts";
+const UNSANCTIONED_SUFFIX_ACTUAL = "another test suffix outside src/";
+const UNSANCTIONED_SUFFIX_FIX = "public surface -> *.integration.test.ts; parity -> *.differential.test.ts; span graph -> *.trace.test.ts; pure-cell property -> in-source; restated literal -> delete";
 //#endregion
 //#region src/rules/test-suffix-outside-src.ts
 const testSuffixOutsideSrc = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Outside src/, a test file must end .integration.test.ts or .differential.test.ts. Integration is the behaviour suffix; differential is the parity/metamorphic suffix driven by @systemfsoftware/differential-spec. Whether the layer doubles at a port is a judgement the suffix no longer encodes." },
+		docs: { description: "Outside src/, a test file ends .integration.test.ts, .differential.test.ts, or .trace.test.ts." },
 		schema: [],
 		messages: { unsanctionedSuffix: MESSAGE$7 }
 	},
@@ -2717,7 +2787,7 @@ const testSuffixOutsideSrc = defineRule({
 		if (isUnderSrc(filename)) return {};
 		const basename = basenameOf(filename);
 		if (!isTestFile(basename)) return {};
-		if (basename.endsWith(".integration.test.ts") || basename.endsWith(".differential.test.ts")) return {};
+		if (basename.endsWith(".integration.test.ts") || basename.endsWith(".differential.test.ts") || basename.endsWith(".trace.test.ts")) return {};
 		return { Program(node) {
 			context.report({
 				node,
@@ -2773,7 +2843,7 @@ const testsDirHelpersInFixtures = defineRule({
 const REACH_IN_EXPECTED = "a package name or subpath, or a sibling helper under the test tree";
 const REACH_IN_ACTUAL = "a relative import that reaches src or climbs into an internal folder";
 const REACH_IN_FIX = "rewrite onto the published package name when the binding is public. Delete the test when the subject is an internal";
-const meta = {
+const meta$1 = {
 	type: "problem",
 	docs: { description: "Forbid package-level tests from relative-importing src or climbing into an internal folder" },
 	schema: [],
@@ -2795,7 +2865,7 @@ const specifierOf = (node) => {
 	if (node.type === "Literal" && typeof node.value === "string") return node.value;
 };
 const testsImportPublicApi = defineRule({
-	meta,
+	meta: meta$1,
 	create(context) {
 		if (!isInTestsImportScope(context.filename)) return {};
 		const reportIfForbidden = (sourceNode) => {
@@ -2832,6 +2902,230 @@ 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,
+	statusText: true
+};
+const HTTP_PROPERTY_MATCHER = "toHaveProperty";
+const HTTP_OBJECT_MATCHERS = {
+	objectContaining: true,
+	toEqual: true,
+	toMatchObject: true,
+	toStrictEqual: true
+};
+const HTTP_TERMINATION_EXPECTED = "a case terminated on a relation hold — .holds(Rel.all(...)) over the declared span graph";
+const HTTP_TERMINATION_ACTUAL = "an HTTP response assertion terminating the case";
+const HTTP_TERMINATION_FIX = "replace the HTTP assertion with a relation over the observed spans, e.g. .holds(Rel.all(Rel.exists(PlaceOrder), Rel.child(PlaceOrder, PaymentCapture)))";
+const RAW_EMIT_EXPECTED = "spans declared once with Span.declare({ id, name, attrs }) inside the traced cell; the spec observes the decoded graph";
+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 = {
+	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." },
+	schema: [],
+	messages: {
+		missingHarnessImport: MESSAGE$7,
+		httpTermination: MESSAGE$7,
+		rawEmitCall: MESSAGE$7
+	}
+};
+//#endregion
+//#region src/rules/trace-test-requires-taxonomy.ts
+const asIdentifierName = (expression) => {
+	if (expression === void 0 || expression.type !== "Identifier") return null;
+	return expression.name;
+};
+const isEmitCallee = (name) => EMIT_CALLEES.some((emit) => emit === name);
+const isExpectCall = (node) => node?.type === "CallExpression" && asIdentifierName(node.callee) === "expect";
+const expectCallUnder = (node) => {
+	const callee = node.callee;
+	if (callee.type !== "MemberExpression" || !isExpectCall(callee.object)) return null;
+	return callee.object;
+};
+const memberReadName = (argument) => {
+	if (argument === void 0 || argument.type !== "MemberExpression") return null;
+	return asIdentifierName(argument.property);
+};
+const httpReadName = (node) => {
+	const read = memberReadName(expectCallUnder(node)?.arguments[0]);
+	if (read === null || HTTP_MEMBERS[read] !== true) return null;
+	return read;
+};
+const memberCallName = (callee) => {
+	if (callee.type !== "MemberExpression") return null;
+	return callee.computed ? null : asIdentifierName(callee.property);
+};
+const emitCalleeName = (node) => {
+	return asIdentifierName(node.callee) ?? memberCallName(node.callee);
+};
+const rawEmitName = (node) => {
+	const name = emitCalleeName(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;
+};
+const stringLiteralValue = (node) => {
+	const value = literalValueOf(node);
+	return typeof value === "string" ? value : null;
+};
+const stringElementValue = (element) => stringLiteralValue(element ?? void 0);
+const httpMemberName = (name) => HTTP_MEMBERS[name] === true ? name : null;
+const httpMemberHead = (path) => {
+	const head = path.split(".")[0];
+	return head === void 0 ? null : httpMemberName(head);
+};
+const propertyPathText = (node) => node?.type === "ArrayExpression" ? stringElementValue(node.elements[0]) : stringLiteralValue(node);
+const toHavePropertyMember = (node) => {
+	const path = propertyPathText(node.arguments[0]);
+	return path === null ? null : httpMemberHead(path);
+};
+const propertyMatchTermination = (node, matcher) => {
+	const member = toHavePropertyMember(node);
+	return matcher === "toHaveProperty" ? member : null;
+};
+const identifierKeyName = (key) => {
+	if (key.type !== "Identifier") return null;
+	return key.name;
+};
+const keyLiteralValue = (key) => {
+	if (key.type !== "Literal") return null;
+	return key.value;
+};
+const stringKeyName = (key) => {
+	const value = keyLiteralValue(key);
+	return typeof value === "string" ? value : null;
+};
+const objectKeyName = (key) => {
+	const identifier = identifierKeyName(key);
+	return identifier === null ? stringKeyName(key) : identifier;
+};
+const objectPropertyKey = (property) => {
+	if (property.type !== "Property" || property.computed) return null;
+	return property.key;
+};
+const propertyKeyName = (property) => {
+	const key = objectPropertyKey(property);
+	return key === null ? null : objectKeyName(key);
+};
+const httpMemberOr = (name) => name === null ? null : httpMemberName(name);
+const propertyValueOf = (property) => property.type === "Property" ? property.value : null;
+const nestedPropertyHttpKey = (property) => httpKeyOfValue(propertyValueOf(property));
+const httpKeyOfProperty = (property) => {
+	const named = httpMemberOr(propertyKeyName(property));
+	return named === null ? nestedPropertyHttpKey(property) : named;
+};
+const elementsHttpKey = (elements) => {
+	const hit = elements.find((element) => httpKeyOfValue(element) !== null);
+	return hit === void 0 ? null : httpKeyOfValue(hit);
+};
+const httpKeyOfNonObject = (value) => value?.type === "ArrayExpression" ? elementsHttpKey(value.elements) : null;
+const httpKeyOfValue = (value) => value?.type === "ObjectExpression" ? propertiesHttpKey(value.properties) : httpKeyOfNonObject(value);
+const propertiesHttpKey = (properties) => {
+	const hit = properties.find((property) => httpKeyOfProperty(property) !== null);
+	return hit === void 0 ? null : httpKeyOfProperty(hit);
+};
+const isObjectExpression = (node) => node.type === "ObjectExpression";
+const objectArgumentHttpKey = (node) => {
+	const argument = node.arguments.find(isObjectExpression);
+	return argument === void 0 ? null : propertiesHttpKey(argument.properties);
+};
+const isObjectShapeMatcher = (matcher) => HTTP_OBJECT_MATCHERS[matcher] === true;
+const objectMatchTermination = (node, matcher) => {
+	const key = objectArgumentHttpKey(node);
+	return isObjectShapeMatcher(matcher) ? key : null;
+};
+const isExpectIdentifier = (node) => node.type === "Identifier" && node.name === "expect";
+const isExpectReference = (node) => isExpectCall(node) || isExpectIdentifier(node);
+const chainRootsAtExpect = (node) => node.type === "MemberExpression" ? chainRootsAtExpect(node.object) : isExpectReference(node);
+const calleeRootsAtExpect = (callee) => callee.type === "MemberExpression" ? chainRootsAtExpect(callee.object) : false;
+const matcherCallName = (node) => {
+	if (!calleeRootsAtExpect(node.callee)) return null;
+	return memberCallName(node.callee);
+};
+const propertyMatchName = (member) => `expect(...).${HTTP_PROPERTY_MATCHER}('${member}')`;
+const objectMatchName = (matcher, key) => `expect(...).${matcher}({ ${key}: ... })`;
+const objectMatchedName = (node, matcher) => {
+	const key = objectMatchTermination(node, matcher);
+	return key === null ? null : objectMatchName(matcher, key);
+};
+const matchedShapeName = (node, matcher) => {
+	const member = propertyMatchTermination(node, matcher);
+	return member === null ? objectMatchedName(node, matcher) : propertyMatchName(member);
+};
+const shapeTerminationName = (node) => {
+	const matcher = matcherCallName(node);
+	return matcher === null ? null : matchedShapeName(node, matcher);
+};
+const httpTerminationName = (node) => {
+	const direct = httpReadName(node);
+	return direct === null ? shapeTerminationName(node) : `expect(...${direct})`;
+};
+const reportRawEmit = (context, node) => {
+	const name = rawEmitName(node);
+	if (name === null) return;
+	context.report({
+		node,
+		messageId: "rawEmitCall",
+		data: {
+			name: `${name}(...) inside a trace spec`,
+			expected: RAW_EMIT_EXPECTED,
+			actual: RAW_EMIT_ACTUAL,
+			fix: RAW_EMIT_FIX
+		}
+	});
+};
+const reportHttpTermination = (context, node) => {
+	const name = httpTerminationName(node);
+	if (name === null) return;
+	context.report({
+		node,
+		messageId: "httpTermination",
+		data: {
+			name: `${name} inside a trace spec`,
+			expected: HTTP_TERMINATION_EXPECTED,
+			actual: HTTP_TERMINATION_ACTUAL,
+			fix: HTTP_TERMINATION_FIX
+		}
+	});
+};
+const traceTestRequiresTaxonomy = defineRule({
+	meta,
+	create(context) {
+		if (!context.filename.endsWith(".trace.test.ts")) return {};
+		let hasHarnessImport = false;
+		return {
+			ImportDeclaration(node) {
+				if (hasHarnessBinding(node)) hasHarnessImport = true;
+			},
+			CallExpression(node) {
+				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/index.ts
 const PLUGIN_NAME = "@systemfsoftware/oxlint-plugin-test-discipline";
 const rule = (name) => `${PLUGIN_NAME}/${name}`;
@@ -2858,7 +3152,10 @@ const recommendedRules = {
 	[rule("tests-dir-helpers-in-fixtures")]: "error",
 	[rule("no-io-module-in-source-test")]: "error",
 	[rule("tests-import-public-api")]: "error",
-	[rule("differential-test-requires-harness")]: "error"
+	[rule("differential-test-requires-harness")]: "error",
+	[rule("no-pseudo-gherkin-unit-tests")]: "error",
+	[rule("ban-raw-span-name-emit")]: "error",
+	[rule("trace-test-requires-taxonomy")]: "error"
 };
 var src_default = {
 	meta: { name: PLUGIN_NAME },
@@ -2886,7 +3183,9 @@ var src_default = {
 		"tests-dir-helpers-in-fixtures": testsDirHelpersInFixtures,
 		"no-io-module-in-source-test": noIoModuleInSourceTest,
 		"tests-import-public-api": testsImportPublicApi,
-		"differential-test-requires-harness": differentialTestRequiresHarness
+		"differential-test-requires-harness": differentialTestRequiresHarness,
+		"ban-raw-span-name-emit": banRawSpanNameEmit,
+		"trace-test-requires-taxonomy": traceTestRequiresTaxonomy
 	},
 	configs: { recommended: { rules: recommendedRules } }
 };

package/dist/oxlint-plugin-test-discipline-untrimmed.d.ts

@@ -29,6 +29,8 @@ declare const _default: {
         'no-io-module-in-source-test': Rule;
         'tests-import-public-api': Rule;
         'differential-test-requires-harness': Rule;
+        'ban-raw-span-name-emit': Rule;
+        'trace-test-requires-taxonomy': Rule;
     };
     configs: {
         recommended: {

package/dist/oxlint-plugin-test-discipline.d.ts

@@ -29,6 +29,8 @@ declare const _default: {
         'no-io-module-in-source-test': Rule;
         'tests-import-public-api': Rule;
         'differential-test-requires-harness': Rule;
+        'ban-raw-span-name-emit': Rule;
+        'trace-test-requires-taxonomy': Rule;
     };
     configs: {
         recommended: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/oxlint-plugin-test-discipline",
   "license": "Apache-2.0",
-  "version": "3.6.0",
+  "version": "3.8.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -44,11 +44,11 @@
   "devDependencies": {
     "@microsoft/api-extractor": "^7.59.1",
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
-    "@systemfsoftware/stryker-ignorer-effect-schema-declarations": "^0.1.0",
-    "@systemfsoftware/stryker-ignorer-in-source-vitest-block": "^0.1.0",
-    "@systemfsoftware/stryker-js": "^10.0.1",
-    "@systemfsoftware/stryker-js-typescript-checker": "^7.0.4",
-    "@systemfsoftware/stryker-js-vitest-runner": "^7.0.1",
+    "@systemfsoftware/stryker-ignorer-effect-schema-declarations": "^0.1.1",
+    "@systemfsoftware/stryker-ignorer-in-source-vitest-block": "^0.1.1",
+    "@systemfsoftware/stryker-js": "^10.1.1",
+    "@systemfsoftware/stryker-js-typescript-checker": "^7.0.5",
+    "@systemfsoftware/stryker-js-vitest-runner": "^7.1.1",
     "@systemfsoftware/stryker-test-contribution": "^3.0.3",
     "@types/node": "^26",
     "@vitest/coverage-v8": "^5",
@@ -59,10 +59,10 @@
     "tsdown": "^0.23.0",
     "typescript": "^7",
     "vitest": "^5",
-    "@systemfsoftware/tsconfig": "^1.3.6",
-    "@systemfsoftware/tsdown-config": "^0.1.0",
+    "@systemfsoftware/stryker-config": "^0.1.0",
     "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/stryker-config": "^0.1.0"
+    "@systemfsoftware/tsconfig": "^1.3.6",
+    "@systemfsoftware/tsdown-config": "^0.1.0"
   },
   "peerDependencies": {
     "effect": "4.0.0-rc.116",