opencode-effect-enforcer 0.2.5 → 0.2.8

package/docs/effect-4.0.0-rc.116.md

@@ -0,0 +1,102 @@
+# Effect 4.0.0-rc.112 → 4.0.0-rc.116
+
+## Provenance and release scope
+
+- Previous dependency: `effect@4.0.0-rc.112`.
+- Target: `effect@4.0.0-rc.116`, npm's `rc` dist-tag checked on 2026-09-18.
+- npm's `latest` tag is the separate v3 line (`3.22.2`).
+- Exact source: [`effect@4.0.0-rc.116`](https://github.com/Effect-TS/effect/tree/effect%404.0.0-rc.116), commit `d62dd0d65252e5d3635538f0e41adc7c08aa9beb`.
+- [Complete source comparison](https://github.com/Effect-TS/effect/compare/effect%404.0.0-rc.112...effect%404.0.0-rc.116).
+- [Full upstream release notes](effect-4.0.0-rc.116-changelog.md): 121 complete release sections across 31 packages, including dependency-only entries.
+
+The interval includes rc.113, rc.114, rc.115, and rc.116. The changelog collection
+was checked section-by-section against every package `CHANGELOG.md` at the target
+tag. No upstream entry in that interval was omitted. Later releases supersede
+earlier changes; notably PostgreSQL timestamp decoding and unknown-OID behavior
+are documented using the final rc.116 contract.
+
+## Changes applied
+
+| Area | Alignment |
+| --- | --- |
+| Dependency and baseline | Pin Effect and lockfile to rc.116; update README and privileged baseline references. |
+| Config and CLI | PascalCase scalar constructors, explicit Boolean defaults, typed arrays/records and ByteSize configuration. Update secret-config detector and fixtures. |
+| Schema | Effectful transformations, standalone Getter combinators, native Arbitrary, parse options, class identity, revivers, AST contracts, template literals, JSON Schema and compilation. |
+| Socket | Scoped pull readers, batched values, Writer objects, typed closure, backpressure, TLS/STARTTLS, addresses, framing, and reconnect ownership. |
+| RPC and cluster | Replace MessagePack recommendations with SchemaBinary; preserve transport framing rules and codec selection; use cluster option `serialization: 'binary'`. |
+| Filesystem and HTTP | ByteSize counts versus numeric buffer lengths and bigint seek offsets; HTTP schemas in Schema; NetAddress, eager web-handler construction, file/range responses, upgrades, parsing and SSE options. |
+| PostgreSQL | Native PgConnection/PgPool, explicit JSON binding, preparation, registry codecs, final row representations, scoped notification queues, startup and TLS behavior. |
+| AI and MCP | Branded service interfaces, opaque/encoded parameter modes, failure-result codecs/origins, DecisionModel, protocol adapters, strict tools, instructions, prompt titles, and stderr logging. |
+| Streams and atoms | Lazy scan seeds, partition ordering/capacity, mapBoth names, targeted error handling, middleware errors, zero TTL, reactivity branding and dehydration. |
+| Lifetimes and scheduling | Cache TTL by Exit, LayerMap acquisition errors, observer error types, process cleanup, timeout fallback lifetime, repeat metadata, rate-limiter store contract, durable queue policy. |
+| Testing | Native Arbitrary sampling/property checks; adapter peer/runtime requirements; compiler-checked migration examples. |
+| Writing | Remove release-qualified behavior from live skills, patterns, and guidance; retain version history here and in upstream release notes. |
+
+## Content audit inventory
+
+The audit covered all 53 bundled skill directories (54 Markdown files), all 45
+pattern definitions, all four guidance documents, and the runtime source.
+Removed public exports were compared between the exact old and new tags and
+searched across the complete live content tree. Targeted scans also covered
+lowercase Config/CLI constructors, callback sockets, MessagePack, fast-check,
+service interface names, Stream scans, and filesystem sizes.
+
+The following grouping records every skill directory; unchanged skills were
+included in the compatibility scans rather than edited merely to mark an audit.
+
+| Skill directories (`effect-` prefix omitted) | Review focus |
+| --- | --- |
+| schema-v4, schema-composition, domain-modeling, domain-predicates, pattern-matching, optics | Schema syntax, transformations, predicates, tagged unions and issue contracts. |
+| config, cli | Constructor renames, defaults, prompts, collection configuration and secrets. |
+| socket, filesystem, path, platform-abstraction, platform-layers, command-executor | Platform boundaries, scoped I/O, byte counts, address types and process lifetime. |
+| http-api, http-client, http-server | HTTP schemas, parsing, server construction, transport errors, files, SSE and WebSocket upgrades. |
+| rpc-api, rpc-client, rpc-server, rpc-cluster | Schema-aware serialization, framing, cluster defaults, storage and peer compatibility. |
+| ai-chat, ai-language-model, ai-prompt, ai-provider, ai-streaming, ai-tool, mcp-server | Service types, provider responses, tool failures, decisions and MCP contracts. |
+| atom-rpc, atom-state, react-composition | RPC/HTTP error channels, TTL, stream scan, React peer and reactive service contracts. |
+| cache, batching, layer-design, scope, service-implementation, context-witness, managed-runtime, incremental-migration | Cached acquisition, service/layer patterns, resource ownership and runtime boundaries. |
+| fiber, parallelization, concurrency-testing, pubsub-event-bus, stream, scheduling | Structured concurrency, stream operators, timing, retry and test synchronization. |
+| testing, error-handling, observability, wide-events | Native property generation, error surfaces, logger configuration and instrumentation. |
+| sql, workflow, graph, typeclass-design | Native database adapters, durable processing, graph and dual-helper compatibility. |
+
+Patterns requiring content changes were `avoid-process-env`,
+`prefer-redacted-config`, `avoid-direct-tag-checks`, `context-tag-extends`, and
+`require-effect-concurrency`. The secret-config detector recognizes
+`Config.String` and `Config.NonEmptyString`; its examples and regression cases
+use the supported constructors. Bidirectional pattern/test inventory and README
+catalog coverage remain required checks.
+
+The active guidance baseline and examples were updated. Historical essays and
+the earlier rc.112 audit retain their historical context.
+
+## Compatibility decisions
+
+- Keep directly consumed Effect-family packages on compatible release versions.
+  This package directly depends only on `effect`; companion adapters are teaching
+  material, not additional runtime dependencies.
+- `@effect/vitest` requires Vitest `>=5.0.0 <6.0.0` and Node
+  `^22.12.0 || ^24.0.0 || >=26.0.0`. This repository uses plain Vitest 3 and does
+  not install that adapter; its own runner therefore remains unchanged.
+- SchemaBinary is a wire/persistence format change, not a transparent replacement
+  for existing MessagePack bytes. Coordinate peers and stored-data migration.
+- Native PostgreSQL is a driver change. Validate row decoding, custom OIDs,
+  preparation/pooler settings and notification recovery at consuming boundaries.
+- The source reference's moving main branch is not the baseline. The exact tag
+  takes precedence when source and prose disagree.
+
+## Verification
+
+- Changelog completeness: all 121 selected upstream sections matched the collected
+  text across 31 package changelogs.
+- Removed-export scan: no old-only qualified public Effect symbols remain in
+  skills, patterns, guidance or runtime source.
+- `bun run check`: passed formatting, lint (zero warnings/errors) and TypeScript
+  compilation.
+- `bun run test`: passed all 912 tests in 53 files, including detector cases,
+  inventory/catalog coverage, runtime tests and marked Markdown example
+  compilation against installed rc.116.
+- `git diff --check`: passed.
+
+The documentation compiler checks explicitly marked, independent TypeScript
+fences. It does not execute every illustrative fragment or verify integrations
+against live databases/providers. Companion-package examples were reviewed
+against tagged source rather than adding all companion dependencies here.

package/guidance/effect-first-development.md

@@ -2,9 +2,9 @@
 
 This document defines the working model behind Effect-first code using the Effect v4 ecosystem.
 
-Bundled baseline: **Effect 4.0.0-rc.112**. Check the consuming project's installed
+Bundled baseline: **Effect 4.0.0-rc.116**. Check the consuming project's installed
 version and inspect the matching upstream release tag before using newer APIs.
-The release changelog and migration audit are in `docs/effect-4.0.0-rc.112.md`.
+The release changelog and migration audit are in `docs/effect-4.0.0-rc.116.md`.
 Source paths below are relative to the Effect source reference; locate symbols
 by name rather than relying on line numbers or a particular tool name.
 
@@ -46,6 +46,8 @@ At boundaries:
 
 ## Laws and Conventions
 
+Keep types sound: no `any`, type assertions, `@ts-ignore`, or non-null assertions.
+
 ### EF-1: Errors are data, not side effects
 
 - If logic can fail, return `Effect.Effect<A, E, R>` with a typed error `E`.
@@ -103,8 +105,9 @@ const toDisplayName = (rawName: string | null | undefined) =>
 
 - Unknown or external data must be decoded at the boundary.
 - Prefer `Schema.decodeUnknownEffect` for effectful paths and `Schema.decodeUnknownSync` only where sync failure handling is explicit.
-- Never use `JSON.parse` / `JSON.stringify`; use schema JSON codecs (`Schema.fromJsonString`, `Schema.decodeUnknown*`, `Schema.encode*`). For unknown JSON, use `Schema.fromJsonString(Schema.Unknown)`.
 - Prefer `Schema.Class` over `Schema.Struct` for all decoded shapes — including HTTP response bodies, API payloads, and ephemeral wire formats, not just domain models. Named `Schema.Class` types enable `instanceof` discrimination (e.g., `Schema.Union([SuccessResponse, ErrorResponse])` then `if (parsed instanceof ErrorResponse)`), which is compile-time safe.
+- Use `Schema.Class` for shapes discriminated via `instanceof` or participating in a `Schema.Union`.
+- Prefer schema constructors over plain `type` / `interface` for property-based domain shapes; derive types from schemas rather than maintaining parallel models. Keep plain types for shapes schema cannot represent cleanly, such as complex type-level transforms, utility types, and overload-only surfaces.
 - Do not name schemas with a `Schema` suffix; schema constants should be named after the domain type.
 - For non-class schemas, export type aliases with the same identifier name as the schema value.
 
@@ -143,6 +146,7 @@ export const decodeCreateTaskInput =
 ### EF-5: Effect modules over native collection helpers
 
 - Use `Arr`, `R`, `Str`, `Eq`, `HashMap`, `HashSet`, `MutableHashMap`, `MutableHashSet`.
+- Sort with `Arr.sort(values, order)` and explicit `effect/Order` values (`Order.String`, `Order.Number`, `Order.mapInput`, etc.), never native array `.sort()`.
 - Avoid domain usage of native `Object`, `Map`, `Set`, `Date`, and direct native string helpers.
 - Do not use imperative `for` / `for...of` loops in domain code. Use `Arr.map`, `Arr.filter`, `Arr.filterMap`, or `Arr.reduce` for pure transformations. For effectful iteration, use `Effect.forEach` (which also supports concurrency).
 - When behavior is unchanged, prefer the tersest helper form: direct helper refs over trivial wrapper lambdas, `flow(...)` over passthrough `pipe(...)` callbacks, and shared thunk helpers when already in scope.
@@ -206,7 +210,6 @@ const summarizeAttempts = (attempts: ReadonlyArray<number>) =>
 
 ### EF-8: Services use explicit tags + `Layer`
 
-- Service identity comes from a unique string key.
 - Honor a current Effect service-tag style already standardized by the project; otherwise default to `Context.Service`.
 - Service constructors are explicit and layered.
 - Dependency wiring happens in Layer composition, not hidden global state.
@@ -276,14 +279,6 @@ export const TenantHeader = Tenant.annotate({
 export type Tenant = typeof Tenant.Type;
 ```
 
-### EF-12b: Schema-first internal domain building blocks
-
-- If an intermediate domain concept is named, reused, matched on, or structurally validated, model it as a schema first instead of an ad-hoc boolean helper.
-- Prefer built-in schema constructors/checks such as `Schema.NonEmptyString`, `Schema.NonEmptyArray`, `Schema.TupleWithRest`, `Schema.Union`, `Schema.isPattern`, and `Schema.isIncludes` before reaching for `Schema.makeFilter`.
-- Derive domain guards with `Schema.is(SomeSchema)`.
-- If an internal literal domain needs type guards, use `Schema.is(Schema.Literal(...))`. For exhaustive matching over literals, use `Match`. For annotation-bearing schema values, use `Schema.Literal(...).annotate({...})`.
-- Prefer named intermediate schemas; export and document them when reusable or when they materially clarify the module’s domain model, otherwise keep them module-local.
-
 ### EF-12c: Reusable schema checks carry metadata
 
 - Reusable `Schema.makeFilter`, `Schema.makeFilterGroup`, and reusable built-in check blocks must include `identifier`, `title`, and `description`.
@@ -296,7 +291,7 @@ export type Tenant = typeof Tenant.Type;
 - Prefer `Schema.Class` for tagged union member schemas.
 - Use `Schema.TaggedUnion` only for canonical `_tag` object-union construction.
 - Reference: `packages/effect/SCHEMA.md`, sections `TaggedUnion` and `toTaggedUnion`.
-- In rc.112, both union forms offer `matchOrElse` for partial matching with a typed fallback. Prefer `match` when every variant must be handled separately. `toTaggedUnion` narrows fallback input to unmatched variants; direct `Schema.TaggedUnion` types it as the full union.
+- Both union forms offer `matchOrElse` for partial matching with a typed fallback. Prefer `match` when every variant must be handled separately. `toTaggedUnion` narrows fallback input to unmatched variants; direct `Schema.TaggedUnion` types it as the full union.
 
 Example:
 
@@ -420,6 +415,12 @@ const pollInterval = Duration.millis(250);
 const program = Effect.sleep(pollInterval).pipe(Effect.timeout(timeout));
 ```
 
+### EF-16b: Byte counts use `ByteSize`
+
+Use `ByteSize` and `ByteSize.Input` for byte counts and storage/network limits.
+Keep signed seek offsets as `bigint`. Parse external size strings before passing
+them to APIs, and preserve exact counts rather than coercing them to numbers.
+
 ### EF-17: Nullable/nullish schema fields should decode to `Option`
 
 - Use dedicated schema helpers for optional/null conversions:
@@ -467,7 +468,7 @@ const b = pipe('value', addPrefix('p:'));
 
 ### EF-19: JSON parse/stringify must use Schema
 
-- Use `Schema.fromJsonString(Schema.Unknown)` for unknown JSON payloads. `Schema.UnknownFromJsonString` is internal as of beta.103.
+- Use `Schema.fromJsonString(Schema.Unknown)` for unknown JSON payloads.
 - Use `Schema.fromJsonString(MySchema)` for typed JSON string boundaries.
 - Avoid direct `JSON.parse` / `JSON.stringify` in Effect-first code.
 - Reference: [`fromJsonString`](packages/effect/src/Schema.ts) in the Effect v4 source.
@@ -498,6 +499,7 @@ You are not done if these fail:
 
 ### EF-21: Runtime execution stays at the boundary
 
+- Runtime source uses Effect `FileSystem`, `Path`, and process services instead of `node:fs`, `node:path`, or `node:child_process`.
 - Application entrypoints and tests may execute effects with `Effect.run*`.
 - Library and domain exports should return `Effect` values.
 - Keep runtime execution in one place so wiring, logging, and lifecycle behavior stay auditable.
@@ -540,7 +542,7 @@ const readSdkValue = (client: ExternalSdk) =>
 - Prefer `Effect.scoped` for helper composition that allocates resources.
 - Do not manually open resources without an explicit finalization strategy.
 - Reference: `acquireUseRelease` and `scoped` in `packages/effect/src/Effect.ts`.
-- For pool checkouts in rc.112 use `Pool.use(pool, callback)` to return the item on every exit without adding a caller `Scope` requirement. Do not return an item from `Effect.scoped(Pool.get(pool))` and then use it after release.
+- For pool checkouts use `Pool.use(pool, callback)` to return the item on every exit without adding a caller `Scope` requirement. Do not return an item from `Effect.scoped(Pool.get(pool))` and then use it after release.
 
 Example:
 
@@ -615,7 +617,7 @@ const runWithHeartbeat = Effect.fn('Worker.run')(function* () {
 - For non-trivial fan-out, set concurrency in `Effect.forEach`, `Effect.all`, or `Effect.validate`.
 - Avoid implicit unbounded parallelism on large collections.
 - Concurrency should be part of API intent for throughput-sensitive paths.
-- Use an explicit number or `"unbounded"`. The `"inherit"` option and `Effect.withConcurrency` were removed in beta.102.
+- Use an explicit number or `"unbounded"`; pass concurrency policy directly to each combinator.
 - Reference: `Effect.forEach`, `Effect.all`, and `Types.Concurrency` in the Effect v4 source.
 
 Example:
@@ -640,16 +642,16 @@ Example:
 import { Config, Effect } from 'effect';
 
 const loadPort = Effect.fn('Config.loadPort')(function* () {
-	return yield* Config.int('PORT');
+	return yield* Config.Int('PORT');
 });
 ```
 
 ### EF-29: Secrets must stay redacted
 
-- Use `Config.redacted` for secret config values.
+- Use `Config.Redacted` for secret config values.
 - Use `Redacted.make` for sensitive values coming from non-config sources.
 - Never log secret values after unwrapping.
-- Reference: `Config.redacted` in `packages/effect/src/Config.ts` and `packages/effect/src/Redacted.ts`.
+- Reference: `Config.Redacted` in `packages/effect/src/Config.ts` and `packages/effect/src/Redacted.ts`.
 
 Example:
 
@@ -657,7 +659,7 @@ Example:
 import { Config, Effect } from 'effect';
 
 const loadApiKey = Effect.fn('Config.loadApiKey')(function* () {
-	const apiKey = yield* Config.redacted('API_KEY');
+	const apiKey = yield* Config.Redacted('API_KEY');
 	yield* Effect.logDebug(`apiKey=${String(apiKey)}`);
 	return apiKey;
 });
@@ -733,30 +735,6 @@ const runIsolated = program.pipe(
 );
 ```
 
-### EF-33: Schema-first development for domain models
-
-- If a data shape is decoded from external input, will be discriminated via `instanceof`, or participates in a `Schema.Union`, define it as `Schema.Class` first — regardless of whether it is a "domain model" or an ephemeral HTTP response shape.
-- Prefer `Schema.Class` (or another schema constructor) over plain `type` / `interface` for property-based domain shapes.
-- Derive runtime types from schema definitions instead of duplicating parallel `type` / `interface` models.
-- Keep plain `type` / `interface` for cases schema cannot represent cleanly (complex type-level transforms, utility types, overload-only surfaces).
-
-Example:
-
-```ts
-import * as Schema from 'effect/Schema';
-
-// Prefer schema-first over plain interfaces for domain payloads.
-export class CreateOrderInput extends Schema.Class<CreateOrderInput>(
-	'CreateOrderInput'
-)(
-	{
-		orderId: Schema.String,
-		customerId: Schema.String
-	},
-	{ description: 'Input payload for creating an order.' }
-) {}
-```
-
 ### EF-34: Schema defaults over fallback object logic
 
 - Put defaults in schema definitions, not in handler/service fallback object literals.
@@ -764,6 +742,8 @@ export class CreateOrderInput extends Schema.Class<CreateOrderInput>(
 - Use `Schema.withDecodingDefault` / `Schema.withDecodingDefaultKey` for decode-time defaults.
 - Constructor defaults may fail with `SchemaIssue.Issue`. Likewise, `MySchema.makeEffect(fields)` returns validation failures directly as `SchemaIssue.Issue`, not wrapped in `Schema.SchemaError`.
 - Constructor defaults (including `Schema.tag`) do not automatically apply during boundary decoding. Unknown input uses `Schema.decodeUnknownEffect`; `decodeSync` is not a constructor replacement.
+- Class `make`, `makeOption`, and `makeEffect` preserve an existing instance. Use `new` when a distinct instance is intended.
+- Pass parsing options to the decoder/encoder/constructor adapter. Model retained extra properties with `Record` or `StructWithRest`; use `onExcessProperty: "error"` for closed boundaries.
 
 Example:
 
@@ -792,10 +772,10 @@ export class VersionSyncOptions extends Schema.Class<VersionSyncOptions>(
 
 - If a guard validates domain strings/paths/tags, define a branded schema and use `Schema.is(...)`.
 - If a domain constraint is named, reused, matched on, or structurally validated, model it as a schema first rather than a forest of ad-hoc predicate helpers.
-- Prefer built-in schema constructors/checks before `Schema.makeFilter`.
+- Prefer built-in schema constructors/checks such as `Schema.NonEmptyString`, `Schema.NonEmptyArray`, `Schema.TupleWithRest`, `Schema.Union`, `Schema.isPattern`, and `Schema.isIncludes` before `Schema.makeFilter`.
 - Keep guard intent and reusable check intent in schema annotations and check metadata.
 - For internal literal domains, use `Schema.is(Schema.Literal(...))` for type guards, `Match` for exhaustive matching, and `Schema.Literal(...).annotate({...})` for annotated schema values.
-- Prefer named intermediate schemas; export them only when reusable or when they materially clarify the module's domain model.
+- Prefer named intermediate schemas; export and document them when reusable or when they materially clarify the module's domain model, otherwise keep them module-local.
 - Propagate branded schema types through the persistence layer (e.g., ORM column types: `text().$type<AccessToken>()`) to enforce compile-time safety across the entire stack and prevent parameter-swapping bugs.
 
 Example:
@@ -925,6 +905,7 @@ const arraysEqual = (
 
 - If conversion is deterministic and type-shaping (path normalization, filename conversion, tagged-string normalization), model it with `Schema.decodeTo(..., SchemaTransformation.transform(...))`.
 - Prefer schema transformation helpers over ad-hoc conversion functions.
+- Use `SchemaGetter.transformEffect` / `SchemaTransformation.transformEffect` for effectful conversion. Compose getters with standalone `SchemaGetter.compose`, and transformation pairs with `SchemaTransformation.composeTransformation`.
 
 Example:
 
@@ -946,25 +927,6 @@ const NativePathToPosixPath = Schema.String.pipe(
 );
 ```
 
-### EF-38: Never use native array sort in Effect-first code
-
-- Use `Arr.sort(values, order)` from `effect/Array`.
-- Define ordering with `effect/Order` (`Order.String`, `Order.Number`, `Order.mapInput`, etc.).
-- Do not call native `.sort()` directly on arrays.
-
-Example:
-
-```ts
-import { Order } from 'effect';
-import * as Arr from 'effect/Array';
-
-const byName = Order.mapInput(
-	Order.String,
-	(item: { readonly name: string }) => item.name
-);
-const sorted = Arr.sort(items, byName);
-```
-
 ### EF-39: Avoid ad-hoc `String(...)` coercion for domain comparisons
 
 - When unknown/scalar data must normalize to domain strings, model the conversion with schema transformations.
@@ -994,7 +956,7 @@ const UnknownToString = Schema.Unknown.pipe(
 - For invalidatable caches, use `Effect.cachedInvalidateWithTTL(effect, Duration.infinity)` which returns a `[cachedEffect, invalidate]` tuple. Call `yield* invalidate` to force re-computation on next access.
 - For time-based caches, use `Effect.cachedWithTTL(effect, duration)`.
 - Prefer `Effect.cachedInvalidateWithTTL` with `Duration.infinity` over mutable `let` rebinding of cached effects.
-- For keyed scoped resources, rc.112 adds `RcMap.getOption` and `LayerMap.contextEffectOption`. They atomically retain already-cached entries and propagate acquisition failures; `None` means missing/closed, not failed. A `has` check followed by `get` is not equivalent.
+- For keyed scoped resources, use `RcMap.getOption` and `LayerMap.contextEffectOption` to atomically retain already-cached entries and propagate acquisition failures; `None` means missing/closed, not failed. A `has` check followed by `get` is not equivalent.
 
 Example:
 
@@ -1013,248 +975,3 @@ const [cachedConfig, invalidate] =
 	);
 // Later: yield* invalidate to force reload on next access
 ```
-
-## Copy-Paste Templates
-
-### Template: Tagged error
-
-```ts
-import * as Schema from 'effect/Schema';
-
-class DomainError extends Schema.TaggedError<DomainError>()(
-	'DomainError',
-	{
-		message: Schema.String
-	},
-	{ description: 'Domain failure' }
-) {}
-```
-
-### Template: Safe nullable boundary conversion
-
-```ts
-import { pipe } from 'effect';
-import * as Option from 'effect/Option';
-
-const fromNullableName = (name: string | null | undefined) =>
-	pipe(
-		Option.fromNullishOr(name),
-		Option.filter((value) => value.length > 0)
-	);
-```
-
-### Template: Decode unknown at API edge
-
-```ts
-import * as Schema from 'effect/Schema';
-
-export class Payload extends Schema.Class<Payload>('Payload')({
-	query: Schema.String
-}) {}
-
-const decodePayload = Schema.decodeUnknownEffect(Payload);
-```
-
-### Template: Schema naming + type alias (no `Schema` suffix)
-
-```ts
-import * as Schema from 'effect/Schema';
-
-export const OrderId = Schema.String;
-export type OrderId = typeof OrderId.Type;
-```
-
-### Template: Schema-first replacement for interface
-
-```ts
-import * as Schema from 'effect/Schema';
-
-export class UserProfile extends Schema.Class<UserProfile>('UserProfile')(
-	{
-		id: Schema.String,
-		displayName: Schema.String
-	},
-	{ description: 'User profile model used in domain workflows.' }
-) {}
-```
-
-### Template: Match over switch
-
-```ts
-import { Match } from 'effect';
-import * as Arr from 'effect/Array';
-
-type Phase = 'draft' | 'running' | 'done';
-
-const phaseLabel = (phase: Phase) =>
-	Match.value(phase).pipe(
-		Match.when('draft', () => 'draft'),
-		Match.when('running', () => 'running'),
-		Match.when('done', () => 'done'),
-		Match.exhaustive
-	);
-
-const summarize = (items: ReadonlyArray<string>) =>
-	Arr.match(items, {
-		onEmpty: () => 'none',
-		onNonEmpty: (values) => `count:${Arr.length(values)}`
-	});
-```
-
-### Template: Effect-returning function constructor
-
-```ts
-import { Effect } from 'effect';
-
-export const runTask = Effect.fn('Task.run')(function* (taskId: string) {
-	yield* Effect.logInfo('run task', taskId);
-	return taskId;
-});
-```
-
-### Template: Option schema from nullish/optional
-
-```ts
-import * as Schema from 'effect/Schema';
-
-export class Input extends Schema.Class<Input>('Input')({
-	maybeName: Schema.OptionFromNullishOr(Schema.String),
-	maybeEmail: Schema.OptionFromOptionalKey(Schema.String)
-}) {}
-```
-
-### Template: Dual helper (data-first + data-last)
-
-```ts
-import { dual } from 'effect/Function';
-
-export const rename: {
-	(
-		to: string
-	): (self: { readonly name: string }) => { readonly name: string };
-	(self: { readonly name: string }, to: string): { readonly name: string };
-} = dual(2, (self, to) => ({ ...self, name: to }));
-```
-
-### Template: JSON boundary without native JSON APIs
-
-```ts
-import * as Schema from 'effect/Schema';
-
-export class Payload extends Schema.Class<Payload>('Payload')({
-	query: Schema.String
-}) {}
-
-const PayloadJson = Schema.fromJsonString(Payload);
-
-export const decodePayloadJson = Schema.decodeUnknownEffect(PayloadJson);
-export const encodePayloadJson = Schema.encodeUnknownEffect(PayloadJson);
-```
-
-### Template: Runtime boundary execution
-
-```ts
-import { Effect } from 'effect';
-
-export const buildReport = Effect.fn('Report.build')(function* () {
-	return 'ok';
-});
-
-// runtime boundary only
-// Effect.runPromise(buildReport())
-```
-
-### Template: Scoped resource helper
-
-```ts
-import { Effect } from 'effect';
-
-export const withResource = <A, E, R>(
-	use: (resource: Resource) => Effect.Effect<A, E, R>
-) => Effect.acquireUseRelease(acquireResource, use, releaseResource);
-```
-
-### Template: Retry + timeout
-
-```ts
-import { Duration, Effect, Schedule } from 'effect';
-
-export const resilientTask = task.pipe(
-	Effect.retry(Schedule.recurs(3)),
-	Effect.timeoutOption(Duration.seconds(5))
-);
-```
-
-### Template: Config + redacted secret
-
-```ts
-import { Config, Effect } from 'effect';
-
-export const loadConfig = Effect.fn('Config.load')(function* () {
-	const port = yield* Config.int('PORT');
-	const apiKey = yield* Config.redacted('API_KEY');
-	return { port, apiKey };
-});
-```
-
-### Template: Isolated layer provide
-
-```ts
-import { Effect, Layer } from 'effect';
-
-export const runIsolated = program.pipe(
-	Effect.provide(Layer.fresh(AppLayer), { local: true })
-);
-```
-
-## LLM Review Checklist
-
-Use this before submitting code:
-
-1. No `any`, no type assertions, no `@ts-ignore`, no non-null assertions.
-2. No untyped error throwing in domain logic.
-3. Nullish converted to `Option` at boundaries.
-4. Unknown input decoded with `Schema`.
-5. Canonical namespace imports (`Option`, `Schema`, `Arr`, `P`, `R`, etc.) present and used.
-6. No native `Object/Map/Set/Date/String` helpers in domain logic.
-7. Branching logic is exhaustive where appropriate (`Match.exhaustive`, schema `.match`, and `Arr.match` for array emptiness).
-8. No new schema constants end with `Schema`.
-9. For non-class schemas, new schema constants expose `export type X = typeof X.Type`.
-10. Schema annotations are used only where they materially improve docs, errors, or introspection.
-11. `Effect`-returning reusable functions are created with `Effect.fn`/`Effect.fnUntraced`.
-12. Critical flows include logs/spans/metrics instrumentation.
-13. Durations/time windows use `Duration` values.
-14. Nullish schema fields use `Schema.OptionFrom*` helpers when representing absence as `Option`.
-15. Exported helper combinators support dual API via `dual`.
-16. No `JSON.parse` / `JSON.stringify` in Effect-first domain paths.
-17. Prefer `Schema.Class` over `Schema.Struct` for all decoded shapes (domain models, HTTP responses, API payloads).
-18. Required verification commands are green.
-19. `Effect.run*` appears only in runtime boundaries (entrypoint/test harness).
-20. Promise-based APIs are lifted with `Effect.tryPromise`.
-21. Acquired resources use `Effect.acquireUseRelease` or `Effect.scoped`.
-22. Retries are declared with `Effect.retry` + `Schedule`.
-23. Timeouts use `Effect.timeoutOption` / `Effect.timeoutOrElse`.
-24. Forking intent is explicit (`forkChild` default; `forkDetach` justified).
-25. Large fan-out operations specify concurrency deliberately.
-26. Config values come from `Config` / `ConfigProvider`, not direct `process.env` in domain logic.
-27. Secrets are `Redacted` (`Config.redacted` / `Redacted.make`) and not logged raw.
-28. Recovery uses `catchTag` / `catchFilter` for targeted cases.
-29. Expected failures use `Effect.fail`; defects are reserved for invariants and discarding irrelevant upstream error types via `orDie`.
-30. Isolation-sensitive layer provisioning uses `{ local: true }` or `Layer.fresh`.
-31. All decoded shapes (domain models, HTTP responses, API payloads) are schema-first with `Schema.Class`; plain `type` / `interface` is used only when schema is not a practical fit.
-32. Literal-string discriminant unions use `Schema.Union` + `Schema.toTaggedUnion`. For exhaustive matching over literals, use `Match`. For type guards, use `Schema.is(Schema.Literal(...))`.
-33. Schema defaults use `Schema.withConstructorDefault` / `Schema.withDecodingDefault*`, not ad-hoc fallback objects in handlers/services.
-34. Named or reused domain constraints are modeled as schemas first; built-in schema constructors/checks are preferred before `Schema.makeFilter`.
-35. Guard helpers for domain strings/paths/tags come from branded schemas with `Schema.is(...)`, not ad-hoc `regex.test(...)` predicates.
-36. Reusable schema checks and filter groups carry `identifier`, `title`, and `description`.
-37. Intermediate schemas are exported only when reusable or materially clarifying; otherwise they stay module-local.
-38. Schema-modeled comparisons use `Schema.toEquivalence(...)` where practical.
-39. Deterministic format conversions use `Schema.decodeTo(..., SchemaTransformation.transform(...))`.
-40. Trivial helper wrapper lambdas are collapsed to direct helper refs where safe, and passthrough `pipe(...)` callbacks are expressed with `flow(...)`.
-41. Runtime source avoids `node:fs` / `node:path` / `node:child_process`; use Effect `FileSystem` / `Path` / process services.
-42. Runtime source avoids native `fetch`; HTTP boundaries use `effect/unstable/http` + platform layers (`BunHttpClient.layer`, etc.).
-43. Runtime sorting uses `Arr.sort` with explicit `Order`, not native `Array.prototype.sort`.
-44. Boolean branching prefers `Bool.match` over ad-hoc `if/else` when branching on booleans.
-45. HTTP request/response composition uses Effect HTTP modules (`HttpClientRequest`, `HttpClientResponse`, `Headers`, `UrlParams`, `HttpMethod`, `HttpBody`).
-46. Retried operations have proven idempotency, and exhausted failures remain visible unless a truthful fallback exists.
-47. Provider/network calls do not run inside authoritative database transactions.

package/guidance/progressive-disclosure-guidance.md

@@ -1,35 +1,21 @@
 # Agent Rules
 
-The bundled guidance targets **Effect 4.0.0-rc.112**. Read the consuming project's
+The bundled guidance targets **Effect 4.0.0-rc.116**. Read the consuming project's
 version before applying an API: stable v3, older prereleases, and unreleased main
 can have different contracts. Keep directly used Effect-family packages on
 compatible release versions.
 
-Load all relevant skills before writing or planning any code. Effect is a massive ecosystem — without loading skills you will write outdated v3 code or miss high-leverage libraries. Load AT LEAST 4 `effect-*` skills before any Effect work.
+Before planning or writing Effect code, load the skills relevant to the APIs involved.
+For other tasks, load a skill only when its guidance is needed to answer or complete the task.
 
 When skills leave any ambiguity, or when you encounter unfamiliar APIs during implementation, read the OpenCode `effect` reference at `~/.local/share/opencode/repos/github.com/Effect-TS/effect@main/`. Treat this reference as the source of truth over `node_modules`, stale external docs, or memory.
 
 Check the reference revision too. For this baseline, inspect the
-`effect@4.0.0-rc.112` tag (for example with `git show
-effect@4.0.0-rc.112:packages/effect/src/Schema.ts`) when main has moved ahead.
+`effect@4.0.0-rc.116` tag (for example with `git show
+effect@4.0.0-rc.116:packages/effect/src/Schema.ts`) when main has moved ahead.
 Source symbols and signatures at that tag take precedence over stale prose or
 line-number links. Public exports marked `@internal` in source are not application APIs.
 
-## Skill routing
-
-Load every branch that the task crosses:
-
-- Schemas, brands, variants, optionality, or decoding: `effect-schema-v4`, `effect-schema-composition`, and `effect-domain-modeling`.
-- Binary schema codecs and framed binary streams: `effect-schema-composition` and `effect-stream`; RPC serialization also needs `effect-rpc-client` / `effect-rpc-server`.
-- Services, layers, runtime wiring, or scoped lifetimes: `effect-service-implementation`, `effect-layer-design`, `effect-scope`, and `effect-fiber`.
-- Configuration or secrets: `effect-config`.
-- Retry, repeat, polling, backoff, pacing, or recurrence: `effect-scheduling` plus the relevant error, HTTP, or testing skill.
-- Memoization, keyed caches, or request batching: `effect-cache` and `effect-batching`.
-- Retained keyed resources or pooled checkout: `effect-cache`, `effect-layer-design`, and `effect-scope`.
-- Streams, queues, pubsubs, pagination, or backpressure: `effect-stream` and the relevant concurrency skill.
-- Outgoing HTTP: `effect-http-client` plus the relevant platform-layer skill.
-- Effect tests, virtual time, or concurrent synchronization: `effect-testing` and `effect-concurrency-testing`.
-
 ## Start here
 
 - `~/.local/share/opencode/repos/github.com/Effect-TS/effect@main/LLMS.md` — generated task-oriented guide for Effect v4, with links to examples.

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "opencode-effect-enforcer",
-  "version": "0.2.5",
+  "version": "0.2.8",
   "description": "OpenCode V2 plugin for Effect v4 skills, guidance, and pattern enforcement",
   "keywords": [
     "opencode",
@@ -46,7 +46,7 @@
     "@ast-grep/napi": "^0.42.3",
     "@opencode/plugin": "2.0.8",
     "diff": "^9.0.0",
-    "effect": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.116",
     "picomatch": "^4.0.3",
     "yaml": "^2.8.1"
   },

package/patterns/avoid-direct-tag-checks.md

@@ -55,6 +55,6 @@ TypeScript correctly narrows literal `_tag` checks. Prefer exported guards and
 matching helpers for consistent semantics and exhaustiveness as variants evolve.
 For schema-first models use union `.guards`, `.match`, or `Schema.is`; class
 variants can also use `instanceof`. `Schema.toTaggedUnion` supports discriminator
-keys beyond `_tag`. In rc.112, `.matchOrElse` adds partial matching with a typed
+keys beyond `_tag`. `.matchOrElse` provides partial matching with a typed
 fallback. For trusted `Data.taggedEnum` values use `$is` / `$match`; `$is` checks
 only the tag and is not structural validation of unknown input.