opencode-effect-enforcer 0.2.2 → 0.2.4

package/skills/effect-ai-tool/SKILL.md

@@ -91,7 +91,7 @@ const GetCurrentTime = Tool.make('GetCurrentTime', {
 	success: Schema.Number
 });
 
-const result = Tool.Success<typeof GetCurrentTime>;
+type Result = Tool.Success<typeof GetCurrentTime>;
 ```
 
 **Key Pattern: Tool.make**
@@ -234,13 +234,13 @@ const QueryDatabase = Tool.make('QueryDatabase', {
 	dependencies: [Database]
 });
 
-type Requirements = Tool.Requirements<typeof QueryDatabase>;
+type Requirements = Tool.HandlerServices<typeof QueryDatabase>;
 ```
 
 **Key Pattern: dependencies**
 
 - Array of service tags
-- Requirements extracted at type level
+- `Tool.HandlerServices<T>` includes declared dependencies, parameter-decoding services, and result-encoding services
 - Must be provided when creating handlers
 
 ## Creating Toolkits
@@ -392,12 +392,12 @@ const toolkitLayer = toolkit.toLayer({
 });
 
 const program = Effect.gen(function* () {
-	const handlers = yield* toolkitLayer;
+	const handlers = yield* toolkit;
 	const resultStream = yield* handlers.handle('GetWeather', { location: 'NYC' });
 	return resultStream;
-}).pipe(Effect.provide(WeatherServiceLive));
+}).pipe(Effect.provide(toolkitLayer), Effect.provide(WeatherServiceLive));
 
-declare const WeatherServiceLive: Layer<WeatherService>;
+declare const WeatherServiceLive: Layer.Layer<WeatherService>;
 ```
 
 **Key Pattern: Handler Context**
@@ -666,7 +666,7 @@ Approved calls execute on the next model call; denied calls are converted to fai
 import { Effect, Stream } from 'effect';
 
 const program = Effect.gen(function* () {
-	const toolkit = yield* MyToolkitLayer;
+	const toolkit = yield* MyToolkit;
 
 	const resultStream = yield* toolkit.handle('GetWeather', {
 		location: 'San Francisco'
@@ -823,7 +823,7 @@ import { Effect, Match } from 'effect';
 
 const executeTool = (toolName: string, params: unknown) =>
 	Effect.gen(function* () {
-		const toolkit = yield* MyToolkitLayer;
+		const toolkit = yield* MyToolkit;
 
 		const handler = Match.value(toolName).pipe(
 			Match.when('GetWeather', () =>
@@ -843,10 +843,12 @@ const executeTool = (toolName: string, params: unknown) =>
 
 ## Complete Example
 
+<!-- typecheck -->
 ```typescript
 import * as Tool from 'effect/unstable/ai/Tool';
 import * as Toolkit from 'effect/unstable/ai/Toolkit';
-import { Effect, Schema, Layer, Stream } from 'effect';
+import * as Schema from 'effect/Schema';
+import { Clock, Context, Effect, Layer, Stream } from 'effect';
 
 class UserNotFound extends Schema.TaggedError<UserNotFound>()(
 	'UserNotFound',
@@ -855,40 +857,27 @@ class UserNotFound extends Schema.TaggedError<UserNotFound>()(
 	}
 ) {}
 
-class Database extends Context.Service<
-	Database,
-	{
-		readonly query: (sql: string) => Effect.Effect<unknown>;
-	}
->()('Database') {}
+class User extends Schema.Class<User>('User')({
+	id: Schema.String,
+	name: Schema.String,
+	email: Schema.String
+}) {}
+
+class UserQuery extends Schema.Class<UserQuery>('UserQuery')({
+	userId: Schema.String
+}) {}
+
+class Users extends Context.Service<Users, {
+	readonly get: (id: string) => Effect.Effect<User, UserNotFound>;
+}>()('app/Users') {}
 
 const GetUser = Tool.make('GetUser', {
 	description: 'Retrieve user information by ID',
-	parameters: Schema.Struct({
-		userId: Schema.String
-	}),
-	success: Schema.Struct({
-		id: Schema.String,
-		name: Schema.String,
-		email: Schema.String
-	}),
-	failure: Schema.instanceOf(UserNotFound),
+	parameters: UserQuery,
+	success: User,
+	failure: UserNotFound,
 	failureMode: 'error',
-	dependencies: [Database]
-});
-
-const CreateUser = Tool.make('CreateUser', {
-	description: 'Create a new user',
-	parameters: Schema.Struct({
-		name: Schema.String,
-		email: Schema.String
-	}),
-	success: Schema.Struct({
-		id: Schema.String,
-		name: Schema.String,
-		email: Schema.String
-	}),
-	dependencies: [Database]
+	dependencies: [Users]
 });
 
 const GetCurrentTime = Tool.make('GetCurrentTime', {
@@ -896,58 +885,26 @@ const GetCurrentTime = Tool.make('GetCurrentTime', {
 	success: Schema.Number
 });
 
-const UserToolkit = Toolkit.make(GetUser, CreateUser, GetCurrentTime);
+const UserToolkit = Toolkit.make(GetUser, GetCurrentTime);
 
 const UserToolkitLive = UserToolkit.toLayer({
-	GetUser: ({ userId }) =>
-		Effect.gen(function* () {
-			const db = yield* Database;
-			const user = yield* db.query(
-				`SELECT * FROM users WHERE id = ?`,
-				userId
-			);
-
-			if (!user) {
-				return yield* Effect.fail(new UserNotFound({ userId }));
-			}
-
-			return user as { id: string; name: string; email: string };
-		}),
-
-	CreateUser: ({ name, email }) =>
-		Effect.gen(function* () {
-			const db = yield* Database;
-			const id = crypto.randomUUID();
-
-			yield* db.query(
-				`INSERT INTO users (id, name, email) VALUES (?, ?, ?)`,
-				id,
-				name,
-				email
-			);
-
-			return { id, name, email };
-		}),
-
-	GetCurrentTime: () => Effect.succeed(Date.now())
+	GetUser: Effect.fn('Tools.GetUser')(function* ({ userId }) {
+		const users = yield* Users;
+		return yield* users.get(userId);
+	}),
+	GetCurrentTime: Effect.fn('Tools.GetCurrentTime')(() => Clock.currentTimeMillis)
 });
 
-const DatabaseLive = Layer.succeed(Database, {
-	query: (sql: string, ...params: ReadonlyArray<unknown>) =>
-		Effect.logInfo(`Query: ${sql}`).pipe(Effect.as({}))
-});
+// A complete, typed demo implementation; production supplies a repository adapter.
+const exampleUser = new User({ id: 'user-123', name: 'Alice', email: 'alice@example.com' });
+const UsersTest = Layer.succeed(Users, Users.of({
+	get: Effect.fn('Users.get')((userId: string): Effect.Effect<User, UserNotFound> => userId === exampleUser.id
+		? Effect.succeed(exampleUser)
+		: Effect.fail(new UserNotFound({ userId })))
+}));
 
 const program = Effect.gen(function* () {
-	const toolkit = yield* UserToolkitLive;
-
-	const createStream = yield* toolkit.handle('CreateUser', {
-		name: 'Alice',
-		email: 'alice@example.com'
-	});
-
-	yield* createStream.pipe(
-		Stream.runForEach((result) => Effect.log('Created user:', result.result))
-	);
+	const toolkit = yield* UserToolkit;
 
 	const getStream = yield* toolkit.handle('GetUser', {
 		userId: 'user-123'
@@ -962,9 +919,15 @@ const program = Effect.gen(function* () {
 	yield* timeStream.pipe(
 		Stream.runForEach((result) => Effect.log('Current time:', result.result))
 	);
-}).pipe(Effect.provide(DatabaseLive));
+}).pipe(Effect.provide(UserToolkitLive), Effect.provide(UsersTest));
 ```
 
+Yield the **Toolkit**, then provide its handler **Layer**. A Layer is not a
+yieldable toolkit instance. Encode tagged failures with the error schema itself
+rather than `Schema.instanceOf(ErrorClass)`, which only checks an existing
+instance and cannot reconstruct it from JSON. Handlers get decoded class values;
+manual `handle` calls accept their encoded representation.
+
 ## Import Patterns
 
 **CRITICAL**: Always use namespace imports:
@@ -1005,7 +968,7 @@ import { make as makeToolkit } from 'effect/unstable/ai/Toolkit';
 - [ ] Tool.Readonly annotation for read-only tools
 - [ ] Tool.Destructive annotation for mutating operations
 - [ ] Tool.Idempotent annotation for safe retries
-- [ ] Custom annotations via Tool.annotate
+- [ ] Custom annotations via the tool's `.annotate` method
 - [ ] Provider-defined tools for native provider features
 - [ ] Toolkit.make with all tools (preferred in v4) or Toolkit.merge for combining tool collections
 - [ ] Error handling with catchTag in handlers

package/skills/effect-atom-rpc/SKILL.md

@@ -18,7 +18,14 @@ You are an Effect TypeScript expert specializing in `effect/unstable/reactivity/
 Use this skill when building React (or Atom-based) frontends that consume an existing `RpcGroup`.
 
 For the underlying RPC definitions, see the `effect-rpc-cluster` skill.
-For Atom fundamentals (`Atom.make`, `family`, `keepAlive`, `AsyncResult`, hydration), see the `effect-atom-state` and `effect-react-vm` skills.
+For Atom fundamentals (`Atom.make`, `family`, `keepAlive`, `AsyncResult`, hydration), see the `effect-atom-state` skill.
+
+The underlying RPC protocols require `codecFor` in rc.112. Built-in protocol
+layers supply it; forward it when implementing a custom transport. You can pair
+`RpcSerialization.layerSchemaBinary` on client/server without changing query or
+mutation call sites; see `effect-rpc-client` for frame limits and compatibility.
+Workflow proxy discard RPCs now return execution IDs, so their mutation success
+type is `string`. This is distinct from the client's `{ discard: true }` option.
 
 ## Effect Source Reference
 
@@ -485,4 +492,4 @@ The `query`/`mutation` arguments differ (you pass `groupName, endpointName, requ
 - Use `AsyncResult.builder(...).onWaiting(...).onError(...).onSuccess(...)` (or `AsyncResult.matchWithWaiting`) to render — never check `.waiting` and `.error` ad-hoc. Reserve `.onFailure((cause) => ...)` for whole-`Cause` fallbacks after typed error branches.
 - For protocol layers that depend on auth tokens or other reactive state, use the `(get) => Layer` form of `protocol` so the client rebuilds when those atoms change.
 - For typed error recovery, handle declared RPC errors, RPC middleware wire errors, and `RpcClientError`; branch on `_tag` only when the relevant errors are tagged.
-- Cross-link to `effect-atom-state` and `effect-react-vm` skills for atom-side patterns; this skill covers only the RPC bridge.
+- Cross-link to `effect-atom-state` for atom-side patterns; this skill covers only the RPC bridge.

package/skills/effect-atom-state/SKILL.md

@@ -7,6 +7,11 @@ description: Implement reactive state management with Effect Atom for React appl
 
 Effect Atom is a reactive state management library for Effect that seamlessly integrates with React.
 
+At rc.112, `@effect/atom-react` supports React `>=19.0.0 <20.0.0` (the peer range
+was relaxed). This does not add React 18 support. Keep the adapter aligned with
+the Effect release; core atoms still live in `effect/unstable/reactivity`, and
+React bindings live in `@effect/atom-react` (`packages/atom/react` upstream).
+
 ## Effect Source Reference
 
 The Effect v4 source is available at `~/.local/share/opencode/repos/github.com/Effect-TS/effect@main/`.

package/skills/effect-cache/SKILL.md

@@ -50,6 +50,7 @@ Choosing the right tool:
 | Cache one value, no key | `Effect.cached` / `cachedWithTTL` / `cachedInvalidateWithTTL` (section 10) |
 | Cache values by key | `Cache` |
 | Cached value owns resources (connection, file handle, subprocess) | `ScopedCache` |
+| Keyed resource retained until each caller's scope releases it | `RcMap` / `LayerMap` |
 | Batch + deduplicate request-shaped fetches | see the effect-batching skill (`RequestResolver.withCache` / `asCache`) |
 | Pool of N interchangeable resources checked out per use | `effect/Pool` (not keyed caching) |
 | Scope/finalizer fundamentals | see the effect-scope skill |
@@ -362,6 +363,37 @@ The full method surface (`get`, `getOption`, `getSuccess`, `set`, `has`, `invali
 
 ## 9. Services in Lookups (requireServicesAt)
 
+### Retain an existing keyed resource (rc.112)
+
+`RcMap.getOption(map, key)` atomically retains a cached entry for the caller's
+`Scope` before awaiting it. It returns `Option.none()` if the entry is missing or
+the map is closed and never starts a lookup for a missing key. An existing
+in-flight entry is awaited; cached/in-flight failures still fail with `E`.
+This is not a non-blocking success-only peek and does not turn failures into absence.
+
+Use `LayerMap.contextEffectOption(key)` for the same behavior over keyed layer
+contexts. Its service-class accessor additionally requires the LayerMap service.
+`has` followed by `get` is not an atomic substitute: the entry can disappear
+between calls and `get` may allocate a replacement. Keep the retained resource's
+use inside the caller scope. See `effect-scope` for `Pool.use` when resources are
+interchangeable rather than keyed.
+
+<!-- typecheck -->
+```ts
+import { Duration, Effect, Option, RcMap } from 'effect';
+
+const program = Effect.gen(function* () {
+	const resources = yield* RcMap.make({
+		lookup: (key: string) => Effect.succeed(`resource:${key}`),
+		idleTimeToLive: Duration.minutes(1)
+	});
+	const missing = yield* RcMap.getOption(resources, 'database');
+	yield* Effect.scoped(RcMap.get(resources, 'database'));
+	const retained = yield* RcMap.getOption(resources, 'database');
+	return { missing: Option.isNone(missing), retained };
+}).pipe(Effect.scoped);
+```
+
 Lookups can use services. `requireServicesAt` controls *where* the type system demands them:
 
 - **default (`'construction'` behavior)**: `Cache.make` itself requires `R`; services are captured when the cache is built, and the cache type is `Cache<Key, A, E, never>` — `get` needs nothing.

package/skills/effect-cli/SKILL.md

@@ -201,20 +201,39 @@ Hidden flags parse normally, but generated help, shell completions, and typo sug
 
 Bare boolean flags are required. `--verbose` produces `true`, `--no-verbose` produces `false`, and omission produces `CliError.MissingOption`. Add `Flag.withDefault(false)` for ordinary opt-in switch behavior, or use `Flag.optional` / a config or prompt fallback when absence has separate meaning.
 
-### Prompt Defaults and Prefixes
+### Prompt Defaults and Themes
 
+<!-- typecheck -->
 ```typescript
+import { Effect } from 'effect';
 import { Prompt } from 'effect/unstable/cli';
 
 Prompt.integer({ message: 'Count', default: 42 });
 Prompt.file({ message: 'Pick file', default: '/workspace/config.json' });
 
-// The default prefix is "?"; an empty string omits it.
-Prompt.text({ message: 'Name', prefix: '>' });
+// A local override merges over the context theme.
+const name = Prompt.text({ message: 'Name', theme: { prefix: '>' } });
+
+// Provide once to theme all prompts in a command or application.
+const themed = name.pipe(
+	Effect.provideService(Prompt.Theme, Prompt.makeTheme({ tick: '✓' }))
+);
 ```
 
 Integer prompt defaults are editable and Enter submits the default if unchanged. `Prompt.file` resolves/selects the default as the initial path.
 
+In rc.112, per-prompt `prefix` is replaced by `theme?: Partial<Prompt.Theme>`.
+`Prompt.Theme` is a context reference with platform defaults; `Prompt.makeTheme`
+builds a complete theme. Local fields override the context theme. Theme fields
+include prompt symbols, `passwordMask`, and ANSI color values. The default
+prefix is `?`; `theme: { prefix: '' }` omits it.
+
+`autoComplete` and `file` now insert `j`/`k` into filter text. Navigate with arrow
+keys (or Ctrl-P/Ctrl-K for up, Ctrl-N for down). Wizard command output redacts
+password prompt values. Completion generators preserve quoted/spaced/Unicode
+choices across Bash (including 3.2), Fish, and Zsh; let the generator escape
+choice values rather than pre-escaping your domain values.
+
 ## Commands
 
 ### Creating Commands

package/skills/effect-concurrency-testing/SKILL.md

@@ -45,7 +45,7 @@ it.effect('fiber polling with yieldNow', () =>
 
 		yield* latch.open;
 
-		expect(yield* fiber.await).toEqual(Exit.void);
+		expect(yield* Fiber.await(fiber)).toEqual(Exit.void);
 	})
 );
 ```
@@ -212,12 +212,12 @@ it.effect('should publish user created event', () =>
 					type: 'created',
 					userId: 'user-123'
 				});
-			})
+			}).pipe(
+				Effect.provide(UserServiceLive),
+				Effect.provide(Layer.succeed(EventBus, pubsub))
+			)
 		);
-	}).pipe(
-		Effect.provide(UserServiceLive),
-		Effect.provide(Layer.succeed(EventBus, pubsub))
-	)
+	})
 );
 ```
 
@@ -333,9 +333,7 @@ it.effect('subscriptions are interruptible', () =>
 
 		const result = yield* Fiber.await(fiber);
 
-		expect(Exit.isFailure(result) && Pull.isDoneCause(result.cause)).toBe(
-			true
-		);
+		expect(Exit.hasInterrupts(result)).toBe(true);
 	})
 );
 ```