opencode-effect-enforcer 0.2.5 → 0.2.8

package/patterns/avoid-process-env.md

@@ -19,9 +19,9 @@ suggestSkills:
 processEnv :: String -> IO (Maybe String)    -- side effect, untyped, untestable
 
 -- Instead
-Config.string :: String -> Config String     -- typed, composable, testable
+Config.String :: String -> Config String     -- typed, composable, testable
 Config.withDefault :: a -> Config a -> Config a
-Config.redacted :: String -> Config Redacted -- for sensitive values
+Config.Redacted :: String -> Config Redacted -- for sensitive values
 ```
 
 ```haskell
@@ -30,10 +30,10 @@ bad :: Effect String
 bad = Effect.sync \_ -> process.env.API_KEY    -- raw side effect
 
 good :: Effect String ConfigError
-good = Config.string "API_KEY"                 -- typed, validated
+good = Config.Redacted "API_KEY"               -- typed, redacted
 
 better :: Effect String ConfigError
-better = Config.string("PORT")
+better = Config.Int("PORT")
   & Config.withDefault "3000"
   & Config.map Number.parse                    -- with transformation
 ```

package/patterns/context-tag-extends.md

@@ -26,13 +26,13 @@ suggestSkills:
 
 # Use `Context.Service` for All Service Definitions
 
-`Context.Service` is the single canonical service-definition API in Effect v4 (beta.46+). Three legacy spellings exist and must all be replaced:
+Use `Context.Service` for service definitions. Replace these legacy spellings:
 
 | Legacy API                  | Era       | Replacement                |
 | --------------------------- | --------- | -------------------------- |
 | `Context.Tag` / `GenericTag` | pre-v4    | `Context.Service`          |
 | `Effect.Service`            | early v4  | `Context.Service`          |
-| `ServiceMap.Service` / `.*` | beta.43    | `Context.Service` / `Context.*` |
+| `ServiceMap.Service` / `.*` | prerelease | `Context.Service` / `Context.*` |
 
 ```haskell
 -- Anti-pattern: *Tag suffix + Context.Tag — removed in v4
@@ -43,10 +43,10 @@ data ParallelClientService = ...
 -- Anti-pattern: Effect.Service — also removed in v4
 class ParallelClient extends Effect.Service<ParallelClient>()(...)
 
--- Anti-pattern: ServiceMap.* — removed before v4 beta.46 stabilized
+-- Anti-pattern: ServiceMap.*
 class MyService extends ServiceMap.Service<MyService>()("@app/MyService", { ... })
 
--- Fix: Context.Service (beta.46 API)
+-- Fix: Context.Service
 class ParallelClient extends Context.Service<ParallelClient>()(
   "@parallel/ParallelClient"
 )

package/patterns/prefer-arr-sort.md

@@ -49,4 +49,4 @@ descending = Arr.sort (Order.reverse byName)
 
 Native `.sort()` mutates the array in place and uses an untyped comparator. `Arr.sort` from `effect/Array` returns a new sorted array using a composable, typed `Order`.
 
-References: EF-38 in effect-first-development.md
+References: EF-5 in effect-first-development.md

package/patterns/prefer-redacted-config.md

@@ -3,13 +3,13 @@ action: context
 tool: (edit|write)
 event: after
 name: prefer-redacted-config
-description: Use Config.redacted or Schema.Redacted for secret-like configuration values
+description: Use Config.Redacted or Schema.Redacted for secret-like configuration values
 glob: '**/*.{ts,tsx}'
 detector: ast
 rule:
     any:
-        - pattern: Config.string($KEY)
-        - pattern: Config.nonEmptyString($KEY)
+        - pattern: Config.String($KEY)
+        - pattern: Config.NonEmptyString($KEY)
         - all:
               - kind: pair
               - has:
@@ -33,18 +33,18 @@ suggestSkills:
 
 ```haskell
 -- Transformation
-Config.string secretKey    :: String            -- easy to log accidentally
-Config.redacted secretKey  :: Redacted String   -- hidden from logs/toString
+Config.String secretKey    :: String            -- easy to log accidentally
+Config.Redacted secretKey  :: Redacted String   -- hidden from logs/toString
 ```
 
 ```typescript
 // Bad
-const apiKey = Config.string('API_KEY');
-const token = Config.nonEmptyString('GITHUB_TOKEN');
+const apiKey = Config.String('API_KEY');
+const token = Config.NonEmptyString('GITHUB_TOKEN');
 
 // Good
-const apiKey = Config.redacted('API_KEY');
-const token = Config.redacted('GITHUB_TOKEN');
+const apiKey = Config.Redacted('API_KEY');
+const token = Config.Redacted('GITHUB_TOKEN');
 ```
 
 For structured config schemas, wrap secret-like string fields in `Schema.Redacted`:
@@ -67,4 +67,4 @@ const AppConfig = Config.schema(
 );
 ```
 
-Secrets should remain redacted from the moment they enter the program. Use `Config.redacted` for primitive config values and `Schema.Redacted(Schema.String)` for schema-based config fields.
+Secrets should remain redacted from the moment they enter the program. Use `Config.Redacted` for primitive config values and `Schema.Redacted(Schema.String)` for schema-based config fields.

package/patterns/prefer-schema-class.md

@@ -51,4 +51,4 @@ extend = class Admin extends User.extend<Admin>("Admin")({
 
 `Schema.Struct` produces an anonymous schema without a constructor or `instanceof` support. `Schema.Class` provides a named type, constructor, extensibility, and optional annotation support when docs or introspection benefit from it. Prefer `Schema.Class` for decoded domain/API shapes, union members, and values that need identity. `Schema.Struct` remains appropriate for local structural composition, configuration internals, and schemas where class identity adds no value, so review this informational finding in context.
 
-References: EF-3, EF-33 in effect-first-development.md
+References: EF-3 in effect-first-development.md

package/patterns/require-effect-concurrency.md

@@ -79,7 +79,7 @@ Effect.forEach xs f opts      -- concurrency intent explicit
 Effect.forEach(items, processItem);
 Effect.all(tasks);
 Effect.validate(inputs, validateInput, { discard: true });
-Effect.all(tasks, { concurrency: 'inherit' }); // removed in beta.102
+Effect.all(tasks, { concurrency: 'inherit' }); // unsupported ambient policy
 
 // Good
 Effect.forEach(items, processItem, { concurrency: 1 });

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

@@ -231,7 +231,7 @@ const program = Effect.gen(function* () {
 		timeToLive: '1 hour' // optional TTL
 	});
 
-	// chat is a `Chat.Persisted` — same API as Chat.Service but auto-saves
+	// chat is a `Chat.Persisted` — same API as Chat.Chat but auto-saves
 	const response = yield* chat
 		.generateText({
 			prompt: 'Hello!'
@@ -245,7 +245,7 @@ const program = Effect.gen(function* () {
 });
 ```
 
-The `Persisted` interface extends `Chat.Service` with:
+The `Persisted` interface extends `Chat.Chat` with:
 
 - `id: string` — the chat identifier in the store
 - `save: Effect<void, AiError | PersistenceError>` — manual save trigger

package/skills/effect-ai-language-model/SKILL.md

@@ -94,7 +94,13 @@ const manualTools = LanguageModel.generateText({
 });
 ```
 
-When `disableToolCallResolution: true`, tool-call `params` are preserved in the schema's **encoded** representation instead of being decoded and then returned. The response type reflects this as `GenerateTextResponse<Tools, true>` and `Response.ToolCallParts<Tools, true>`; streaming uses `Response.StreamPart<Tools, true>`. This matters for transformations such as `Schema.NumberFromString`: manual calls contain the wire value `{ count: '3' }`, not `{ count: 3 }`.
+With `disableToolCallResolution: true`, tool-call `params` retain the schema's
+**encoded** representation. Response generics use the mode `"encoded"`, for
+example `GenerateTextResponse<Tools, "encoded">` and
+`Response.StreamPart<Tools, "encoded">`. Automatic resolution uses `"opaque"`
+parameters (`unknown`), because invalid calls can also appear in responses.
+Only successfully decoded handler inputs have the decoded parameter type.
+For `Schema.NumberFromString`, manual calls contain `{ count: '3' }`.
 
 Pass those encoded params directly to `toolkit.handle(name, params, toolCallId)` when resolving manually. `Toolkit.handle` now accepts `Tool.ParametersEncoded<T>` and performs the decode before the handler receives `Tool.Parameters<T>`.
 
@@ -104,7 +110,7 @@ Pass those encoded params directly to `toolkit.handle(name, params, toolCallId)`
 const response = yield* LanguageModel.generateText({ prompt: '...' });
 
 response.text; // string - concatenated text content
-response.toolCalls; // decoded params normally; encoded params when resolution is disabled
+response.toolCalls; // opaque params normally; encoded params when resolution is disabled
 response.toolResults; // Array<ToolResultParts> - tool outputs
 response.finishReason; // "stop" | "length" | "content-filter" | "tool-calls" | "error" | "pause" | "unknown" | "other"
 response.usage; // Usage object with nested structure, e.g. response.usage.outputTokens.total
@@ -297,6 +303,32 @@ const robust = LanguageModel.generateText({
 );
 ```
 
+## Batched classification, rating, and probability
+
+Use `DecisionModel` for structured judgments over one schema-encoded input.
+Define named decisions once and send them in one call; input encoding services
+remain explicit and provider/validation failures use `AiError`. Classification
+requires at least two labels, rating requires at least two distinct ordered
+levels, and a definition requires at least one decision.
+
+<!-- typecheck -->
+```ts
+import * as Schema from 'effect/Schema';
+import { Decision, DecisionModel } from 'effect/unstable/ai';
+
+class Ticket extends Schema.Class<Ticket>('Ticket')({ body: Schema.String }) {}
+const triage = Decision.make({
+	input: Ticket,
+	decisions: {
+		team: Decision.classify({
+			instructions: 'Choose the team responsible for this request',
+			criteria: { billing: 'Payments and invoices', support: 'Product support' }
+		})
+	}
+});
+const result = DecisionModel.decide(triage, { input: new Ticket({ body: 'Invoice question' }) });
+```
+
 ## Type Extraction Utilities
 
 ```typescript
@@ -308,8 +340,8 @@ type MyError = LanguageModel.ExtractError<typeof options>;
 // Extract service requirements from options
 type MyRequirements = LanguageModel.ExtractServices<typeof options>;
 
-// true only when options has literal disableToolCallResolution: true
-type EncodedParams = LanguageModel.ExtractEncodedToolParameters<typeof options>;
+// "encoded" for literal disableToolCallResolution: true; otherwise "opaque"
+type ParametersMode = LanguageModel.ExtractToolParametersMode<typeof options>;
 
 // Inferred based on:
 // - toolkit: Toolkit.WithHandler<Tools> → Tool.HandlerError<Tools> ∈ E

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

@@ -516,7 +516,7 @@ const program = Effect.gen(function* () {
 
 ## Provider-Specific Options
 
-### OpenAI Responses explicit cache breakpoints (rc.112)
+### OpenAI Responses explicit cache breakpoints
 
 With `@effect/ai-openai` loaded, system-message and text-part options accept
 `openai.promptCacheBreakpoint`. This requires GPT-5.6 or later; earlier models

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

@@ -100,7 +100,7 @@ import { FetchHttpClient } from 'effect/unstable/http';
 
 // Client layer (reusable across models)
 const AnthropicClientLayer = AnthropicClient.layerConfig({
-	apiKey: Config.redacted('ANTHROPIC_API_KEY')
+	apiKey: Config.Redacted('ANTHROPIC_API_KEY')
 }).pipe(Layer.provide(FetchHttpClient.layer));
 
 // Option A: model() — returns Model.Model (preferred)
@@ -130,7 +130,7 @@ import { Config, Layer } from 'effect';
 import { FetchHttpClient } from 'effect/unstable/http';
 
 const OpenAiClientLayer = OpenAiClient.layerConfig({
-	apiKey: Config.redacted('OPENAI_API_KEY')
+	apiKey: Config.Redacted('OPENAI_API_KEY')
 }).pipe(Layer.provide(FetchHttpClient.layer));
 
 // model() constructor (preferred)
@@ -186,7 +186,7 @@ import { Config, Layer } from 'effect';
 import { FetchHttpClient, HttpClient, HttpClientRequest } from 'effect/unstable/http';
 
 const CompatibleClientLayer = OpenAiClient.layerConfig({
-	apiKey: Config.redacted('OPENAI_COMPAT_API_KEY'),
+	apiKey: Config.Redacted('OPENAI_COMPAT_API_KEY'),
 	apiUrl: Config.succeed('https://my-provider.example.com/v1')
 }).pipe(Layer.provide(FetchHttpClient.layer));
 
@@ -211,7 +211,7 @@ import { Config, Layer } from 'effect';
 import { FetchHttpClient } from 'effect/unstable/http';
 
 const OpenRouterClientLayer = OpenRouterClient.layerConfig({
-	apiKey: Config.redacted('OPENROUTER_API_KEY')
+	apiKey: Config.Redacted('OPENROUTER_API_KEY')
 }).pipe(Layer.provide(FetchHttpClient.layer));
 
 // model() constructor — use provider-prefixed model IDs
@@ -420,7 +420,7 @@ export class AiWriter extends Context.Service<
 
 ## Custom Error Wrapping
 
-In rc.112, `AiError.AuthenticationError` accepts an optional `description` and
+`AiError.AuthenticationError` accepts an optional `description` and
 appends it after the kind-based remediation message. Anthropic, OpenAI,
 OpenAI-compatible, and OpenRouter adapters propagate provider error text from
 401/403 responses. Preserve this reason rather than replacing it with a generic
@@ -496,11 +496,11 @@ import { FetchHttpClient } from 'effect/unstable/http';
 // ---------------------------------------------------------------------------
 
 const AnthropicClientLayer = AnthropicClient.layerConfig({
-	apiKey: Config.redacted('ANTHROPIC_API_KEY')
+	apiKey: Config.Redacted('ANTHROPIC_API_KEY')
 }).pipe(Layer.provide(FetchHttpClient.layer));
 
 const OpenAiClientLayer = OpenAiClient.layerConfig({
-	apiKey: Config.redacted('OPENAI_API_KEY')
+	apiKey: Config.Redacted('OPENAI_API_KEY')
 }).pipe(Layer.provide(FetchHttpClient.layer));
 
 // ---------------------------------------------------------------------------
@@ -619,15 +619,15 @@ Effect.runPromise(program.pipe(Effect.provide(AiWriter.layer)));
 // WRONG: Hardcoded API keys
 AnthropicClient.layerConfig({ apiKey: 'sk-...' });
 
-// RIGHT: Config.redacted for secrets
-AnthropicClient.layerConfig({ apiKey: Config.redacted('ANTHROPIC_API_KEY') });
+// RIGHT: Config.Redacted for secrets
+AnthropicClient.layerConfig({ apiKey: Config.Redacted('ANTHROPIC_API_KEY') });
 
 // WRONG: Missing FetchHttpClient layer
-AnthropicClient.layerConfig({ apiKey: Config.redacted('KEY') });
+AnthropicClient.layerConfig({ apiKey: Config.Redacted('KEY') });
 // Will fail at runtime — providers require an HttpClient
 
 // RIGHT: Always provide an HTTP client layer
-AnthropicClient.layerConfig({ apiKey: Config.redacted('KEY') }).pipe(
+AnthropicClient.layerConfig({ apiKey: Config.Redacted('KEY') }).pipe(
 	Layer.provide(FetchHttpClient.layer)
 );
 
@@ -653,7 +653,7 @@ import { BedrockClient } from '@effect/ai-amazon-bedrock'; // Does NOT exist
 
 ## Quality Checklist
 
-- [ ] Use `Config.redacted` for API keys (never hardcode)
+- [ ] Use `Config.Redacted` for API keys (never hardcode)
 - [ ] Provide `FetchHttpClient.layer` to all client layers
 - [ ] Use `.model()` constructor for `ExecutionPlan` and `Effect.provide`
 - [ ] Use `ExecutionPlan` for multi-provider fallback with retry
@@ -674,6 +674,17 @@ import { BedrockClient } from '@effect/ai-amazon-bedrock'; // Does NOT exist
 
 ## References
 
+Provider-neutral structured decisions use `Decision` / `DecisionModel` from
+`effect/unstable/ai`. `OpenRouterDecisionModel` targets OpenRouter's alpha Decisions
+API; `@effect/ai-typesafe` supplies a provider for TypeSafe System One. Custom
+OpenRouter client implementations include `createDecisions`.
+
+Use each branded service's same-name type (`LanguageModel.LanguageModel`,
+`EmbeddingModel.EmbeddingModel`, `Chat.Chat`) and its exported TypeId for custom
+implementations. Prefer provided constructors; do not hard-code marker strings.
+OpenAI web-search sources are a discriminated union: narrow `type` before reading
+`url` or `name`. Provider-executed tool failures remain failure results.
+
 - `packages/ai/anthropic/src/AnthropicLanguageModel.ts`
 - `packages/ai/openai/src/OpenAiLanguageModel.ts`
 - `packages/ai/openrouter/src/OpenRouterLanguageModel.ts`

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

@@ -208,6 +208,19 @@ type Error = Tool.Failure<typeof FindUser>;
 
 **Key Pattern: failureMode**
 
+Parameter validation follows the tool's `failureMode`. Failure results include
+`Tool.ExecutionFailure` for framework failures (AI errors, denial, interruption)
+as well as declared user errors. Select result codecs using `isFailure` and
+`Tool.failureResultSchema(tool)`; preserve `encodedResult` when storing or
+replaying response parts. A failure with `Schema.NumberFromString` is stored as
+a string, even when the success schema stores a number. Validation errors do not
+expose a `toolParams` field.
+
+`Toolkit.handle` accepts parse options for parameter decoding. Returned failures
+carry `failureOrigin`, also available through the `Toolkit.FailureOrigin` cause
+annotation and `Tool.FailureOrigin` type. Keep validation, declared handler, and
+internal failures distinct when presenting or reporting them.
+
 - `"error"` (default): Failures go to Effect error channel
 - `"return"`: Failures returned as tool result (captured, not thrown)
 

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

@@ -20,7 +20,7 @@ Use this skill when building React (or Atom-based) frontends that consume an exi
 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` skill.
 
-The underlying RPC protocols require `codecFor` in rc.112. Built-in protocol
+The underlying RPC protocols require `codecFor`. 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.
@@ -29,6 +29,12 @@ type is `string`. This is distinct from the client's `{ discard: true }` option.
 
 ## Effect Source Reference
 
+Query and mutation errors include client middleware errors. AtomHttpApi stream
+successes retain transport, decoding, and SSE failures in the stream error channel;
+handle them when consuming the stream. An explicit zero `timeToLive` disables
+default idle retention, so unmount/remount may dispose and refetch. Omission uses
+the registry default. HttpApi calls accept per-call `sseOptions`.
+
 - `packages/effect/src/unstable/reactivity/AtomRpc.ts` — the whole API (~270 lines)
 - `packages/effect/test/reactivity/AtomRpc.test.ts` — minimal usage + serialization test
 - `packages/effect/src/unstable/reactivity/AtomHttpApi.ts` — the cousin pattern for `HttpApi` (same idea, same options)

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

@@ -7,7 +7,7 @@ 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
+`@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).
@@ -27,6 +27,12 @@ Reference this for:
 
 ### Atoms as References
 
+`Reactivity.Reactivity` is the branded service interface. Custom implementations
+include its exported `[TypeId]: TypeId`; prefer the supplied constructor/layer.
+Registry dehydration skips unencodable values while preserving other atoms.
+`Atom.withFallback` forwards writes to the primary atom. Keep encoding contracts
+explicit for state that must survive SSR dehydration.
+
 Atoms work **by reference** - they are stable containers for reactive state:
 
 ```typescript
@@ -301,7 +307,7 @@ export const notifications = Atom.make(
 	Stream.fromEventListener(window, 'notification').pipe(
 		Stream.map(parseNotification),
 		Stream.filter(isValid),
-		Stream.scan([], (acc, n) => [...acc, n].slice(-10))
+		Stream.scan(() => [], (acc, n) => [...acc, n].slice(-10))
 	)
 );
 ```

package/skills/effect-cache/SKILL.md

@@ -7,6 +7,15 @@ You are an Effect TypeScript expert specializing in in-memory caching with `Cach
 
 ## Effect Source Reference
 
+`Effect.cachedWithTTL` accepts either a fixed Duration input or an Exit-dependent
+TTL function, so success and failure retention can differ. Allocate the cache
+once in its owning layer. A zero TTL is explicit, not omission.
+For `LayerMap.Service({ preload: true, ... })`, preserve acquisition errors on
+the yielded service and `get` / `contextEffect` / `contextEffectOption`: an entry
+can fail when reacquired after successful preloading. Invalidating an active
+RcMap/LayerMap entry releases it after its last borrower closes; a replacement
+entry remains independently owned.
+
 The Effect v4 source is available at `~/.local/share/opencode/repos/github.com/Effect-TS/effect@main/`.
 Browse and read files there directly to look up APIs, types, and implementations.
 
@@ -363,7 +372,7 @@ The full method surface (`get`, `getOption`, `getSuccess`, `set`, `has`, `invali
 
 ## 9. Services in Lookups (requireServicesAt)
 
-### Retain an existing keyed resource (rc.112)
+### Retain an existing keyed resource
 
 `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