opencode-effect-enforcer 0.2.5 → 0.2.6

package/skills/effect-sql/SKILL.md

@@ -560,7 +560,7 @@ Effect SQL uses driver-specific packages that provide `SqlClient` layers.
 
 | Package                   | Database                             |
 | ------------------------- | ------------------------------------ |
-| `@effect/sql-pg`          | PostgreSQL (via `pg`)                |
+| `@effect/sql-pg`          | PostgreSQL (native Effect protocol client) |
 | `@effect/sql-pglite`      | Embedded PostgreSQL/PGlite           |
 | `@effect/sql-mysql2`      | MySQL (via `mysql2`)                 |
 | `@effect/sql-sqlite-node` | SQLite (via `better-sqlite3`)        |
@@ -591,14 +591,14 @@ const DatabaseLayer = PgClient.layer({
 
 // From Config (reads from environment/config provider)
 const DatabaseLayerConfig = PgClient.layerConfig({
-	url: Config.redacted('DATABASE_URL')
+	url: Config.Redacted('DATABASE_URL')
 });
 
 // The layer provides both PgClient and SqlClient services
 const program = Effect.gen(function* () {
 	const sql = yield* SqlClient; // generic interface
 	// or
-	const pg = yield* PgClient; // pg-specific (has .json(), .listen(), .notify())
+	const pg = yield* PgClient.PgClient; // PostgreSQL-specific service
 });
 
 const main = program.pipe(Effect.provide(DatabaseLayer));
@@ -606,10 +606,35 @@ const main = program.pipe(Effect.provide(DatabaseLayer));
 
 ### PgClient-Specific Features
 
-### Low-level PostgreSQL codecs (rc.112)
-
-`@effect/sql-pg` adds public `PgProtocol`, `PgTypes`, and `PgAuth` modules.
-These are building blocks for protocol adapters; `PgClient` still uses `pg`.
+### Native PostgreSQL client and codecs
+
+`PgClient` uses `PgConnection` and `PgPool` for native binary queries, prepared
+statements, pipelining, streaming, cancellation, and notifications. Use `make`
+for a pool or `makeClient` for one connection. `types` accepts a `PgTypes.Registry`.
+Bind JSON explicitly with `sql.json`, and send one statement per query string.
+Named preparation is enabled by default; set `prepare: false` for incompatible
+poolers, or use statement-level `unprepared` / `valuesUnprepared`.
+
+Decode rows according to the actual driver boundary: `int8` is `bigint`, `date`
+is a string, timestamps are `Date` (millisecond precision), and `bytea` is
+`Uint8Array`. Infinite/out-of-range timestamps decode to invalid Dates; validate
+before constructing domain instants. Timestamp encoders accept Date or epoch
+milliseconds; invalid Date encoding fails. A Date binds as `timestamptz`, so use
+UTC session time or `PgTypes.timestamp(value)` for UTC fields in a timestamp column.
+`executeRaw` returns `PgConnection.Result`.
+
+Unregistered OIDs decode as UTF-8 text, suitable for scalar enum labels but not
+arbitrary binary types. Register custom scalar/array codecs through
+`PgTypes.makeRegistry().register(elementOid, codec, { arrayOid })` and pass the
+registry as `types`. Decode failures close the connection and fail pending work.
+`inet` uses `IpInterface`; `cidr` uses `IpNetwork` and rejects host bits.
+
+Use structured `startupParameters` and opaque `startupOptions` for per-connection
+session defaults. Passwords may be infallible, service-free Effects reevaluated
+per physical connection. `sslmode=prefer` and `allow` try TLS first and fall back
+only when the server declines SSLRequest; handshake/certificate failures remain
+fatal. Explicit SSL options take precedence. `maxMessageSize` defaults to 16 MiB;
+when multiplexing is enabled, `multiplexConcurrency` defaults to 32.
 
 - `PgProtocol`: PostgreSQL 3.0 frontend encoding and incremental backend-frame
   parsing. Stateful parser failures are terminal and synchronous; lift a parser
@@ -629,16 +654,29 @@ keep the Effect-family package versions aligned when upgrading those adapters.
 ### PgClient JSON and Notifications
 
 ```ts
-const pg = yield* PgClient;
+const pg = yield* PgClient.PgClient;
 
 // JSON parameter helper
 sql`INSERT INTO data ${sql.insert({ metadata: pg.json({ key: 'value' }) })}`;
 
 // LISTEN/NOTIFY
-const notifications = pg.listen('my_channel'); // Stream<string, SqlError>
+const notifications = yield* pg.listen('my_channel'); // scoped Dequeue<string, SqlError>
 yield* pg.notify('my_channel', 'hello');
+const messages = Stream.fromQueue(notifications);
 ```
 
+Listener acquisition completes after registration, giving an explicit readiness
+boundary. PostgreSQL listener queues carry `SqlError` when the connection fails;
+retry a scoped effect that reacquires the listener, not the failed queue. Intentional
+scope closure interrupts consumers. PGlite also returns a scoped notification dequeue.
+
+`SqlModel.makeResolvers().insert` requires both input encoding and row decoding
+services; `insertVoid` needs only input encoding services. D1 statement `.raw`
+returns the complete native result; read `.results` for rows. Durable Object SQL
+transactions support nested child rollback but no explicit async operations inside
+the transaction. Use `Statement.SpanPropagationEnabled` to opt into driver span
+parenting under `sql.execute`.
+
 ### PGlite Setup
 
 Use `@effect/sql-pglite` for embedded PostgreSQL-compatible databases backed by `@electric-sql/pglite`. Its layer provides both the PGlite-specific service and the generic `SqlClient` service.
@@ -654,7 +692,7 @@ const PgliteLayer = PgliteClient.layer({
 });
 
 const PgliteLayerConfig = PgliteClient.layerConfig({
-	dataDir: Config.string('PGLITE_DATA_DIR')
+	dataDir: Config.String('PGLITE_DATA_DIR')
 });
 
 const program = Effect.gen(function* () {
@@ -662,7 +700,7 @@ const program = Effect.gen(function* () {
 	const pglite = yield* PgliteClient.PgliteClient;
 
 	yield* sql`INSERT INTO data ${sql.insert({ metadata: pglite.json({ key: 'value' }) })}`;
-	const notifications = pglite.listen('my_channel');
+	const notifications = yield* pglite.listen('my_channel');
 	yield* pglite.notify('my_channel', 'hello');
 	yield* pglite.refreshArrayTypes;
 	const snapshot = yield* pglite.dumpDataDir('gzip');
@@ -704,7 +742,7 @@ yield*
 		Stream.runCollect
 	);
 
-// Chunked streaming (driver-dependent, e.g. pg uses cursor with 128-row chunks)
+// Streaming uses the driver's bounded result batching.
 ```
 
 ## Error Handling

package/skills/effect-stream/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: effect-stream
-description: Build effectful pull-based streaming pipelines with Effect Stream — creation, transformation, consumption, NDJSON/Msgpack encoding, concurrency, resource safety. Use when working with values produced over time, paginated APIs, event listeners, or streaming I/O.
+description: Build effectful pull-based streaming pipelines with Effect Stream — creation, transformation, consumption, NDJSON/SchemaBinary encoding, concurrency, resource safety. Use when working with values produced over time, paginated APIs, event listeners, or streaming I/O.
 ---
 
 You are an Effect TypeScript expert specializing in pull-based streaming with `Stream`, `Sink`, and `Channel`.
@@ -15,7 +15,7 @@ Reference this for:
 - Stream constructors and combinators (`packages/effect/src/Stream.ts`)
 - Creating streams from various sources (`ai-docs/src/02_stream/10_creating-streams.ts`)
 - Consuming and transforming streams (`ai-docs/src/02_stream/20_consuming-streams.ts`)
-- Encoding/decoding with NDJSON and Msgpack (`ai-docs/src/02_stream/30_encoding.ts`)
+- Encoding/decoding with NDJSON and SchemaBinary (`packages/effect/src/unstable/encoding/`)
 
 ## Core Model
 
@@ -25,7 +25,7 @@ Use a stream when values are naturally many-valued and ordered over time. For on
 
 ```ts
 import { Effect, Schedule, Schema, Sink, Stream } from 'effect';
-import { Ndjson, Msgpack } from 'effect/unstable/encoding';
+import { Ndjson, SchemaBinary } from 'effect/unstable/encoding';
 ```
 
 For Node.js readable streams:
@@ -249,11 +249,11 @@ Stream.make('US', 'CA', 'NZ').pipe(
 ```ts
 // Running accumulator — emits initial state plus each accumulated state
 // Output: [0, 1, 3, 6]
-Stream.make(1, 2, 3).pipe(Stream.scan(0, (acc, n) => acc + n));
+Stream.make(1, 2, 3).pipe(Stream.scan(() => 0, (acc, n) => acc + n));
 
 // Effectful variant
 Stream.make(1, 2, 3).pipe(
-	Stream.scanEffect(0, (acc, n) => Effect.succeed(acc + n))
+	Stream.scanEffect(() => 0, (acc, n) => Effect.succeed(acc + n))
 );
 ```
 
@@ -355,15 +355,15 @@ stream.pipe(
 
 ---
 
-## 4. Encoding & Decoding (NDJSON / Msgpack / SchemaBinary)
+## 4. Encoding & Decoding (NDJSON / SchemaBinary)
 
 Use `Stream.pipeThroughChannel` with codec channels from `effect/unstable/encoding`.
 
 ```ts
-import { Ndjson, Msgpack } from 'effect/unstable/encoding';
+import { Ndjson, SchemaBinary } from 'effect/unstable/encoding';
 ```
 
-### Schema-derived binary frames (rc.112)
+### Schema-derived binary frames
 
 <!-- typecheck -->
 ```ts
@@ -446,20 +446,8 @@ objectStream.pipe(Stream.pipeThroughChannel(Ndjson.encode())); // objects → Ui
 Stream.pipeThroughChannel(Ndjson.decodeString({ ignoreEmptyLines: true }));
 ```
 
-### Msgpack
-
-Same API shape — replace `Ndjson` with `Msgpack`. Note that `Msgpack.decodeSchema(schema)` is curried: it returns a factory you must invoke (`()`) to get the `Channel` value passed to `Stream.pipeThroughChannel`, exactly like the NDJSON schema helpers.
-
-```ts
-const decoder = Msgpack.decodeSchema(
-	Schema.Struct({
-		id: Schema.Number,
-		name: Schema.String
-	})
-)();
-
-binaryStream.pipe(Stream.pipeThroughChannel(decoder), Stream.runCollect);
-```
+Use SchemaBinary for a schema-derived binary contract and NDJSON for JSON
+interoperability. Both peers must agree on the wire format and schema.
 
 ### Realistic pipeline: decode → transform → re-encode
 
@@ -545,6 +533,13 @@ stream.pipe(Stream.orElseSucceed((error) => defaultValue));
 
 Prefer natural backpressure. Add `Stream.buffer` only to deliberately decouple producer and consumer: `"suspend"` backpressures when full, `"dropping"` drops new values, and `"sliding"` drops old values to retain the latest. Avoid `capacity: "unbounded"` unless growth is bounded elsewhere and documented.
 
+`Stream.partition` returns `[passes, fails]` and accepts `{ capacity }` (default
+16). Consume both sides concurrently to avoid blocking a full partition.
+`Stream.mapBoth` takes `onElement` / `onError`. `catchTags` rejects unknown tag
+keys; `catchDefect` handles defects separately from typed failures/interruption.
+`tapDefect`, `tapErrorTag`, and `unwrapReason` provide targeted observation/recovery.
+Use `Channel.runDrain` to consume channel output and return its completion value.
+
 ### merge
 
 Interleave elements from two streams concurrently in arrival order.
@@ -625,7 +620,7 @@ Because the producer starts immediately, subscribers that attach after the sourc
 
 ### broadcastN
 
-Fixed-fanout multicast (added in beta.68). Produces a tuple of `n` streams; the source starts only **after all `n` downstream streams have been subscribed**, so every consumer sees the full sequence without needing `replay`. If a downstream stream is interrupted, it unsubscribes and no longer contributes backpressure.
+Fixed-fanout multicast produces a tuple of `n` streams; the source starts only **after all `n` downstream streams have been subscribed**, so every consumer sees the full sequence without needing `replay`. If a downstream stream is interrupted, it unsubscribes and no longer contributes backpressure.
 
 ```ts
 Effect.scoped(
@@ -679,7 +674,7 @@ const safeStream = Stream.scoped(
 // Stream<string, never, never> — Scope is eliminated
 ```
 
-As of beta.69, `Stream.scoped` provides its managed scope to the **pull effects** as well — including effects created by `Stream.fromEffect` and by sequential `Stream.mapEffect`. So `Effect.acquireRelease` finalizers used inside those pulls run when the stream completes, not leaked until the outer program ends.
+`Stream.scoped` provides its managed scope to **pull effects**, including effects created by `Stream.fromEffect` and sequential `Stream.mapEffect`. `Effect.acquireRelease` finalizers inside those pulls run when the stream completes.
 
 ### unwrap
 

package/skills/effect-testing/SKILL.md

@@ -21,11 +21,16 @@ Reference this for:
 
 ## Framework Selection
 
-Keep `@effect/vitest` aligned with the Effect release. The rc.112 adapter's
-Vitest peer range is `>=4.1.0 <5.0.0`; do not install it into a Vitest 3 project
+Keep `@effect/vitest` aligned with the Effect release. Its
+Vitest peer range is `>=5.0.0 <6.0.0`; do not install it into a Vitest 3 or 4 project
 without migrating that project's test framework. Plain compiler/inventory tests
 can keep using their existing Vitest runner without the adapter.
 
+The adapter requires Node.js `^22.12.0 || ^24.0.0 || >=26.0.0`. Use
+`{ concurrent: false }` for sequential suites, including named `layer` / `it.layer`
+suites. Await asynchronous assertions and finalizers. Define custom matchers
+through `vitest.Matchers` and import reporter types from `vitest/node`.
+
 **CRITICAL**: Choose the correct testing framework based on the code being tested.
 
 ### Use @effect/vitest for Effect Code
@@ -367,7 +372,7 @@ layer(DatabaseLayer)((it) => {
 });
 ```
 
-A nested `it.layer` suite **reuses** the parent suite's memoized layer allocations rather than rebuilding them. As of beta.67, each nested suite also **forks its own memo map**, so layers allocated locally inside one nested suite are isolated from sibling nested suites and are released independently when that suite finishes. The practical effect: shared parent layers (e.g. `DatabaseLayer`) are built once and reused, while sibling-local allocations do not leak across siblings even in concurrent suites.
+A nested `it.layer` suite **reuses** the parent's memoized allocations and **forks its own memo map**. Parent layers are built once; local allocations are isolated from sibling suites and released when their suite finishes, including concurrent suites.
 
 ### Excluding Test Services
 
@@ -604,19 +609,21 @@ it.effect('should fail with specific error', () =>
 ### Using it.prop for Pure Properties
 
 ```typescript
-import { FastCheck } from 'effect/testing';
+import * as Schema from 'effect/Schema';
 import { it } from '@effect/vitest';
 
 it.prop(
 	'addition is commutative',
-	[FastCheck.integer(), FastCheck.integer()],
+	[Schema.Int, Schema.Int],
 	([a, b]) => a + b === b + a
 );
 
 // With object syntax
 it.prop(
 	'multiplication distributes',
-	{ a: FastCheck.integer(), b: FastCheck.integer(), c: FastCheck.integer() },
+	{ a: Schema.Int.check(Schema.isBetween({ minimum: -100, maximum: 100 })),
+	  b: Schema.Int.check(Schema.isBetween({ minimum: -100, maximum: 100 })),
+	  c: Schema.Int.check(Schema.isBetween({ minimum: -100, maximum: 100 })) },
 	({ a, b, c }) => a * (b + c) === a * b + a * c
 );
 ```
@@ -626,7 +633,7 @@ it.prop(
 ```typescript
 import { it } from '@effect/vitest';
 import { Effect, Context } from 'effect';
-import { FastCheck } from 'effect/testing';
+import * as Schema from 'effect/Schema';
 
 class Database extends Context.Service<
 	Database,
@@ -638,7 +645,7 @@ class Database extends Context.Service<
 
 it.effect.prop(
 	'database operations are idempotent',
-	[FastCheck.string(), FastCheck.integer()],
+	[Schema.String, Schema.Int],
 	([key, value]) =>
 		Effect.gen(function* () {
 			const db = yield* Database;
@@ -674,35 +681,41 @@ it.effect.prop('user validation works', { user: User }, ({ user }) =>
 );
 ```
 
-`it.prop` and `it.effect.prop` accept schemas directly and derive their arbitraries internally. For manual use, beta.106 consolidated derivation into `Schema.toArbitrary(schema)`, which returns a factory that must receive the fast-check module:
+`it.prop` and `it.effect.prop` accept schemas and native Arbitraries, composed
+with `Arbitrary.all`. For manual sampling use the interruptible native runner:
 
 ```typescript
-import { Schema } from 'effect';
-import { FastCheck } from 'effect/testing';
+import { Arbitrary } from 'effect/unstable/arbitrary';
 
-const UserArbitrary = Schema.toArbitrary(User)(FastCheck);
-const samples = FastCheck.sample(UserArbitrary, 10);
+const userArbitrary = Arbitrary.schema(User);
+const samples = Arbitrary.sampleEffect(userArbitrary, { count: 10, seed: 'users' });
 ```
 
-`Schema.toArbitraryLazy` and arbitrary derivation reports no longer exist.
+Generation is from the decoded schema Type. Compose with `map`, `flatMap`,
+`filter`, `filterMap`, `all`, and `array(item, { minLength, maxLength })`.
+Prefer constructive schemas over filters that exhaust the discard budget.
+`checkEffect` returns `Passed`, `Falsified`, `Exhausted`, or an invalid-replay
+result; inspect the outcome rather than treating completion as success. Preserve
+seeds, replay tokens, and important failing inputs. Replay paths can change when
+the generator/shrinker changes. In the Vitest adapter, thrown exceptions, typed
+failures, and defects are shrinkable falsifications; interruption stays interruption.
 
-### Configuring FastCheck
+### Configuring native property checks
 
 ```typescript
 import { it } from '@effect/vitest';
 import { Effect } from 'effect';
-import { FastCheck } from 'effect/testing';
+import * as Schema from 'effect/Schema';
 
 it.effect.prop(
 	'property test',
-	[FastCheck.integer()],
+	[Schema.Int],
 	([n]) => Effect.succeed(n >= 0 || n < 0),
 	{
 		timeout: 10000,
-		fastCheck: {
-			numRuns: 1000,
-			seed: 42,
-			verbose: true
+		arbitrary: {
+			runs: 1000,
+			seed: 42
 		}
 	}
 );
@@ -1155,7 +1168,7 @@ Key differences from `@effect/vitest`:
 - Layer composition uses `Layer.provideMerge` here because the harness intentionally exposes both application and test services; do not use it blindly
 - Keep `effect` as the default; use `live` only when real time or live runtime services are under test
 
-**`TestClock` without an ambient `Scope` (beta.70):** earlier betas required a surrounding `Scope` for `TestClock.adjust` to advance time. As of beta.70, `TestClock.layer()` works when provided directly to a program run with `Effect.runPromise` (no ambient `Scope`) — which is exactly what the harness above relies on. `testEffect(...).effect(...)` merges `TestClock.layer()` into the layer stack and runs with `Effect.runPromise`, and `TestClock.adjust` still drives time correctly.
+`TestClock.layer()` works when provided directly to a program executed with `Effect.runPromise`, without an ambient Scope. The harness above merges that layer into the test stack so `TestClock.adjust` controls time.
 
 ## Testing Checklist
 

package/skills/effect-workflow/SKILL.md

@@ -125,7 +125,7 @@ yield* SendEmail.resume(executionId);
 
 ### Deterministic Execution ID
 
-As of rc.112, generated `WorkflowProxy.toRpcGroup` `<Name>Discard` RPCs and
+Generated `WorkflowProxy.toRpcGroup` `<Name>Discard` RPCs and
 `WorkflowProxy.toHttpApiGroup` discard HTTP endpoints also return the execution
 ID (`Schema.String`). Consumers can persist that ID to poll/resume the workflow.
 Update generated client response types and tests that expected `void`; ordinary
@@ -192,7 +192,7 @@ const sendWithRetry = Activity.make({
 
 `Activity.retry` accepts the same options as `Effect.retry` *minus* `schedule` — the activity owns the attempt counter, so retries are attempt-based (`times`, `until`, `while`, `catch`, etc.) rather than schedule-based.
 
-Because an `Activity` *is* an `Effect`, pipe it directly through compensation/retry combinators — there is no `.asEffect()` method (`Effect.Yieldable` was removed in beta.66):
+An `Activity` *is* an `Effect`; pipe it directly through compensation/retry combinators:
 
 ```ts
 yield* SomeActivity.pipe(
@@ -460,6 +460,17 @@ const AppLayer = Layer.mergeAll(MyWorkflowLayer, ApiWorker).pipe(
 
 Delivery is **at least once** per the backing `PersistedQueue`, so worker handlers must be **idempotent** and tolerate retries, duplicate observations, and worker restarts.
 
+Persisted queue processing policy belongs on `PersistedQueue.make`: `maxAttempts`
+defaults to 10 and `retrySchedule` determines redelivery delay. Attempts count on
+claim; exhausted and undecodable items are dead-lettered. Distinguish this policy
+from retrying a transient failure to offer an item.
+
+`DurableDeferred.into` requires the schema encoding services needed to persist the
+exit. Cluster handoff interrupts an abandoned workflow run attempt without
+persisting a business failure or running compensations; replay continues under
+the next owner. Keep durable completion and activity state under the workflow
+engine rather than adding local retry/wakeup bookkeeping.
+
 ## Compensation (Saga Pattern)
 
 `Workflow.withCompensation` registers rollback logic that runs if the **entire workflow** fails. This enables the saga pattern for distributed transactions.