@sayoriqwq/effect-harness 0.2.0 → 0.3.0

package/dist/eslint.d.ts

@@ -2701,7 +2701,7 @@ declare namespace ESLint {
 //#endregion
 //#region src/eslint.d.ts
 /**
- * Composable Effect guardrails for a target-owned ESLint flat config.
+ * Composable pinned-reference boundaries for a target-owned ESLint flat config.
  *
  * Targets import this value from `@sayoriqwq/effect-harness/eslint`; Prelude
  * intentionally never rewrites executable config files.

package/dist/eslint.js

@@ -1,97 +1,20 @@
-const effectHarnessEslintPlugin = { rules: { "no-disable-validation": {
-	meta: {
-		type: "problem",
-		docs: { description: "Disallow disabling Effect Schema validation." },
-		messages: { noDisableValidation: "Do not use { disableValidation: true }. Fix the data or schema instead of disabling validation." },
-		schema: []
-	},
-	create(context) {
-		return { Property(node) {
-			if ((node.key.type === "Identifier" && node.key.name === "disableValidation" || node.key.type === "Literal" && node.key.value === "disableValidation") && node.value.type === "Literal" && node.value.value === true) context.report({
-				node,
-				messageId: "noDisableValidation"
-			});
-		} };
-	}
-} } };
-const sharedEffectEslintPolicy = {
-	rules: { "effect-harness/no-disable-validation": "error" },
-	restrictedImports: {
-		paths: [{
-			name: "node:test",
-			message: "Use @effect/vitest for Effect test entries."
-		}, {
-			name: "@effect/cli",
-			message: "Use effect/unstable/cli for Effect v4 beta."
-		}],
-		patterns: [
-			{
-				group: ["@effect/cli/*"],
-				message: "Use effect/unstable/cli for Effect v4 beta."
-			},
-			{
-				group: ["repos/effect/**", "**/repos/effect/**"],
-				message: "Import installed packages, never pinned source trees."
-			},
-			{
-				group: ["repos/tsgo/**", "**/repos/tsgo/**"],
-				message: "Use tsgo through its installed package."
-			}
-		]
-	},
-	restrictedSyntax: [{
-		selector: "MemberExpression[object.name=\"Context\"][property.name=\"Tag\"]",
-		message: "Use Context.Service for Effect v4 services."
-	}, {
-		selector: "MemberExpression[object.name=\"Effect\"][property.name=/^(catchAllCause|serviceOption)$/]",
-		message: "Use the Effect-native safer pattern."
-	}]
-};
-const effectTestEslintPolicy = {
-	restrictedImportPaths: [{
-		name: "vitest",
-		importNames: [
-			"describe",
-			"it",
-			"test"
-		],
-		message: "Use @effect/vitest Effect entries."
-	}],
-	restrictedSyntax: [{
-		selector: "CallExpression[callee.name=\"it\"]",
-		message: "Use it.effect, it.live, or layer from @effect/vitest."
-	}]
-};
 //#endregion
 //#region src/eslint.ts
 /**
-* Composable Effect guardrails for a target-owned ESLint flat config.
+* Composable pinned-reference boundaries for a target-owned ESLint flat config.
 *
 * Targets import this value from `@sayoriqwq/effect-harness/eslint`; Prelude
 * intentionally never rewrites executable config files.
 */
 const effectHarnessEslintConfig = [{
 	name: "effect-harness/guardrails",
-	plugins: { "effect-harness": effectHarnessEslintPlugin },
-	rules: {
-		...sharedEffectEslintPolicy.rules,
-		"no-restricted-imports": ["error", sharedEffectEslintPolicy.restrictedImports],
-		"no-restricted-syntax": ["error", ...sharedEffectEslintPolicy.restrictedSyntax]
-	}
-}, {
-	name: "effect-harness/tests",
-	files: ["tests/**/*.test.{js,mjs,ts}"],
-	rules: {
-		"no-restricted-imports": ["error", {
-			paths: [...sharedEffectEslintPolicy.restrictedImports.paths, ...effectTestEslintPolicy.restrictedImportPaths],
-			patterns: sharedEffectEslintPolicy.restrictedImports.patterns
-		}],
-		"no-restricted-syntax": [
-			"error",
-			...sharedEffectEslintPolicy.restrictedSyntax,
-			...effectTestEslintPolicy.restrictedSyntax
-		]
-	}
+	rules: { "no-restricted-imports": ["error", { restrictedImports: { patterns: [{
+		group: ["repos/effect/**", "**/repos/effect/**"],
+		message: "Import installed packages, never pinned Effect reference trees."
+	}, {
+		group: ["repos/tsgo/**", "**/repos/tsgo/**"],
+		message: "Use tsgo through its installed package, never its pinned reference tree."
+	}] } }.restrictedImports] }
 }];
 //#endregion
 export { effectHarnessEslintConfig as default };

package/dist/prelude.d.ts

@@ -1,22 +1,13 @@
 import * as _$_sayoriqwq_prelude_contract0 from "@sayoriqwq/prelude-contract";
-import * as _$effect_Schema0 from "effect/Schema";
 
 //#region src/prelude.d.ts
-declare const harnessModule: _$_sayoriqwq_prelude_contract0.HarnessModule<_$effect_Schema0.Struct.ReadonlySide<{
-  readonly _tag: _$effect_Schema0.tag<"TargetObservationError">;
-  readonly operation: _$effect_Schema0.Literals<readonly ["readBytes", "readText", "readDirectory", "readPackageManifest"]>;
-  readonly locator: _$effect_Schema0.Union<readonly [_$effect_Schema0.Struct<{
-    readonly root: _$effect_Schema0.Literal<"ControlRoot">;
-    readonly path: _$effect_Schema0.String;
-  }>, _$effect_Schema0.Struct<{
-    readonly root: _$effect_Schema0.Literal<"IntegrationWorkspace">;
-    readonly path: _$effect_Schema0.String;
-  }>, _$effect_Schema0.Struct<{
-    readonly root: _$effect_Schema0.Literal<"PackageRoot">;
-    readonly packageRoot: _$effect_Schema0.String;
-    readonly path: _$effect_Schema0.String;
-  }>]>;
-  readonly message: _$effect_Schema0.String;
-}, "Type">>;
+/**
+ * Read-only Effect Harness Module.
+ *
+ * Prelude converges only stable Harness-owned assets. Repository-specific
+ * package, TypeScript, editor, lint, activation, and verification adaptation
+ * begins after delivery through the managed Target Adaptation skill.
+ */
+declare const harnessModule: _$_sayoriqwq_prelude_contract0.HarnessModule<never>;
 //#endregion
 export { harnessModule };

package/dist/prelude.js

@@ -1,7 +1,29 @@
-import { Buffer } from "node:buffer";
 import { CANONICAL_TREE_ARCHIVE_FORMAT, MODULE_PROTOCOL_V2, PRELUDE_V2_SUPPORTED_FEATURES, defineHarnessModule } from "@sayoriqwq/prelude-contract";
 import { Effect } from "effect";
-import * as TypeScript from "typescript";
+//#region artifact-assets/effect/reference-archives/effect.json
+var effect_default = {
+	archive: { "format": "prelude-canonical-tree-archive-v1" },
+	name: "effect",
+	provenance: {
+		"sourceUrl": "https://github.com/Effect-TS/effect-smol",
+		"revision": "f643dbb265093065dc0a61ca6133693dc2401678",
+		"treeDigest": "d797515e8ecb2e164deef65b6b7abde6445201ce9d1e9e584f39d634c2469e95"
+	},
+	schemaVersion: 1
+};
+//#endregion
+//#region artifact-assets/effect/reference-archives/tsgo.json
+var tsgo_default = {
+	archive: { "format": "prelude-canonical-tree-archive-v1" },
+	name: "tsgo",
+	provenance: {
+		"sourceUrl": "https://github.com/Effect-TS/tsgo",
+		"revision": "f0d48a67515048d277feb2c184c41cd7cffa51a4",
+		"treeDigest": "f76adab084de0de584e0a565679b3afca2b48674a28e36c7dd6398846fd2bd9d"
+	},
+	schemaVersion: 1
+};
+//#endregion
 //#region src/harness/Baseline.ts
 const versions = {
 	effect: "4.0.0-beta.97",
@@ -33,6 +55,11 @@ const requiredDevToolTarget = {
 */
 const acceptedEffectBaseline = {
 	versions,
+	typescriptTopology: {
+		primaryCompiler: "nativeTypescript",
+		effectSemanticAuthority: "tsgo",
+		compilerApiCompatibility: "typescript"
+	},
 	packages: {
 		effect: {
 			id: "runtime",
@@ -122,145 +149,6 @@ const acceptedEffectBaseline = {
 		}
 	}
 };
-/** Policy item projected into each approved Target Package Root by Prelude. */
-const effectTsgoTargetProjection = { languageServicePlugin: {
-	name: "@effect/language-service",
-	diagnostics: true,
-	includeSuggestionsInTsc: true,
-	ignoreEffectSuggestionsInTscExitCode: false,
-	ignoreEffectWarningsInTscExitCode: false,
-	ignoreEffectErrorsInTscExitCode: false,
-	diagnosticSeverity: {
-		anyUnknownInErrorContext: "error",
-		asyncFunction: "warning",
-		catchAllToMapError: "suggestion",
-		catchToIgnore: "suggestion",
-		catchToOrElseSucceed: "suggestion",
-		catchUnfailableEffect: "suggestion",
-		classSelfMismatch: "error",
-		cryptoRandomUUID: "warning",
-		cryptoRandomUUIDInEffect: "warning",
-		deterministicKeys: "warning",
-		duplicatePackage: "warning",
-		effectDoNotation: "warning",
-		effectFnIife: "warning",
-		effectFnImplicitAny: "error",
-		effectFnOpportunity: "suggestion",
-		effectGenUsesAdapter: "warning",
-		effectInFailure: "warning",
-		effectInVoidSuccess: "warning",
-		effectMapFlatten: "suggestion",
-		effectMapVoid: "suggestion",
-		effectSucceedWithVoid: "suggestion",
-		extendsNativeError: "warning",
-		flatMapToMap: "suggestion",
-		floatingEffect: "error",
-		genericEffectServices: "warning",
-		globalConsole: "warning",
-		globalConsoleInEffect: "warning",
-		globalDate: "warning",
-		globalDateInEffect: "warning",
-		globalErrorInEffectCatch: "warning",
-		globalErrorInEffectFailure: "warning",
-		globalFetch: "warning",
-		globalFetchInEffect: "warning",
-		globalRandom: "warning",
-		globalRandomInEffect: "warning",
-		globalTimers: "warning",
-		globalTimersInEffect: "warning",
-		instanceOfSchema: "warning",
-		layerMergeAllWithDependencies: "warning",
-		lazyEffect: "suggestion",
-		lazyPromiseInEffectSync: "warning",
-		leakingRequirements: "suggestion",
-		missedPipeableOpportunity: "warning",
-		missingEffectContext: "error",
-		missingEffectError: "error",
-		missingLayerContext: "error",
-		missingReturnYieldStar: "error",
-		missingStarInYieldEffectGen: "error",
-		multipleCatchTag: "suggestion",
-		multipleEffectProvide: "warning",
-		nestedEffectGenYield: "warning",
-		newPromise: "warning",
-		newSchemaClass: "warning",
-		nodeBuiltinImport: "warning",
-		outdatedApi: "warning",
-		overriddenSchemaConstructor: "error",
-		preferSchemaOverJson: "warning",
-		processEnv: "warning",
-		processEnvInEffect: "warning",
-		redundantMapError: "suggestion",
-		redundantOrDie: "suggestion",
-		redundantSchemaTagIdentifier: "suggestion",
-		returnEffectInGen: "suggestion",
-		runEffectInsideEffect: "suggestion",
-		schemaNumber: "suggestion",
-		schemaStructWithTag: "suggestion",
-		serviceNotAsClass: "warning",
-		strictBooleanExpressions: "warning",
-		strictEffectProvide: "warning",
-		tryCatchInEffectGen: "suggestion",
-		unknownInEffectCatch: "warning",
-		unnecessaryArrowBlock: "warning",
-		unnecessaryEffectGen: "suggestion",
-		unnecessaryFailYieldableError: "suggestion",
-		unnecessaryPipe: "suggestion",
-		unnecessaryPipeChain: "suggestion",
-		unnecessaryTypeofType: "suggestion",
-		unsafeEffectTypeAssertion: "warning"
-	},
-	barrelImportPackages: ["effect"],
-	topLevelNamedReexports: "follow",
-	effectFn: ["span"],
-	keyPatterns: [
-		{
-			target: "service",
-			pattern: "default",
-			skipLeadingPath: ["src/"]
-		},
-		{
-			target: "error",
-			pattern: "default",
-			skipLeadingPath: ["src/"]
-		},
-		{
-			target: "custom",
-			pattern: "default",
-			skipLeadingPath: ["src/"]
-		}
-	],
-	extendedKeyDetection: true,
-	layerGraphFollowDepth: 1,
-	noExternal: true,
-	inlays: true,
-	allowedDuplicatedPackages: [],
-	pipeableMinArgCount: 2
-} };
-//#endregion
-//#region artifact-assets/effect/reference-archives/effect.json
-var effect_default = {
-	archive: { "format": "prelude-canonical-tree-archive-v1" },
-	name: "effect",
-	provenance: {
-		"sourceUrl": "https://github.com/Effect-TS/effect-smol",
-		"revision": "f643dbb265093065dc0a61ca6133693dc2401678",
-		"treeDigest": "d797515e8ecb2e164deef65b6b7abde6445201ce9d1e9e584f39d634c2469e95"
-	},
-	schemaVersion: 1
-};
-//#endregion
-//#region artifact-assets/effect/reference-archives/tsgo.json
-var tsgo_default = {
-	archive: { "format": "prelude-canonical-tree-archive-v1" },
-	name: "tsgo",
-	provenance: {
-		"sourceUrl": "https://github.com/Effect-TS/tsgo",
-		"revision": "f0d48a67515048d277feb2c184c41cd7cffa51a4",
-		"treeDigest": "f76adab084de0de584e0a565679b3afca2b48674a28e36c7dd6398846fd2bd9d"
-	},
-	schemaVersion: 1
-};
 //#endregion
 //#region src/harness/SourcePins.ts
 const effectPin = acceptedEffectBaseline.sourcePins.effect;
@@ -269,281 +157,74 @@ function verifiedProvenance(publication, identity) {
 	if (publication.name !== identity.publicationName || publication.provenance.sourceUrl !== identity.sourceUrl) throw new Error(`Source Pin publication does not match accepted Baseline identity: ${identity.publicationName}`);
 	return publication.provenance;
 }
-/**
-* Immutable declarations derived from the Source Pin publications.
-*
-* Partita publishes each archive and its generic provenance. Effect Harness
-* adds only its concrete pin identity and Target delivery policy.
-*/
-const pinnedReferenceOutputs = [{
-	kind: "PinnedReferenceTree",
-	id: effectPin.outputId,
-	archive: {
-		path: `artifact-assets/effect/reference-archives/${effectPin.publicationName}.pta`,
-		format: CANONICAL_TREE_ARCHIVE_FORMAT
-	},
-	locator: {
-		root: "IntegrationWorkspace",
-		path: effectPin.targetPath
-	},
-	provenance: verifiedProvenance(effect_default, effectPin),
-	referenceOnly: true
-}, {
-	kind: "PinnedReferenceTree",
-	id: tsgoPin.outputId,
-	archive: {
-		path: `artifact-assets/effect/reference-archives/${tsgoPin.publicationName}.pta`,
-		format: CANONICAL_TREE_ARCHIVE_FORMAT
-	},
-	locator: {
-		root: "IntegrationWorkspace",
-		path: tsgoPin.targetPath
-	},
-	provenance: verifiedProvenance(tsgo_default, tsgoPin),
-	referenceOnly: true
-}];
 //#endregion
 //#region src/prelude.ts
-const routingBlock = `## Effect Harness\n\nFor Effect application, test, package, TypeScript, editor, or lint changes, read the current Effect integration's \`.prelude/**/managed/docs/index.md\` first. Use \`.prelude/**/managed/skills/adapt-effect-target/SKILL.md\` when package selection or target-owned TypeScript topology needs adaptation. Keep \`.prelude/**/feedback/**\` target-owned. Treat \`.prelude/**/repos/**\` as read-only source diagnostics: consult it when installed declarations and managed guidance are insufficient, but never import or edit it.\n`;
-const managedTreeOutput = {
-	kind: "ManagedTree",
-	id: "effect.managed",
-	sourceRoot: "artifact-assets/effect/managed",
-	locator: {
-		root: "IntegrationWorkspace",
-		path: "managed"
-	}
-};
-const routingOutput = {
-	kind: "ManagedBlock",
-	id: "effect.agent-routing",
-	locator: {
-		root: "ControlRoot",
-		path: "AGENTS.md"
-	},
-	blockId: "effect-harness-routing",
-	content: routingBlock
-};
-const editorPolicyOutputs = [
+const stableHarnessOutputs = [
 	{
-		kind: "JsonValue",
-		id: "effect.vscode.auto-import-exclude",
+		kind: "ManagedTree",
+		id: "effect.managed",
+		sourceRoot: "artifact-assets/effect/managed",
 		locator: {
-			root: "ControlRoot",
-			path: ".vscode/settings.json"
-		},
-		pointer: "/typescript.preferences.autoImportFileExcludePatterns",
-		value: [".prelude/**/repos/**"]
+			root: "IntegrationWorkspace",
+			path: "managed"
+		}
 	},
 	{
-		kind: "JsonValue",
-		id: "effect.vscode.javascript-auto-import-exclude",
+		kind: "ManagedBlock",
+		id: "effect.agent-routing",
 		locator: {
 			root: "ControlRoot",
-			path: ".vscode/settings.json"
+			path: "AGENTS.md"
 		},
-		pointer: "/javascript.preferences.autoImportFileExcludePatterns",
-		value: [".prelude/**/repos/**"]
+		blockId: "effect-harness-routing",
+		content: `## Effect Harness\n\nFor Effect application, test, package, TypeScript, editor, or lint changes, read the current Effect integration's \`.prelude/**/managed/docs/index.md\` first. Use \`.prelude/**/managed/skills/adapt-effect-target/SKILL.md\` when package selection or target-owned TypeScript topology needs adaptation. Keep \`.prelude/**/feedback/**\` target-owned. Treat \`.prelude/**/repos/**\` as read-only source diagnostics: consult it when installed declarations and managed guidance are insufficient, but never import or edit it.\n`
 	},
-	{
-		kind: "JsonValue",
-		id: "effect.zed.auto-import-exclude",
-		locator: {
-			root: "ControlRoot",
-			path: ".zed/settings.json"
+	...[{
+		kind: "PinnedReferenceTree",
+		id: effectPin.outputId,
+		archive: {
+			path: `artifact-assets/effect/reference-archives/${effectPin.publicationName}.pta`,
+			format: CANONICAL_TREE_ARCHIVE_FORMAT
 		},
-		pointer: "/lsp/typescript-language-server/initialization_options/preferences/autoImportFileExcludePatterns",
-		value: [".prelude/**/repos/**"]
-	}
-];
-const baselineDevRequirements = [
-	acceptedEffectBaseline.packages.effectVitest,
-	acceptedEffectBaseline.packages.tsgo,
-	acceptedEffectBaseline.packages.nativeTypescript,
-	acceptedEffectBaseline.packages.typescript
-].map((entry) => ({
-	id: entry.id,
-	packageName: entry.packageName,
-	range: entry.range,
-	section: entry.target.defaultSection
-}));
-const deliveryToolRequirements = [
-	{
-		id: "eslint",
-		packageName: "eslint",
-		range: "^10.3.0",
-		section: "devDependencies"
-	},
-	{
-		id: "antfu-eslint-config",
-		packageName: "@antfu/eslint-config",
-		range: "^9.0.0",
-		section: "devDependencies"
-	},
-	{
-		id: "vitest-runner",
-		packageName: "vitest",
-		range: "^4.1.8",
-		section: "devDependencies"
-	}
-];
-function packageRootKey(packageRoot) {
-	return Buffer.from(packageRoot, "utf8").toString("hex");
-}
-function packageOutputs(packageRoot) {
-	return [{
-		kind: "JsonKeyedItem",
-		id: `effect.tsconfig.language-service.${packageRootKey(packageRoot)}`,
 		locator: {
-			root: "PackageRoot",
-			packageRoot,
-			path: "tsconfig.json"
+			root: "IntegrationWorkspace",
+			path: effectPin.targetPath
 		},
-		collectionPointer: "/compilerOptions/plugins",
-		keyField: "name",
-		keyValue: "@effect/language-service",
-		item: effectTsgoTargetProjection.languageServicePlugin
-	}];
-}
-function hasManifestDependency(manifest, section, packageName) {
-	const entries = manifest?.[section];
-	return typeof entries === "object" && entries !== null && !Array.isArray(entries) && typeof entries[packageName] === "string";
-}
-function selectedSection(manifest, packageName, fallback, peerFallback) {
-	if (hasManifestDependency(manifest, "dependencies", packageName)) return "dependencies";
-	if (hasManifestDependency(manifest, "devDependencies", packageName)) return "devDependencies";
-	if (hasManifestDependency(manifest, "peerDependencies", packageName)) return peerFallback;
-	return fallback;
-}
-function hasDeclaredDependency(manifest, packageName) {
-	return hasManifestDependency(manifest, "dependencies", packageName) || hasManifestDependency(manifest, "devDependencies", packageName) || hasManifestDependency(manifest, "peerDependencies", packageName);
-}
-function shouldPlanBaselinePackage(manifest, entry) {
-	return entry.target.presence === "required" || manifest === void 0 || hasDeclaredDependency(manifest, entry.packageName);
-}
-function requirementsFor(packageRoot, manifest) {
-	const rootKey = packageRootKey(packageRoot);
-	const runtime = acceptedEffectBaseline.packages.effect;
-	const platform = acceptedEffectBaseline.packages.platformNode;
-	const runtimeRequirements = [{
-		id: runtime.id,
-		packageName: runtime.packageName,
-		range: runtime.range,
-		section: selectedSection(manifest, runtime.packageName, runtime.target.defaultSection, runtime.target.peerFallbackSection)
-	}];
-	const platformSection = selectedSection(manifest, platform.packageName, platform.target.defaultSection, platform.target.peerFallbackSection);
-	const platformRequirements = shouldPlanBaselinePackage(manifest, platform) ? [{
-		id: platform.id,
-		packageName: platform.packageName,
-		range: platform.range,
-		section: platformSection
-	}] : [];
-	return [
-		...runtimeRequirements,
-		...platformRequirements,
-		...baselineDevRequirements,
-		...deliveryToolRequirements
-	].map((requirement) => ({
-		...requirement,
-		id: `effect.${requirement.id}.${rootKey}`,
-		packageRoot
-	}));
-}
-function checksFor(packageRoot) {
-	const rootKey = packageRootKey(packageRoot);
-	return [
-		{
-			id: `effect.typecheck.${rootKey}`,
-			summary: "Run strict Effect diagnostics",
-			packageRoot,
-			argv: ["pnpm", "typecheck"]
+		provenance: verifiedProvenance(effect_default, effectPin),
+		referenceOnly: true
+	}, {
+		kind: "PinnedReferenceTree",
+		id: tsgoPin.outputId,
+		archive: {
+			path: `artifact-assets/effect/reference-archives/${tsgoPin.publicationName}.pta`,
+			format: CANONICAL_TREE_ARCHIVE_FORMAT
 		},
-		{
-			id: `effect.lint.${rootKey}`,
-			summary: "Run Effect lint guardrails",
-			packageRoot,
-			argv: [
-				"pnpm",
-				"lint",
-				"--max-warnings",
-				"0"
-			]
+		locator: {
+			root: "IntegrationWorkspace",
+			path: tsgoPin.targetPath
 		},
-		{
-			id: `effect.verify.${rootKey}`,
-			summary: "Run Effect domain verification",
-			packageRoot,
-			argv: ["pnpm", "verify"]
-		}
-	];
-}
-function eslintIntegrationIssue(content) {
-	if (typeof content === "string") {
-		if (hasEffectHarnessEslintComposition(content)) return [];
-	}
-	return [{
-		id: "effect.eslint.integration",
-		summary: "Target ESLint config does not compose Effect Harness guardrails",
-		detail: "The target-owned eslint.config.mjs must import and include @sayoriqwq/effect-harness/eslint.",
-		evidence: content === void 0 ? "eslint.config.mjs is absent." : "eslint.config.mjs does not reference the stable Effect Harness ESLint export.",
-		guidance: "artifact-assets/effect/managed/docs/package-config.md"
-	}];
-}
-function hasEffectHarnessEslintComposition(content) {
-	const source = TypeScript.createSourceFile("eslint.config.mjs", content, TypeScript.ScriptTarget.Latest, false, TypeScript.ScriptKind.JS);
-	let antfuBinding = "";
-	for (const statement of source.statements) if (TypeScript.isImportDeclaration(statement) && TypeScript.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "@antfu/eslint-config") antfuBinding = statement.importClause?.name?.text ?? "";
-	for (const statement of source.statements) {
-		if (!TypeScript.isImportDeclaration(statement) || !TypeScript.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@sayoriqwq/effect-harness/eslint") continue;
-		const binding = statement.importClause?.name?.text ?? "";
-		if (binding.length > 0 && composesEslintBinding(source, binding, antfuBinding)) return true;
-	}
-	return false;
-}
-function composesEslintBinding(source, binding, antfuBinding) {
-	return source.statements.some((statement) => {
-		if (TypeScript.isExportAssignment(statement) === false) return false;
-		if (statement.isExportEquals === true) return false;
-		if (TypeScript.isArrayLiteralExpression(statement.expression)) return statement.expression.elements.some((element) => TypeScript.isSpreadElement(element) && TypeScript.isIdentifier(element.expression) && element.expression.text === binding) && !spreadsAntfuCall(statement.expression, antfuBinding);
-		return appendsEffectConfigToAntfu(statement.expression, binding, antfuBinding);
-	});
-}
-function spreadsAntfuCall(expression, antfuBinding) {
-	return antfuBinding.length > 0 && expression.elements.some((element) => TypeScript.isSpreadElement(element) && TypeScript.isCallExpression(element.expression) && TypeScript.isIdentifier(element.expression.expression) && element.expression.expression.text === antfuBinding);
-}
-function appendsEffectConfigToAntfu(expression, effectBinding, antfuBinding) {
-	if (antfuBinding.length === 0 || !TypeScript.isCallExpression(expression)) return false;
-	const append = expression.expression;
-	if (!TypeScript.isPropertyAccessExpression(append) || append.name.text !== "append") return false;
-	if (!TypeScript.isCallExpression(append.expression) || !TypeScript.isIdentifier(append.expression.expression) || append.expression.expression.text !== antfuBinding) return false;
-	return expression.arguments.some((argument) => TypeScript.isSpreadElement(argument) && TypeScript.isIdentifier(argument.expression) && argument.expression.text === effectBinding);
-}
+		provenance: verifiedProvenance(tsgo_default, tsgoPin),
+		referenceOnly: true
+	}]
+];
+/**
+* Read-only Effect Harness Module.
+*
+* Prelude converges only stable Harness-owned assets. Repository-specific
+* package, TypeScript, editor, lint, activation, and verification adaptation
+* begins after delivery through the managed Target Adaptation skill.
+*/
 const harnessModule = defineHarnessModule({
 	descriptor: {
 		harnessId: "effect-harness",
 		protocolVersion: MODULE_PROTOCOL_V2,
 		requiredFeatures: PRELUDE_V2_SUPPORTED_FEATURES
 	},
-	plan: (context) => Effect.gen(function* () {
-		const eslintConfig = yield* context.target.readText({
-			root: "ControlRoot",
-			path: "eslint.config.mjs"
-		});
-		const outputs = context.integration.packageRoots.flatMap(packageOutputs);
-		const requirements = (yield* Effect.forEach(context.integration.packageRoots, (packageRoot) => context.target.readPackageManifest(packageRoot).pipe(Effect.map((manifest) => requirementsFor(packageRoot, manifest))))).flat();
-		const checks = context.integration.packageRoots.flatMap(checksFor);
-		return {
-			outputs: [
-				managedTreeOutput,
-				routingOutput,
-				...pinnedReferenceOutputs,
-				...outputs,
-				...editorPolicyOutputs
-			],
-			requirements,
-			checks,
-			issues: eslintIntegrationIssue(eslintConfig)
-		};
+	plan: () => Effect.succeed({
+		outputs: stableHarnessOutputs,
+		requirements: [],
+		checks: [],
+		issues: []
 	})
 });
 //#endregion