@danieljvdm/dev-kit 0.11.3 → 0.12.0

package/skills/build-effect-apis/references/effect-atom-lifecycle.md

@@ -0,0 +1,78 @@
+# Effect Atom lifecycle
+
+Treat query atoms as shared read state and mutations as actions owned by an
+initiating UI or workflow. Choose registry scope, atom identity, retention,
+freshness, polling, and cancellation independently.
+
+## Registry and runtime scope
+
+`RegistryProvider` creates its registry on first render; later option changes do
+not rebuild it. Provider unmount schedules disposal after a short grace period,
+while moving or keying the provider changes the cache boundary. Place one
+provider around the application subtree that should share client state; nested
+or route-local providers create separate caches.
+
+The registry stores nodes, values, subscriptions, idle timers, and finalizers.
+An Atom runtime supplies Effect services, and `Atom.context({ memoMap })` lets
+several runtimes share layer construction. Create neither a registry nor a memo
+map per query or render. Keep request-specific authentication out of a
+process-global server memo map.
+
+## Stable identity and families
+
+Export fixed queries directly. Use `Atom.family` when a parameter selects the
+resource. Prefer a primitive family argument; give object keys deliberate Effect
+`Equal`/`Hash` semantics or reuse the same object. Calling a family with a stable
+primitive during render already returns its stable member; an extra `useMemo`
+does not improve identity.
+
+## Three independent clocks
+
+| Control                                         | Clock starts                 | Effect                                                                                  | It does not mean           |
+| ----------------------------------------------- | ---------------------------- | --------------------------------------------------------------------------------------- | -------------------------- |
+| Registry/default idle TTL or query `timeToLive` | When the atom becomes unused | Retain the cached node until idle eviction                                              | The value remains fresh    |
+| `Atom.swr({ staleTime })`                       | At the latest success        | Revalidate stale data on configured mount/focus signals while showing the prior success | The node survives unmount  |
+| `Atom.withRefresh(interval)`                    | While its wrapper is mounted | Force periodic refresh until disposal                                                   | Fresh requests are skipped |
+
+Set retention long enough for the intended navigation/remount reuse window.
+`staleTime` cannot rescue an already evicted node. Manual refresh, invalidation,
+and polling are forceful and do not consult SWR freshness. Applying `keepAlive`
+to a polling wrapper intentionally keeps that polling lifetime alive.
+
+Atom registries are in-memory caches, not durable or shared storage. New tabs,
+hard reloads, processes, and providers have separate caches. Idle TTL is not a
+maximum-entry bound; finite TTLs are important for unbounded family keys.
+
+## React mounts and action ownership
+
+- `useAtomValue(atom)` subscribes for rendering;
+- `useAtomSet(atom)` mounts a writable atom and returns a setter;
+- `useAtom(atom)` subscribes and writes when one component owns both behaviors.
+
+Use `useAtom` instead of pairing `useAtomValue` and `useAtomSet` for the same
+atom in one component. The split form creates a value subscription plus a
+separate mount and obscures ownership.
+
+Unmount releases only that hook's subscription or mount. Registry eviction waits
+for remaining consumers and idle TTL, then runs node finalizers. Component
+unmount, registry eviction, and `Atom.Interrupt` are distinct events.
+
+Use `Atom.Interrupt` for explicit cancellation. A cleanup write publishes an
+interrupted `AsyncResult.Failure`; it is not passive unmount release, can run
+during React Strict Mode replay, and can cancel work owned by another consumer.
+
+Place a multi-request action in an owner that lives for the whole sequence. If
+navigation or disconnect must not leave a partially completed fan-out, use a
+stable workflow atom/service or one durable server-side command.
+
+## Keep aggregates stable
+
+`AsyncResult.all` returns the first non-success input, so an aggregate is only
+as reusable as its least-stable input. A newly allocated or evicted input
+returns to `Initial` and makes the aggregate appear reset even while other
+queries remain cached.
+
+Define every input as a module-scoped singleton or stable family member with
+compatible retention. Aggregate inside a derived atom so the registry owns
+recomputation; memoizing only the `AsyncResult.all` call does not repair an
+unstable input atom.

package/skills/build-effect-apis/references/effect-atom-testing.md

@@ -0,0 +1,74 @@
+# Deterministic Effect Atom testing
+
+Test cache policy below React first with `AtomRegistry.make()`. Add a React
+integration test for provider placement, hook behavior, browser-only SSR
+boundaries, hydration, or Strict Mode ownership.
+
+Use fake timers, a request counter, controllable Effects, and explicit mounts:
+
+```ts
+const registry = AtomRegistry.make({ defaultIdleTTL: 1_000 });
+const unmount = registry.mount(queryAtom);
+const first = registry.get(queryAtom);
+
+// Flush Effect work and advance the test runner's fake timers.
+
+unmount();
+```
+
+Use the repository's established `Effect.yieldNow` or test-clock pattern rather
+than wall-clock sleeps. Prefer installed APIs and predicates such as
+`AsyncResult.isSuccess`; use the cleanup returned by `registry.mount(atom)`.
+
+## Remount reuse
+
+1. Mount and resolve the query; assert request count `1`.
+2. Unmount, advance less than idle TTL, and remount the same atom identity.
+3. Assert cached success is immediately available and no fresh request occurs.
+
+## Stale refresh
+
+1. Resolve once through an SWR wrapper.
+2. Advance past `staleTime` but not idle TTL.
+3. Remount or emit the injected focus signal.
+4. Assert the previous success remains with `waiting: true`, then a second
+   success arrives and request count becomes `2`.
+5. Prove a fresh mount or focus signal does not request.
+
+## TTL eviction
+
+1. Resolve and unmount.
+2. Advance to just before TTL and assert reuse.
+3. Advance through TTL, flush disposal, and remount.
+4. Assert initial/waiting behavior and a new request.
+
+## Polling cleanup
+
+1. Mount the `Atom.withRefresh` wrapper and resolve once.
+2. Advance one interval and assert one forced refresh.
+3. Unmount, advance several intervals, and assert the counter stops changing.
+
+## Mutation invalidation
+
+1. Mount list and detail queries with explicit keys.
+2. Run a successful mutation and assert only intended queries refresh.
+3. Run a failed mutation and assert nothing invalidates.
+4. Dispose the queries and assert invalidation handlers are removed.
+
+## Strict Mode and action ownership
+
+Render the owner inside `StrictMode`. Prove development setup-cleanup replay
+does not write `Atom.Interrupt` or publish an interrupted failure before an
+explicit cancellation. For multi-request actions, unmount during the sequence
+and prove the chosen policy. If the atom is shared, prove unmounting one
+consumer does not cancel work still owned by another.
+
+## Aggregate stability
+
+Mount a route atom using `AsyncResult.all`, resolve every input, unmount, and
+remount inside the retention window. Assert the aggregate never returns to
+`Initial`. Then expire one input and prove that input causes the reset.
+
+For runtime/layer tests, seed `runtime.layer` through `RegistryProvider`
+`initialValues` with a deterministic test layer. Replace network services
+without changing the production atom graph.

package/skills/build-effect-apis/references/runtime-assembly.md

@@ -0,0 +1,56 @@
+# Standard runtime assembly
+
+Use this branch for conventional Node/Bun processes, generated documentation,
+and Web-standard handlers. Confirm platform package names against the installed
+versions.
+
+## Compose routes before choosing the runtime
+
+```ts
+import { NodeHttpServer, NodeRuntime } from "@effect/platform-node";
+import { Layer } from "effect";
+import { HttpRouter, HttpServer } from "effect/unstable/http";
+import { HttpApiBuilder, HttpApiScalar } from "effect/unstable/httpapi";
+import { createServer } from "node:http";
+import { ApplicationApi } from "@app/domain/http";
+
+const ApplicationHttpLive = Layer.mergeAll(ProjectsHandlersLive, AuthenticateLive).pipe(
+  Layer.provide(ApplicationServicesLive),
+);
+
+const ApiRoutes = HttpApiBuilder.layer(ApplicationApi, {
+  openapiPath: "/openapi.json",
+}).pipe(Layer.provide(ApplicationHttpLive));
+
+const DocsRoute = HttpApiScalar.layer(ApplicationApi, { path: "/docs" });
+const AllRoutes = Layer.mergeAll(ApiRoutes, DocsRoute);
+```
+
+Build the typed API route and documentation route from the same contract. Merge
+raw routes here only when the API schema cannot represent their transport, and
+ensure they independently enforce equivalent identity and security behavior.
+
+## Run a long-lived server
+
+```ts
+const HttpServerLive = HttpRouter.serve(AllRoutes).pipe(
+  Layer.provide(NodeHttpServer.layer(createServer, { port: 3000 })),
+);
+
+Layer.launch(HttpServerLive).pipe(NodeRuntime.runMain);
+```
+
+Use the matching platform server layer for Bun or another runtime. Keep the
+platform choice at this composition root.
+
+## Export a Web handler
+
+```ts
+export const { handler, dispose } = HttpRouter.toWebHandler(
+  AllRoutes.pipe(Layer.provide(HttpServer.layerServices)),
+);
+```
+
+Use the Web handler for serverless and framework adapters that accept standard
+`Request` and `Response` values. Preserve and call `dispose` when the host has a
+lifecycle hook; do not recreate the handler and its runtime for every request.

package/skills/build-effect-apis/references/server-and-middleware.md

@@ -0,0 +1,174 @@
+# Server handlers and middleware
+
+Implement the shared contract with group handlers, application services, and
+layers. Confirm names against the installed Effect version; examples here use
+the Effect v4 `effect/unstable/httpapi` surface.
+
+- [Implement thin group handlers](#implement-thin-group-handlers)
+- [Declare security middleware in the shared contract](#declare-security-middleware-in-the-shared-contract)
+- [Implement security middleware on the server](#implement-security-middleware-on-the-server)
+- [Assemble layers at the runtime edge](#assemble-layers-at-the-runtime-edge)
+- [Use response escape hatches deliberately](#use-response-escape-hatches-deliberately)
+
+## Implement thin group handlers
+
+Resolve application services once in the group builder, then map every endpoint
+identifier to one handler. Use `Effect.fn` for callbacks that return Effects.
+
+```ts
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { ApplicationApi } from "@app/domain/http";
+import { Projects } from "../services/Projects";
+
+export const ProjectsHandlersLive = HttpApiBuilder.group(
+  ApplicationApi,
+  "projects",
+  Effect.fn("ProjectsApi.handlers")(function* (handlers) {
+    const projects = yield* Projects;
+
+    return handlers
+      .handle("listProjects", () => projects.list().pipe(Effect.orDie))
+      .handle("getProject", ({ params }) =>
+        projects
+          .get(params.projectId)
+          .pipe(Effect.catchReasons("ProjectsError", { ProjectNotFound: Effect.fail }, Effect.die)),
+      );
+  }),
+);
+```
+
+Handlers receive decoded `params`, `query`, `headers`, and `payload`. Check
+cross-field invariants at this boundary when schemas cannot express them, then
+call one application workflow. Keep persistence, transactions, retries, and
+multi-service orchestration in services.
+
+Reconcile the service error channel with the endpoint contract here. Use
+`Effect.orDie` when an endpoint declares no service failures. Use
+`Effect.catchReason`, `Effect.catchReasons`, or `Effect.unwrapReason` when an
+application service wraps domain reasons: re-fail only reasons declared by the
+endpoint and turn unexpected infrastructure or invariant failures into defects.
+Finish when each handler's expected error type is a subset of the endpoint's
+declared error schema.
+
+## Declare security middleware in the shared contract
+
+Keep the middleware declaration in the shared contract package so server,
+OpenAPI, and generated clients see the same requirement. Keep its implementation
+out of that package.
+
+```ts
+// packages/domain/src/http/authorization.ts
+import { Context, Schema } from "effect";
+import { HttpApiGroup, HttpApiMiddleware, HttpApiSecurity } from "effect/unstable/httpapi";
+
+export class CurrentActor extends Context.Service<CurrentActor, { readonly id: string }>()(
+  "app/CurrentActor",
+) {}
+
+export class Unauthorized extends Schema.TaggedError<Unauthorized>()(
+  "Unauthorized",
+  { message: Schema.String },
+  { httpApiStatus: 401 },
+) {}
+
+export class Authenticate extends HttpApiMiddleware.Service<
+  Authenticate,
+  {
+    readonly provides: CurrentActor;
+    readonly requires: never;
+  }
+>()("app/Authenticate", {
+  requiredForClient: true,
+  security: { bearer: HttpApiSecurity.bearer },
+  error: Unauthorized,
+}) {}
+
+export const ProjectsApi = HttpApiGroup.make("projects")
+  .add(GetProjectEndpoint, ListProjectsEndpoint)
+  .middleware(Authenticate)
+  .prefix("/projects");
+```
+
+`requiredForClient` makes the generated client require a matching client-side
+middleware layer. The security declaration also owns credential decoding and
+OpenAPI security metadata; do not manually decode an `Authorization` header for
+this case.
+
+## Implement security middleware on the server
+
+A security middleware implementation is keyed by the names in its `security`
+object. It can use server-only services without leaking them into clients.
+
+```ts
+// apps/api/src/http/Authenticate.ts
+import { Effect, Layer, Redacted } from "effect";
+import { Authenticate, CurrentActor, Unauthorized } from "@app/domain/http";
+import { Actors } from "../services/Actors";
+
+export const AuthenticateLive = Layer.effect(
+  Authenticate,
+  Effect.gen(function* () {
+    const actors = yield* Actors;
+
+    return Authenticate.of({
+      bearer: Effect.fn("Authenticate.bearer")(function* (httpEffect, { credential }) {
+        const actor = yield* actors
+          .authenticate(Redacted.value(credential))
+          .pipe(
+            Effect.catch(() => Effect.fail(new Unauthorized({ message: "Invalid bearer token" }))),
+          );
+
+        return yield* Effect.provideService(httpEffect, CurrentActor, actor);
+      }),
+    });
+  }),
+);
+```
+
+Use ordinary `HttpApiMiddleware.Service` implementations for request logging,
+tenancy, correlation IDs, or other cross-cutting work that is not a declared
+security scheme. Those implementations may access `HttpServerRequest`, but they
+must decode raw headers, cookies, and external values before providing services.
+When middleware uses `requires` and `provides`, confirm ordering from the
+installed docs: the outer middleware that requires a service is attached before
+the inner middleware that provides it.
+
+Every error a middleware can return belongs in its `error` schema. Keep the
+server layer separate from the shared declaration so importing the contract
+never pulls secrets, repositories, or platform services into a client bundle.
+
+## Assemble layers at the runtime edge
+
+```ts
+const ProjectsHandlersProvided = ProjectsHandlersLive.pipe(Layer.provide(ApplicationServicesLive));
+
+const ApiLive = HttpApiBuilder.layer(ApplicationApi, {
+  openapiPath: "/api/openapi.json",
+}).pipe(
+  Layer.provide(ProjectsHandlersProvided),
+  Layer.provide(AuthenticateLive),
+  Layer.provideMerge(HttpRuntimePrerequisitesLive),
+);
+```
+
+The exact HTTP platform/router/server layers vary by runtime. Keep that wiring
+at the entrypoint, provide all group and middleware layers, and let the type
+system expose missing requirements. Verify that the OpenAPI path composes with
+any API prefix as intended.
+
+For a conventional Node/Bun process, generated docs route, or serverless web
+handler, read [runtime-assembly.md](runtime-assembly.md).
+
+Transport-wide middleware such as CORS may wrap the final HTTP application.
+Keep API middleware for contract-visible behavior and runtime HTTP middleware
+for concerns that also apply to raw or non-API routes.
+
+## Use response escape hatches deliberately
+
+Return typed success values and declared errors for ordinary endpoints. Use
+`HttpServerResponse` when the boundary must pass through an upstream response,
+redirect, set cookies, stream, or control a non-default success status or body.
+Use Effect request and cookie APIs to parse boundary state. Reserve unsafe JSON
+response constructors for values whose safety is established elsewhere; encode
+ordinary typed 4xx failures through the endpoint's declared error schemas.

package/skills/build-effect-apis/references/shared-contracts.md

@@ -0,0 +1,108 @@
+# Shared contracts
+
+Use a runtime-neutral domain package as the protocol boundary shared by the
+server and every typed client.
+
+## Package shape
+
+```text
+packages/domain/
+├── package.json
+└── src/
+    ├── models/
+    │   ├── ids.ts
+    │   ├── errors.ts
+    │   └── views.ts
+    └── http/
+        ├── endpoints/
+        │   ├── get-project.ts
+        │   └── update-project.ts
+        ├── authorization.ts
+        ├── project-api.ts
+        ├── application-api.ts
+        └── index.ts
+```
+
+Export the root API, contract-visible middleware declarations, and any genuinely
+reusable schemas. Keep middleware implementations, server handlers, React,
+database clients, secrets, platform bindings, and runtime layers out of this
+package. A workspace export map can expose `./http`, `./models`, and endpoint
+subpaths when consumers need them.
+
+## Model the wire
+
+Use schemas for every external value. Prefer reusable named classes for DTOs,
+branded scalar schemas for identifiers, and serializable tagged errors with
+HTTP status metadata for expected failures.
+
+```ts
+import { Schema } from "effect";
+import { HttpApiSchema } from "effect/unstable/httpapi";
+
+export const ProjectId = Schema.String.pipe(Schema.brand("ProjectId"));
+export type ProjectId = typeof ProjectId.Type;
+
+export class ProjectDto extends Schema.Class<ProjectDto>("ProjectDto")({
+  id: ProjectId,
+  name: Schema.NonEmptyString,
+}) {}
+
+export class ProjectNotFoundError extends Schema.TaggedError<ProjectNotFoundError>()(
+  "ProjectNotFoundError",
+  { id: ProjectId },
+) {}
+
+export const ProjectNotFound = ProjectNotFoundError.pipe(HttpApiSchema.status("NotFound"));
+```
+
+Keep success schemas limited to successful values. Put every expected 4xx/5xx
+failure in `error`; defects remain defects. Reuse a tuple of transport errors
+only when the same set is genuinely standard across endpoints.
+
+Make DTOs describe the wire exactly. If clients receive `id`, expose `id` even
+when a persistence model uses `publicId`; map between them in a small boundary
+function. Keep endpoint-specific request DTOs beside their endpoint and move a
+DTO into shared models only when multiple contracts reuse the same concept.
+
+## Define one endpoint per file
+
+An endpoint declares the complete request and response contract inline.
+
+```ts
+import { HttpApiEndpoint } from "effect/unstable/httpapi";
+import { ProjectDto, ProjectId, ProjectNotFound } from "../../models";
+import { RequestHeaders } from "../headers";
+
+export const GetProjectEndpoint = HttpApiEndpoint.get("getProject", "/projects/:projectId", {
+  params: { projectId: ProjectId },
+  headers: RequestHeaders,
+  success: ProjectDto,
+  error: ProjectNotFound,
+});
+```
+
+Use the operation identifier as a stable protocol name: handlers and generated
+clients address it directly. Represent optional query values with the installed
+version's optional schema operator, such as `Schema.optionalKey`.
+
+If headers use `Schema.Class`, generated client input may require a constructed
+class instance rather than a structurally similar object. Encode a representative
+instance in a test so this contract stays explicit.
+
+## Compose groups and the root
+
+```ts
+import { HttpApi, HttpApiGroup } from "effect/unstable/httpapi";
+import { GetProjectEndpoint, UpdateProjectEndpoint } from "./endpoints";
+
+export const ProjectsApi = HttpApiGroup.make("projects")
+  .add(GetProjectEndpoint, UpdateProjectEndpoint)
+  .prefix("/projects");
+
+export const ApplicationApi = HttpApi.make("application").add(ProjectsApi).prefix("/api");
+```
+
+Group and root files compose; endpoint files specify. Re-export through index
+files so server and clients import the same `ApplicationApi` value. A contract
+change is complete only after all affected handlers, callers, tests, and
+OpenAPI output agree with it.

package/skills/build-effect-apis/references/tanstack-start.md

@@ -0,0 +1,86 @@
+# TanStack Start integration
+
+TanStack Start modules are isomorphic unless an explicit boundary says
+otherwise. Choose one data-execution model before wiring Effect Atom.
+
+## Client-only atom data
+
+Use this when identity, focus signals, or other dependencies require browser
+globals.
+
+1. Mount one `RegistryProvider` around the application subtree whose client
+   navigations should share cache state.
+2. Put browser-dependent atom consumers behind `ClientOnly`.
+3. Keep the runtime, `AtomHttpApi.Service`, query families, and mutations as
+   client module singletons.
+4. Render a useful server fallback and accept that API fetching begins after
+   hydration.
+
+```tsx
+import { RegistryProvider } from "@effect/atom-react";
+import { ClientOnly, Outlet } from "@tanstack/react-router";
+
+export function Root() {
+  return (
+    <RegistryProvider defaultIdleTTL={60_000}>
+      <ClientOnly fallback={<AppSkeleton />}>
+        <Outlet />
+      </ClientOnly>
+    </RegistryProvider>
+  );
+}
+```
+
+`Atom.windowFocusSignal`, `localStorage`, `window`, and `document` belong in
+this client-only branch.
+
+## SSR or loader-owned data
+
+Prefer TanStack loaders or server functions when they already own SSR data.
+Pass loader data into the client state graph or keep the query loader-owned;
+avoid maintaining two independent server caches for the same request.
+
+When atom SSR is intentional:
+
+- create the registry and request-specific runtime/layers per request;
+- give serializable queries deterministic `serializationKey` values;
+- mount or run only the intended serializable atoms on the server;
+- dehydrate only intended values;
+- create the browser registry once and hydrate matching atom identities before
+  descendants read them;
+- use `HydrationBoundary` when the installed React adapter supports it.
+
+Process-global registries or memo maps can leak request-specific authentication
+and server state across users. Verify request isolation with concurrent SSR
+tests.
+
+## Focus is browser-only
+
+`Atom.windowFocusSignal` reads `window` and `document.visibilityState` when
+mounted. Keep focus-enabled consumers behind `ClientOnly`, or inject a no-op
+server signal and the browser signal on the client. `revalidateOnFocus: true`
+respects `staleTime`; `"always"` forces a request on each focus signal.
+
+## Separate API development
+
+When TanStack Start and the Effect API run as separate local processes, proxy a
+stable prefix and WebSocket upgrades through the app dev server:
+
+```ts
+export default defineConfig({
+  plugins: [tanstackStart(), react()],
+  server: {
+    proxy: {
+      "/api": {
+        target: "http://127.0.0.1:8787",
+        changeOrigin: true,
+        ws: true,
+      },
+    },
+  },
+});
+```
+
+Keep the client base URL aligned with proxy and production routing. If
+credentials cross origins, configure CORS and cookie/header behavior at the API
+edge and test the deployed topology, not only the same-origin development path.

package/skills/build-effect-apis/references/verification.md

@@ -0,0 +1,50 @@
+# Verification
+
+Test the contract spine at its seams. Use the repository's established Effect
+test integration and command authority.
+
+## Contract tests
+
+- Decode and re-encode representative request, success, and error values.
+- Prove branded path/query/header values reject invalid wire input.
+- Encode any `Schema.Class` headers exactly as generated clients receive them.
+- Assert each expected error carries the intended HTTP status and body encoding.
+- Compare or smoke-test generated OpenAPI when the public contract changes.
+
+## Server tests
+
+- Build every changed group and fail the test if an endpoint handler is missing.
+- Provide deterministic test layers for application services and middleware.
+- Prove each handler exposes only errors declared by its endpoint; exercise
+  expected reason mapping and unexpected failure defects separately.
+- Exercise success, declared failure, malformed input, and middleware rejection.
+- Assert cross-field boundary invariants before the service workflow runs.
+- Exercise raw routes separately and prove they enforce middleware-equivalent
+  identity/security rules.
+
+Use the installed `HttpApiTest` or an in-memory `HttpClient` when available;
+otherwise run the built HTTP application against representative requests. Avoid
+mocking below the contract so heavily that request encoding and response
+decoding are skipped.
+
+## Client tests
+
+- Derive the client from the same root API used by the server.
+- Provide every `requiredForClient` middleware with
+  `HttpApiMiddleware.layerClient` and assert that it transforms the request.
+- Assert params, query, headers, payload, and expected errors at least once for
+  every changed request shape.
+- For Atom clients, complete every applicable scenario routed through
+  `effect-atom-testing.md`; use a deterministic HTTP layer so request encoding,
+  invalidation, and lifecycle remain observable.
+
+## Completion matrix
+
+Account for every changed endpoint across these columns:
+
+| Contract                                         | Middleware                       | Handler/service                  | Client/query/mutation                          | Tests                            |
+| ------------------------------------------------ | -------------------------------- | -------------------------------- | ---------------------------------------------- | -------------------------------- |
+| Params, query, headers, payload, success, errors | Scope, provided services, errors | Identifier, invariants, workflow | Typed call shape, identity, cache/invalidation | Round-trip and boundary behavior |
+
+Completion means every changed endpoint has an entry in every applicable
+column and the repository's formatter, linter, typechecker, and tests pass.