@danieljvdm/dev-kit 0.7.2 → 0.9.0

package/README.md

@@ -193,8 +193,9 @@ tool versions. A project-local process lock also prevents concurrent applies.
 ```
 
 - `dev-kit` installs guidance for operating the toolkit itself.
-- `effect` expands to `effect-ts` plus focused Effect Atom HTTP data-fetching
-  guidance.
+- `effect` expands to the `effect-ts` umbrella, whose lazy references include
+  Effect Atom HTTP data fetching and Effect DateTime guidance. The former
+  `effect-atom-data-fetching` selector remains an alias for compatibility.
 - Prefer individual external skills such as `workers-best-practices` and
   `wrangler`, selected after scanning the project for relevant technologies.
 - `serve-sim` selects the approved Evan Bacon simulator skill directly.
@@ -259,8 +260,8 @@ worktree converges its own copy during install while the project-owned
 
 ## Vite+ quality setup
 
-Supported Vite+/Effect repositories can explicitly opt into Dev Kit's canonical
-quality configuration and GitHub Actions workflow:
+Vite+/Effect repositories opt into the canonical Vite config and GitHub Actions
+workflow independently:
 
 ```jsonc
 {
@@ -269,27 +270,27 @@ quality configuration and GitHub Actions workflow:
     "effectTsgo": { "enabled": true },
     "vitePlus": {
       "hooks": { "enabled": true },
-      "quality": { "enabled": true },
+      "quality": {
+        "config": { "enabled": true },
+        "workflow": { "enabled": true },
+      },
     },
   },
 }
 ```
 
-The quality task requires direct `@danieljvdm/dev-kit`, `vite-plus`, `effect`,
-`@effect/tsgo`, and native TypeScript dependencies, plus the enabled Effect
-TypeScript-Go patch. The installed Vite+ version must satisfy Dev Kit's
-`vite-plus` peer range; Dev Kit tests one exact development version inside that
-range, while CI lets `setup-vp` resolve the consumer's version from its own
-manifest and lockfile. It manages `vite.config.ts` and
-`.github/workflows/check.yml` as digest-owned files. Existing custom files or
-conflicting `check`/`typecheck` package scripts are rejected instead of merged
-or overwritten. Exact canonical files can be adopted; disabling the task
-removes only unchanged owned files.
+`quality.config.enabled` owns `vite.config.ts`; `quality.workflow.enabled` owns
+`.github/workflows/check.yml`. Selecting one does not impose the other resource's
+config, scripts, or TypeScript topology. Both require direct
+`@danieljvdm/dev-kit`, `vite-plus`, `effect`, `@effect/tsgo`, and native
+TypeScript dependencies with `setup.effectTsgo.enabled`. The installed Vite+
+must satisfy Dev Kit's peer range.
 
 The managed Vite config composes the shared Oxfmt and Oxlint presets, configures
 `vp staged`, and defines separate `vp run check` and pure `vp run typecheck`
-tasks. The default `single-project` strategy runs one `tsc --noEmit` process and
-requires a root `tsconfig.json` without project references:
+tasks. It rejects conflicting root scripts. The default `single-project`
+strategy requires a root `tsconfig.json` without project references. Workspaces
+can instead select Vite Task orchestration explicitly:
 
 ```jsonc
 {
@@ -297,15 +298,28 @@ requires a root `tsconfig.json` without project references:
     "effectTsgo": { "enabled": true },
     "vitePlus": {
       "quality": {
-        "enabled": true,
-        "typecheck": { "strategy": "single-project" },
+        "config": {
+          "enabled": true,
+          "typecheck": {
+            "strategy": "workspace",
+            "concurrency": 4,
+            "packages": ["apps/web", "packages/core"],
+          },
+        },
       },
     },
   },
 }
 ```
 
-Workspaces can instead opt into Vite Task orchestration explicitly:
+Workspace mode requires `package.json#workspaces` and an explicit list of
+package directories with pure `typecheck` scripts. The generated task uses
+dependency order, caching, `--fail-if-no-match`, and bounded concurrency.
+Project-reference builds remain custom because their `.tsbuildinfo` inputs and
+outputs are repository-specific.
+
+Repositories with a custom Vite config can still adopt only the hardened CI
+workflow and declare repository-specific preparation and typecheck commands:
 
 ```jsonc
 {
@@ -313,11 +327,18 @@ Workspaces can instead opt into Vite Task orchestration explicitly:
     "effectTsgo": { "enabled": true },
     "vitePlus": {
       "quality": {
-        "enabled": true,
-        "typecheck": {
-          "strategy": "workspace",
-          "concurrency": 4,
-          "packages": ["apps/web", "packages/core"],
+        "workflow": {
+          "enabled": true,
+          "beforeChecks": [
+            {
+              "name": "Install media tools",
+              "run": ["sudo apt-get update", "sudo apt-get install --yes ffmpeg"],
+            },
+          ],
+          "typecheck": [
+            "vp run -F './apps/*' -F './packages/*' check",
+            "vp exec tsc --noEmit -p scripts/tsconfig.json",
+          ],
         },
       },
     },
@@ -325,31 +346,19 @@ Workspaces can instead opt into Vite Task orchestration explicitly:
 }
 ```
 
-Workspace mode requires `package.json#workspaces` and an explicit list of
-project-relative package directories. Each listed package must define a pure
-`typecheck` package script. Dev Kit generates Vite+ filters for exactly that
-scope with `--fail-if-no-match`; Vite Task uses ordinary workspace dependency
-order, forces script caching on, and bounds concurrency to the configured value
-(1–32). Dev Kit does not generate a project-reference mode: repositories that
-need `tsc -b` must keep the quality setup disabled and define a custom Vite task
-with deliberate `.tsbuildinfo` inputs and outputs.
-
-Generated CI performs exactly one `vp install` through
-`voidzero-dev/setup-vp`, using `--frozen-lockfile --ignore-scripts`, then runs
-`vp exec dev-kit apply --locked` before quality checks. This verifies the
-committed Dev Kit lock and explicitly converges the Effect TypeScript-Go patch
-without relying on a consumer lifecycle script or running an unlocked apply.
-Vite+ maps those install flags to the detected npm, pnpm, Yarn, or Bun project;
-the workflow does not pretend their native immutable/no-script flags are
-interchangeable.
-The template pins the exact commit for a supported `setup-vp` release because
-its `v1` tag is frozen; keep the annotated release commit current with Renovate
-or Dependabot. See the primary
+Workflow-only setup does not validate or take ownership of the Vite config,
+scripts, or TypeScript topology. It performs one frozen, script-suppressed
+install, runs `dev-kit apply --locked`, and only then runs custom preparation,
+formatting, linting, tests, and typechecking. Its default typecheck command is
+`vp run typecheck`; `workflow.typecheck` replaces it. Vite+ maps install flags
+to the detected package manager. The template pins an exact `setup-vp` release
+commit because its `v1` tag is frozen; keep it current with Renovate or
+Dependabot. Existing workflows remain user-owned until their rendered content
+matches exactly—Dev Kit never merges YAML. See the primary
 [`setup-vp` versioning guidance](https://github.com/voidzero-dev/setup-vp#versioning),
 [Vite+ install guide](https://viteplus.dev/guide/install), and
-[Vite Task run guide](https://viteplus.dev/guide/run) when maintaining these
-templates. The check task and CI then run `vp fmt --check`, `vp lint`,
-`vp test`, and `vp run typecheck`.
+[Vite Task run guide](https://viteplus.dev/guide/run) when maintaining the
+templates.
 
 ## Effect source checkout
 
@@ -413,8 +422,7 @@ native TypeScript compiler. It does not download dependencies and skips an
 installation that is already patched. Use `dev-kit tsgo patch --dry-run` when
 troubleshooting the task directly.
 
-Dependency and `tsconfig.json` edits remain explicit. Enable the Vite+ quality
-task only when Dev Kit can own the canonical root config and GitHub workflow.
+Dependency and `tsconfig.json` edits remain explicit.
 
 ## Installed package skills
 
@@ -547,9 +555,8 @@ Use `lint.extends` rather than a shallow object spread so Vite+ composes the
 nested plugin and rule configuration correctly. Oxfmt has no `extends`, so
 spread its configuration before project-local formatter options. The shared
 lint preset enables `typeAware` for semantic lint rules but leaves `typeCheck`
-disabled. The opt-in `setup.vitePlus.quality` task manages this composition for
-repositories that use the canonical config; custom configs keep the task
-disabled and compose the exports manually. Effect TypeScript-Go projects run:
+disabled. Managed quality config uses this composition; custom Vite configs
+compose the exports manually. Effect TypeScript-Go projects run:
 
 ```sh
 vp fmt --check

package/dev-kit.example.jsonc

@@ -9,8 +9,11 @@
     "vitePlus": {
       "hooks": { "enabled": true },
       "quality": {
-        "enabled": true,
-        "typecheck": { "strategy": "single-project" },
+        "config": {
+          "enabled": true,
+          "typecheck": { "strategy": "single-project" },
+        },
+        "workflow": { "enabled": true },
       },
     },
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieljvdm/dev-kit",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "private": false,
   "description": "Declarative project development toolkit with portable agent skills.",
   "license": "MIT",

package/schema/dev-kit.schema.json

@@ -161,7 +161,20 @@
       }
     },
     "vitePlusQualitySetup": {
-      "description": "Manage the canonical Vite+ quality config and GitHub Actions workflow for supported Effect TypeScript-Go repositories.",
+      "description": "Opt into independently managed Vite+ quality resources for supported Effect TypeScript-Go repositories.",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "config": {
+          "$ref": "#/$defs/vitePlusQualityConfigSetup"
+        },
+        "workflow": {
+          "$ref": "#/$defs/vitePlusQualityWorkflowSetup"
+        }
+      }
+    },
+    "vitePlusQualityConfigSetup": {
+      "description": "Manage the canonical root Vite config without requiring Dev Kit to own CI.",
       "type": "object",
       "additionalProperties": false,
       "properties": {
@@ -174,6 +187,54 @@
         }
       }
     },
+    "vitePlusQualityWorkflowSetup": {
+      "description": "Manage the canonical GitHub Actions check workflow without requiring Dev Kit to own the Vite config.",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "default": false
+        },
+        "beforeChecks": {
+          "description": "Repository-specific preparation steps inserted after locked setup verification and before quality checks.",
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/vitePlusQualityWorkflowStep"
+          },
+          "default": []
+        },
+        "typecheck": {
+          "description": "Shell commands for the workflow's pure typecheck step.",
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "string",
+            "minLength": 1
+          },
+          "default": ["vp run typecheck"]
+        }
+      }
+    },
+    "vitePlusQualityWorkflowStep": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["name", "run"],
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "run": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        }
+      }
+    },
     "vitePlusQualityTypecheckSetup": {
       "description": "Select the managed typecheck topology. Single-project is the default; workspace mode runs explicitly scoped package scripts through Vite Task.",
       "type": "object",

package/skill-sources.jsonc

@@ -47,5 +47,13 @@
       "include": ["serve-sim"],
       "licensePath": "LICENSE",
     },
+    {
+      "id": "mattpocock-skills",
+      "repository": "https://github.com/mattpocock/skills.git",
+      "ref": "main",
+      "skillsPath": "skills/engineering",
+      "include": ["tdd", "improve-codebase-architecture"],
+      "licensePath": "LICENSE",
+    },
   ],
 }

package/skill-sources.lock.json

@@ -125,6 +125,24 @@
         "serve-sim": "sha256:782f41d4d79100d5bfc9ec1211e5d4766e978299bbb93fd8e34c6f8d2ecf2114"
       },
       "licensePath": "LICENSE"
+    },
+    {
+      "id": "mattpocock-skills",
+      "repository": "https://github.com/mattpocock/skills.git",
+      "ref": "main",
+      "resolved": "2ab958093e83e0ec752e6c1c5932da465bf23e0c",
+      "skillsPath": "skills/engineering",
+      "include": ["tdd", "improve-codebase-architecture"],
+      "skills": ["improve-codebase-architecture", "tdd"],
+      "descriptions": {
+        "improve-codebase-architecture": "Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.",
+        "tdd": "Test-driven development. Use when the user wants to build features or fix bugs test-first, mentions \"red-green-refactor\", or wants integration tests."
+      },
+      "digests": {
+        "improve-codebase-architecture": "sha256:43721b6125a4c703810414e649fbbab252f1f85a62385cdb23f313e0e06ba26a",
+        "tdd": "sha256:ea2d26eda005b10a2de4bdb7de44d33072f2a8e82dbf670952ce30a9c2d7c475"
+      },
+      "licensePath": "LICENSE"
     }
   ]
 }

package/skills/dev-kit/SKILL.md

@@ -76,7 +76,10 @@ skill as `dev-kit` when project agents should carry the toolkit procedure.
     "claudeInstructions": { "enabled": true },
     "vitePlus": {
       "hooks": { "enabled": true },
-      "quality": { "enabled": true },
+      "quality": {
+        "config": { "enabled": true },
+        "workflow": { "enabled": true },
+      },
     },
   },
   "targets": {
@@ -109,34 +112,26 @@ ignored dispatchers in linked worktrees. Preserve other hook managers; Dev Kit
 refuses to replace an unrelated `core.hooksPath`. Use `VITE_GIT_HOOKS=0` or
 `HUSKY=0` to skip hook setup for an invocation.
 
-Enable `setup.vitePlus.quality` only in supported Vite+/Effect repositories
-that explicitly want Dev Kit to own the canonical root `vite.config.ts` and
-`.github/workflows/check.yml`. It requires direct Dev Kit, Vite+, Effect,
-Effect TypeScript-Go, and native TypeScript dependencies, as well as
-`setup.effectTsgo.enabled`. It refuses custom destination files and conflicting
-`check` or `typecheck` package scripts. Exact canonical files can be adopted;
-later updates and cleanup occur only while the owned files remain unchanged.
-The installed Vite+ version must satisfy Dev Kit's package peer range; generated
-CI resolves the consumer's locked Vite+ rather than carrying a second version
-literal.
-
-The managed Vite config composes the shared formatter and linter presets,
-configures `vp staged`, and defines separate cached `check` and pure `typecheck`
-Vite tasks. The default `single-project` typecheck strategy runs
-`tsc --noEmit` and rejects root TypeScript project references. An explicit
-`workspace` strategy requires explicit package directories with consumer-owned
-`typecheck` scripts, then runs exactly that filter scope in workspace dependency
-order with caching enabled, unmatched-filter failure, and configurable bounded
-concurrency. Project-reference builds remain custom because they need
-repository-specific `.tsbuildinfo` inputs and outputs.
-
-The GitHub Actions workflow uses one frozen, script-suppressed install through
-an exact `setup-vp` release, then runs `vp exec dev-kit apply --locked`. This
-verifies the committed setup and converges the Effect TypeScript-Go patch before
-formatting, linting, tests, and typechecking. Vite+ maps the frozen and
-ignore-scripts flags to the detected package manager. Keep the exact setup
-action release commit current with Renovate or Dependabot; do not switch back
-to the frozen `v1` tag.
+Enable `setup.vitePlus.quality.config` and
+`setup.vitePlus.quality.workflow` independently in supported Vite+/Effect
+repositories. Config owns canonical root `vite.config.ts`; workflow owns
+`.github/workflows/check.yml`; selecting one must not constrain the other's
+config, scripts, or TypeScript topology. Both require direct Dev Kit, compatible
+Vite+, Effect, Effect TypeScript-Go, and native TypeScript dependencies with
+`setup.effectTsgo.enabled`. Preserve unowned destinations and adopt only exact
+rendered matches.
+
+Managed config defines separate `check` and pure `typecheck` Vite tasks. Its
+default single-project strategy rejects project references; workspace mode
+requires explicit package directories with `typecheck` scripts and generates
+cached, dependency-ordered, bounded-concurrency filters. Keep project-reference
+builds custom. Workflow-only consumers may configure `workflow.beforeChecks`
+and `workflow.typecheck`; treat these commands as trusted manifest input.
+
+The workflow must use one frozen, script-suppressed install, then locked Dev Kit
+convergence before preparation or checks. Keep `setup-vp` pinned to a reviewed
+release commit—the `v1` tag is frozen—and let Vite+ resolve the consumer's
+compatible locked version.
 
 ## Ownership and conflicts
 
@@ -270,8 +265,8 @@ in the consuming project.
 
 Manage skill outputs, the `setup.agentInstructions` wrapper, the
 `setup.claudeInstructions` link, the `setup.vitePlus.hooks` dispatcher, the
-opt-in `setup.vitePlus.quality` config and GitHub workflow, the
+independently opt-in `setup.vitePlus.quality` config and GitHub workflow, the
 `setup.effectSource` checkout, and the explicit `setup.effectTsgo` task.
 Dependency and `tsconfig.json` contributions remain deliberate user-owned
-edits. Custom Vite configs compose the Oxlint and Oxfmt package exports manually
-and leave the canonical quality task disabled.
+edits. Custom Vite configs compose the Oxlint and Oxfmt package exports
+manually, leave managed config disabled, and may still use the managed workflow.

package/skills/effect-ts/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: effect-ts
-description: Use this skill whenever working in a repository that uses Effect, even if the current task is in a new file or the user does not explicitly ask for Effect help. Apply it to Effect patterns, services, layers, schemas, streams, runtimes, typed errors, observability, testing, HTTP, SQL, command-line scripts, project automation, and supporting tooling.
+description: Use this skill whenever working in a repository that uses Effect, even if the current task is in a new file or the user does not explicitly ask for Effect help. Apply it to Effect patterns, services, layers, schemas, streams, runtimes, typed errors, DateTime, Effect Atom, observability, testing, HTTP, SQL, command-line scripts, project automation, and supporting tooling.
 ---
 
 # Effect Expert
@@ -106,6 +106,19 @@ When the task touches one of these areas, consult the matching guide before impl
 - `./references/guide-schedule.md` for retries, repeats, backoff, polling, cron, and schedule composition
 - `./references/guide-schema.md` for schema-first application modeling,
   service contracts, transformations, unions, recursion, and branded types
+- `./references/guide-datetime.md` for current time, parsing, UTC and zoned
+  values, time zones, DST-safe arithmetic, formatting, Date interoperability,
+  and deterministic `TestClock` tests
+- `./references/guide-atom-data-fetching.md` for the core Effect Atom HTTP
+  data-fetching workflow and ownership rules
+- `./references/atom-cache-lifecycle.md` for Effect Atom registry scope,
+  runtime memoization, families, TTL, SWR, polling, and aggregation resets
+- `./references/atom-http-and-invalidation.md` for `AtomHttpApi.Service`,
+  queries, mutations, reactivity keys, and invalidation
+- `./references/atom-tanstack-start.md` only for TanStack Start provider
+  placement, SSR isolation, hydration, and focus guidance
+- `./references/atom-testing.md` when adding or diagnosing deterministic Effect
+  Atom lifecycle tests
 - `./references/guide-sql.md` for Effect SQL usage, transactions, resolvers, schema-aware SQL, and migrations
 - `./references/guide-testing.md` for `@effect/vitest`, deterministic testing,
   honest test Layers, property tests, and protocol round trips
@@ -208,6 +221,15 @@ Install additional `@effect/*` packages only when the user task actually needs t
 - If a type is hard to express, simplify the design or introduce a properly typed helper instead of using unsafe TypeScript.
 - For layers, do not hide them inside `namespace` blocks. Prefer either `static` members on the service class or plain exported layer constants.
 
+### Date and Time
+
+- Prefer Effect `DateTime` over vanilla JavaScript `Date` for application
+  logic. Keep `Date` as an interoperability type at external boundaries.
+- Use `DateTime.now` inside Effect programs so current time remains driven by
+  the `Clock` service and deterministic under `TestClock`.
+- Preserve the distinction between instants, zoned wall-clock values, and
+  date-only domain values.
+
 ### Code Quality
 
 - Write type-safe code that leverages Effect's type system.
@@ -233,6 +255,12 @@ rely on installed declarations and version-matched canonical Effect source.
 - `./references/guide-retries.md`
 - `./references/guide-schedule.md`
 - `./references/guide-schema.md`
+- `./references/guide-datetime.md`
+- `./references/guide-atom-data-fetching.md`
+- `./references/atom-cache-lifecycle.md`
+- `./references/atom-http-and-invalidation.md`
+- `./references/atom-tanstack-start.md`
+- `./references/atom-testing.md`
 - `./references/guide-sql.md`
 - `./references/guide-testing.md`
 - `./references/guide-cli.md`

package/skills/effect-ts/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "Effect Expert"
   short_description: "Apply current Effect v4 patterns and tooling"
-  default_prompt: "Use $effect-ts to apply the relevant Effect architecture, schema, service, error, testing, HTTP, SQL, observability, or CLI guidance."
+  default_prompt: "Use $effect-ts to apply the relevant Effect architecture, DateTime, Atom, schema, service, error, testing, HTTP, SQL, observability, or CLI guidance."

package/skills/{effect-atom-data-fetching/references/cache-lifecycle.md → effect-ts/references/atom-cache-lifecycle.md}

@@ -1,4 +1,4 @@
-# Cache lifecycle
+# Effect Atom cache lifecycle
 
 ## Registry and runtime scope
 

package/skills/{effect-atom-data-fetching/references/http-and-invalidation.md → effect-ts/references/atom-http-and-invalidation.md}

@@ -1,4 +1,4 @@
-# HTTP queries and invalidation
+# Effect Atom HTTP queries and invalidation
 
 ## Build one API service
 

package/skills/{effect-atom-data-fetching/references/tanstack-start.md → effect-ts/references/atom-tanstack-start.md}

@@ -1,4 +1,4 @@
-# TanStack Start integration
+# Effect Atom TanStack Start integration
 
 TanStack Start code is isomorphic by default, including route loaders. Treat every module used by a route as server-capable unless an explicit boundary says otherwise.
 

package/skills/{effect-atom-data-fetching/references/testing.md → effect-ts/references/atom-testing.md}

@@ -1,4 +1,4 @@
-# Deterministic lifecycle testing
+# Deterministic Effect Atom lifecycle testing
 
 Test cache policy below React first with `AtomRegistry.make()`. Add a React integration test only for provider placement, hook behavior, a browser-only SSR boundary, or hydration.
 

package/skills/{effect-atom-data-fetching/SKILL.md → effect-ts/references/guide-atom-data-fetching.md}

@@ -1,8 +1,3 @@
----
-name: effect-atom-data-fetching
-description: Design, implement, debug, or review HTTP data fetching with Effect Atom in React applications. Use for AtomHttpApi.Service queries and mutations, parameterized Atom.family caches, RegistryProvider and runtime placement, TTL/SWR/polling behavior, reactivity-key invalidation, framework-appropriate SSR and focus handling, AsyncResult aggregation resets, and deterministic cache lifecycle tests.
----
-
 # Effect Atom Data Fetching
 
 Model server data as stable atoms owned outside React renders. Give the application one intentional registry boundary and one compatible runtime factory; then choose cache retention, freshness, polling, and invalidation independently.
@@ -28,13 +23,6 @@ Model server data as stable atoms owned outside React renders. Give the applicat
 - Ensure every input to a route-level `AsyncResult.all` has stable atom identity and compatible retention. One newly allocated or immediately evicted input returns to `Initial` and makes the whole aggregate appear reset even when the other inputs remain cached.
 - Do not describe manual refresh or polling as freshness caching. Refresh is forceful; `staleTime` only gates SWR's automatic mount/focus decisions.
 
-## References
-
-- Read `./references/cache-lifecycle.md` for registry scope, runtime memoization, families, TTL, SWR, polling, and the aggregation trap.
-- Read `./references/http-and-invalidation.md` for `AtomHttpApi.Service`, query/mutation ownership, reactivity-key vocabulary, and invalidation.
-- Read `./references/tanstack-start.md` only for its framework-specific provider placement, SSR isolation, hydration, and focus guidance.
-- Read `./references/testing.md` when adding or diagnosing lifecycle tests.
-
 ## Completion check
 
 Confirm one registry boundary, stable atom identity, deliberate TTL/staleness/polling values, matching query and mutation keys, SSR-safe browser access, and tests for every lifecycle behavior changed.

package/skills/effect-ts/references/guide-datetime.md

@@ -0,0 +1,72 @@
+# Effect DateTime
+
+Prefer Effect `DateTime` over vanilla JavaScript `Date` for application logic. Keep `Date` as an interoperability type at external boundaries, not the domain model.
+
+## Workflow
+
+1. Inspect the installed `effect` version and `DateTime` source before relying on exact signatures. DateTime APIs are version-sensitive.
+2. Identify whether each value represents an absolute instant, a wall-clock time in a named zone, or only a calendar date. Do not silently collapse these meanings.
+3. Decode external strings, numbers, and `Date` objects at the boundary. Use `Schema.DateTimeUtc`, `Schema.DateTimeUtcFromString`, `Schema.DateTimeUtcFromMillis`, `Schema.DateTimeUtcFromDate`, or `Schema.DateTimeZoned` as appropriate.
+4. Keep domain values as `DateTime.Utc` by default. Use `DateTime.Zoned` when calendar operations or presentation must retain an IANA time zone.
+5. Use `DateTime.now` inside Effect programs so the current time comes from the `Clock` service. Reserve `DateTime.nowUnsafe()` and `Date.now()` for explicit synchronous host boundaries.
+6. Perform comparisons, arithmetic, rounding, and formatting with `DateTime` operations, then convert to `Date` or epoch milliseconds only when an external API requires them.
+7. Test time-dependent behavior with `it.effect` and `TestClock`; advance virtual time instead of sleeping or consulting the live clock.
+
+## Construction and boundaries
+
+- Prefer safe decoding for untrusted input. `DateTime.make` and zoned constructors return `Option`; Schema decoders produce structured parse failures.
+- Use `DateTime.makeUnsafe` only for literals and values already validated by the program. Do not turn user input into defects.
+- Prefer explicit ISO 8601 strings with offsets at wire boundaries. Avoid implementation-dependent or locale-formatted date strings.
+- Do not invent a midnight instant for a genuinely date-only value such as a birthday. Preserve a validated `YYYY-MM-DD` or a domain-specific year/month/day structure until an actual time and zone are chosen.
+- Use `DateTime.makeZonedFromString` or `Schema.DateTimeZoned` when a serialized value must preserve its zone.
+- Use `DateTime.toDateUtc`, `DateTime.toEpochMillis`, and `DateTime.fromDateUnsafe` only at interop boundaries.
+
+```ts
+import { DateTime, Effect, Schema } from "effect";
+
+const Timestamp = Schema.DateTimeUtcFromString;
+
+const expiresAt = DateTime.makeUnsafe("2030-01-01T00:00:00Z");
+
+const isExpired = Effect.gen(function* () {
+  const now = yield* DateTime.now;
+  return DateTime.isLessThanOrEqualTo(expiresAt, now);
+});
+```
+
+## Instants, zones, and arithmetic
+
+- Treat `DateTime.Utc` as an instant without retained zone information. Treat `DateTime.Zoned` as the same kind of instant plus a zone used for wall-clock parts, formatting, and zone-aware transformations.
+- Use `DateTime.setZone` or `setZoneNamed` to view the same instant in another zone. When constructing from local wall-clock parts, use `makeZoned` with `adjustForTimeZone: true` and choose a deliberate `disambiguation` policy for DST gaps and repeated times.
+- Use `DateTime.addDuration` and `subtractDuration` for elapsed time. Use `DateTime.add` and `subtract` for calendar arithmetic such as days, months, and years; these operations account for a zoned value's calendar rules.
+- Use `DateTime.startOf`, `endOf`, or `nearest` rather than hand-editing fields. State `weekStartsOn` when week boundaries are domain-sensitive.
+- Use `DateTime.Order`, `Equivalence`, `min`, `max`, `between`, and comparison helpers rather than comparing formatted strings or mutable `Date` objects.
+- Use `formatIso` for UTC interchange, `formatIsoZoned` when preserving a zone, and `format` / `formatIntl` for presentation. Do not persist locale-formatted output.
+
+## Current time and tests
+
+Code that asks what time it is must remain clock-driven:
+
+```ts
+import { assert, it } from "@effect/vitest";
+import { DateTime, Duration, Effect } from "effect";
+import { TestClock } from "effect/testing";
+
+it.effect("expires after an hour", () =>
+  Effect.gen(function* () {
+    yield* TestClock.setTime(DateTime.toEpochMillis(DateTime.makeUnsafe("2030-01-01T00:00:00Z")));
+    const startedAt = yield* DateTime.now;
+
+    yield* TestClock.adjust("1 hour");
+    const now = yield* DateTime.now;
+
+    assert.strictEqual(Duration.toMillis(DateTime.distance(startedAt, now)), 60 * 60 * 1000);
+  }),
+);
+```
+
+`@effect/vitest` supplies `TestClock` to `it.effect`. Fork work that sleeps, times out, retries, or follows a schedule before advancing the clock. Use `it.live` only when a test intentionally needs real time.
+
+## Completion check
+
+Confirm that domain code uses `DateTime`, untrusted inputs are decoded, UTC versus zoned intent is explicit, DST behavior is deliberate, elapsed and calendar arithmetic are not confused, serialization is stable, and time-dependent tests use `TestClock` without wall-clock sleeps.

package/skills/testing/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: testing
+description: Set an extremely high bar for automated tests. Use whenever software work raises the question of adding, changing, retaining, or removing tests.
+---
+
+# Testing
+
+**If in doubt, don't test it.**
+
+Committed tests must prove durable value. Tests are permanent product code, not a reflexive companion to each source file.
+
+Write a test only when every condition holds:
+
+- It protects stable product behavior rather than an implementation detail.
+- A regression is plausible and would be costly.
+- The behavior is observable through a stable public seam.
+- The test will survive likely refactors.
+- The expected result is independent of the implementation.
+- Existing tests, types, static checks, or a smoke check cannot cover the risk adequately.
+
+If any condition fails, skip the test and use the cheapest sufficient verification instead. Moving MVP behavior often warrants no committed tests.
+
+Test capabilities, not files. Use the fewest tests that protect the risk, and ignore coverage targets unless the user explicitly asks for them.

package/skills/testing/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Testing"
+  short_description: "Set a very high bar for automated tests"
+  default_prompt: "Use $testing to decide whether this change truly warrants any automated tests."

package/src/catalog.ts

@@ -176,7 +176,8 @@ export const loadSkillCatalog = Effect.fn("loadSkillCatalog")(function* (
     });
   }
   const families: Readonly<Record<string, ReadonlyArray<string>>> = {
-    effect: ["effect-ts", "effect-atom-data-fetching"],
+    effect: ["effect-ts"],
+    "effect-atom-data-fetching": ["effect-ts"],
     ...Object.fromEntries(externalFamilies),
   };
 

package/src/index.ts

@@ -11,10 +11,16 @@ export {
   EffectTsgoSetupSchema,
   type HarnessTarget,
   TargetConfigSchema,
+  type VitePlusQualityConfigSetup,
+  VitePlusQualityConfigSetupSchema,
   type VitePlusQualitySetup,
   VitePlusQualitySetupSchema,
   type VitePlusQualityTypecheckSetup,
   VitePlusQualityTypecheckSetupSchema,
+  type VitePlusQualityWorkflowSetup,
+  VitePlusQualityWorkflowSetupSchema,
+  type VitePlusQualityWorkflowStep,
+  VitePlusQualityWorkflowStepSchema,
   type VitePlusSetup,
   VitePlusSetupSchema,
   type VitePlusTypecheckStrategy,

package/src/manifest.ts

@@ -63,10 +63,29 @@ export const VitePlusQualityTypecheckSetupSchema = Schema.Struct({
 });
 export type VitePlusQualityTypecheckSetup = typeof VitePlusQualityTypecheckSetupSchema.Type;
 
-export const VitePlusQualitySetupSchema = Schema.Struct({
+export const VitePlusQualityConfigSetupSchema = Schema.Struct({
   enabled: Schema.optional(Schema.Boolean),
   typecheck: Schema.optional(VitePlusQualityTypecheckSetupSchema),
 });
+export type VitePlusQualityConfigSetup = typeof VitePlusQualityConfigSetupSchema.Type;
+
+export const VitePlusQualityWorkflowStepSchema = Schema.Struct({
+  name: Schema.String,
+  run: Schema.Array(Schema.String),
+});
+export type VitePlusQualityWorkflowStep = typeof VitePlusQualityWorkflowStepSchema.Type;
+
+export const VitePlusQualityWorkflowSetupSchema = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean),
+  beforeChecks: Schema.optional(Schema.Array(VitePlusQualityWorkflowStepSchema)),
+  typecheck: Schema.optional(Schema.Array(Schema.String)),
+});
+export type VitePlusQualityWorkflowSetup = typeof VitePlusQualityWorkflowSetupSchema.Type;
+
+export const VitePlusQualitySetupSchema = Schema.Struct({
+  config: Schema.optional(VitePlusQualityConfigSetupSchema),
+  workflow: Schema.optional(VitePlusQualityWorkflowSetupSchema),
+});
 export type VitePlusQualitySetup = typeof VitePlusQualitySetupSchema.Type;
 
 export const VitePlusSetupSchema = Schema.Struct({
@@ -134,11 +153,18 @@ export type NormalizedManifest = {
         readonly enabled: boolean;
       };
       readonly quality: {
-        readonly enabled: boolean;
-        readonly typecheck: {
-          readonly strategy: VitePlusTypecheckStrategy;
-          readonly concurrency: number;
-          readonly packages: ReadonlyArray<string>;
+        readonly config: {
+          readonly enabled: boolean;
+          readonly typecheck: {
+            readonly strategy: VitePlusTypecheckStrategy;
+            readonly concurrency: number;
+            readonly packages: ReadonlyArray<string>;
+          };
+        };
+        readonly workflow: {
+          readonly enabled: boolean;
+          readonly beforeChecks: ReadonlyArray<VitePlusQualityWorkflowStep>;
+          readonly typecheck: ReadonlyArray<string>;
         };
       };
     };
@@ -174,6 +200,8 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
       };
     }
   }
+  const quality = manifest.setup?.vitePlus?.quality;
+  const typecheck = quality?.config?.typecheck;
 
   return {
     exclude: manifest.exclude ?? [],
@@ -202,11 +230,18 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
           enabled: manifest.setup?.vitePlus?.hooks?.enabled ?? false,
         },
         quality: {
-          enabled: manifest.setup?.vitePlus?.quality?.enabled ?? false,
-          typecheck: {
-            strategy: manifest.setup?.vitePlus?.quality?.typecheck?.strategy ?? "single-project",
-            concurrency: manifest.setup?.vitePlus?.quality?.typecheck?.concurrency ?? 4,
-            packages: manifest.setup?.vitePlus?.quality?.typecheck?.packages ?? [],
+          config: {
+            enabled: quality?.config?.enabled ?? false,
+            typecheck: {
+              strategy: typecheck?.strategy ?? "single-project",
+              concurrency: typecheck?.concurrency ?? 4,
+              packages: typecheck?.packages ?? [],
+            },
+          },
+          workflow: {
+            enabled: quality?.workflow?.enabled ?? false,
+            beforeChecks: quality?.workflow?.beforeChecks ?? [],
+            typecheck: quality?.workflow?.typecheck ?? ["vp run typecheck"],
           },
         },
       },

package/src/sync.ts

@@ -225,7 +225,8 @@ class ApplyRaceError extends Schema.TaggedErrorClass<ApplyRaceError>()("ApplyRac
 }
 
 const SKILL_FAMILIES: SkillCatalog = {
-  effect: ["effect-ts", "effect-atom-data-fetching"],
+  effect: ["effect-ts"],
+  "effect-atom-data-fetching": ["effect-ts"],
 };
 
 export const DEFAULT_MANIFEST = "dev-kit.jsonc";
@@ -634,43 +635,48 @@ const buildDesiredOutputs = Effect.fn("buildDesiredSkillOutputs")(function* (
       linkTarget,
     });
   }
-  if (setup.vitePlus.quality.enabled) {
-    for (const generated of [
-      {
-        resourceId: "setup:vite-plus-config" as const,
-        path: VITE_PLUS_CONFIG_PATH,
-        sourcePath: VITE_PLUS_CONFIG_TEMPLATE,
-      },
-      {
-        resourceId: "setup:vite-plus-github-actions" as const,
-        path: VITE_PLUS_GITHUB_ACTIONS_PATH,
-        sourcePath: VITE_PLUS_GITHUB_ACTIONS_TEMPLATE,
-      },
-    ]) {
-      const managed = yield* resolveManagedPath(projectDir, generated.path);
-      const template = yield* readGeneratedFileTemplate(packageRoot, generated.sourcePath);
-      const content =
-        generated.resourceId === "setup:vite-plus-config"
-          ? renderVitePlusConfigTemplate(template, setup.vitePlus.quality.typecheck)
-          : renderVitePlusWorkflowTemplate(
-              template,
-              projectDir === packageRoot
-                ? "./bin/dev-kit.mjs apply --locked"
-                : "vp exec dev-kit apply --locked",
-            );
+  if (setup.vitePlus.quality.config.enabled) {
+    const managed = yield* resolveManagedPath(projectDir, VITE_PLUS_CONFIG_PATH);
+    const template = yield* readGeneratedFileTemplate(packageRoot, VITE_PLUS_CONFIG_TEMPLATE);
+    const content = renderVitePlusConfigTemplate(template, setup.vitePlus.quality.config.typecheck);
 
-      outputs.push({
-        resourceId: generated.resourceId,
-        path: managed.relative,
-        sourcePath: generated.sourcePath,
-        mode: "copy",
-        kind: "file",
-        digest: yield* digestFileContent(content),
-        destination: managed.absolute,
-        content,
-        adoptIfExact: true,
-      });
-    }
+    outputs.push({
+      resourceId: "setup:vite-plus-config",
+      path: managed.relative,
+      sourcePath: VITE_PLUS_CONFIG_TEMPLATE,
+      mode: "copy",
+      kind: "file",
+      digest: yield* digestFileContent(content),
+      destination: managed.absolute,
+      content,
+      adoptIfExact: true,
+    });
+  }
+  if (setup.vitePlus.quality.workflow.enabled) {
+    const managed = yield* resolveManagedPath(projectDir, VITE_PLUS_GITHUB_ACTIONS_PATH);
+    const template = yield* readGeneratedFileTemplate(
+      packageRoot,
+      VITE_PLUS_GITHUB_ACTIONS_TEMPLATE,
+    );
+    const content = renderVitePlusWorkflowTemplate(template, {
+      devKitCommand:
+        projectDir === packageRoot
+          ? "./bin/dev-kit.mjs apply --locked"
+          : "vp exec dev-kit apply --locked",
+      workflow: setup.vitePlus.quality.workflow,
+    });
+
+    outputs.push({
+      resourceId: "setup:vite-plus-github-actions",
+      path: managed.relative,
+      sourcePath: VITE_PLUS_GITHUB_ACTIONS_TEMPLATE,
+      mode: "copy",
+      kind: "file",
+      digest: yield* digestFileContent(content),
+      destination: managed.absolute,
+      content,
+      adoptIfExact: true,
+    });
   }
   const agentsTarget = targets.agents;
   const duplicateOutput = skills.find(
@@ -918,18 +924,31 @@ export const planProjectSkills = Effect.fn("planProjectSkills")(function* (optio
   const packageRoot = yield* resolvePackageRoot();
   const manifest = normalizeManifest(yield* readManifest(manifestManaged.absolute));
 
-  if (manifest.setup.vitePlus.quality.enabled) {
+  const vitePlusQuality = manifest.setup.vitePlus.quality;
+  const vitePlusQualityEnabled = vitePlusQuality.config.enabled || vitePlusQuality.workflow.enabled;
+
+  if (vitePlusQualityEnabled) {
     if (!manifest.setup.effectTsgo.enabled) {
       return yield* new InvalidProjectStateError({
         message:
-          "setup.vitePlus.quality requires setup.effectTsgo.enabled so vp run typecheck uses the Effect-patched compiler",
+          "setup.vitePlus.quality requires setup.effectTsgo.enabled so managed quality setup converges the Effect-patched compiler",
       });
     }
     yield* validateVitePlusQualitySupport(
       projectDir,
       packageRoot,
       manifest.setup.effectTsgo.typescriptPackage,
-      manifest.setup.vitePlus.quality.typecheck,
+      {
+        ...(vitePlusQuality.config.enabled ? { config: vitePlusQuality.config.typecheck } : {}),
+        ...(vitePlusQuality.workflow.enabled
+          ? {
+              workflow: {
+                beforeChecks: vitePlusQuality.workflow.beforeChecks,
+                typecheck: vitePlusQuality.workflow.typecheck,
+              },
+            }
+          : {}),
+      },
     );
   }
   const effectSource = manifest.setup.effectSource.enabled

package/src/vite-plus-quality.ts

@@ -1,7 +1,7 @@
 import { Effect, FileSystem, Path, Schema } from "effect";
 import { parse as parseJsonc, type ParseError } from "jsonc-parser";
 
-import type { VitePlusTypecheckStrategy } from "./manifest.ts";
+import type { VitePlusQualityWorkflowStep, VitePlusTypecheckStrategy } from "./manifest.ts";
 import { readDirectDependencyNames, readProjectPackage } from "./project-package.ts";
 import { validateInstalledVitePlus } from "./vite-plus-dependency.ts";
 
@@ -21,8 +21,22 @@ export type VitePlusQualityTypecheck = {
   readonly packages: ReadonlyArray<string>;
 };
 
+export type VitePlusQualityWorkflow = {
+  readonly beforeChecks: ReadonlyArray<VitePlusQualityWorkflowStep>;
+  readonly typecheck: ReadonlyArray<string>;
+};
+
+export type VitePlusQualitySelection = {
+  readonly config?: VitePlusQualityTypecheck;
+  readonly workflow?: VitePlusQualityWorkflow;
+};
+
 const SINGLE_PROJECT_TYPECHECK_TASK = '      typecheck: "tsc --noEmit",';
 const LOCKED_DEV_KIT_COMMAND = "vp exec dev-kit apply --locked";
+const BEFORE_CHECKS_MARKER =
+  "      # Dev Kit inserts configured quality.workflow.beforeChecks steps here.\n\n";
+const DEFAULT_WORKFLOW_TYPECHECK = `      - name: Type check with Effect TypeScript-Go
+        run: vp run typecheck`;
 
 const replaceUniqueTemplateMarker = (
   template: string,
@@ -62,18 +76,65 @@ export const renderVitePlusConfigTemplate = (
 
 export const renderVitePlusWorkflowTemplate = (
   template: string,
-  devKitCommand = LOCKED_DEV_KIT_COMMAND,
-): string =>
-  devKitCommand === LOCKED_DEV_KIT_COMMAND
-    ? template
-    : replaceUniqueTemplateMarker(template, LOCKED_DEV_KIT_COMMAND, devKitCommand);
+  options: {
+    readonly devKitCommand?: string;
+    readonly workflow?: VitePlusQualityWorkflow;
+  } = {},
+): string => {
+  const devKitCommand = options.devKitCommand;
+  const workflow = options.workflow;
+  let rendered =
+    devKitCommand === undefined || devKitCommand === LOCKED_DEV_KIT_COMMAND
+      ? template
+      : replaceUniqueTemplateMarker(template, LOCKED_DEV_KIT_COMMAND, devKitCommand);
+
+  if (workflow !== undefined) {
+    const steps = workflow.beforeChecks
+      .map((step) => {
+        const commands = step.run
+          .flatMap((command) => command.split("\n"))
+          .map((line) => `          ${line}`)
+          .join("\n");
+
+        return `      - name: ${JSON.stringify(step.name)}
+        run: |
+${commands}`;
+      })
+      .join("\n\n");
+
+    rendered = replaceUniqueTemplateMarker(
+      rendered,
+      BEFORE_CHECKS_MARKER,
+      steps.length === 0 ? "" : `${steps}\n\n`,
+    );
+  }
+  if (
+    workflow !== undefined &&
+    (workflow.typecheck.length !== 1 || workflow.typecheck[0] !== "vp run typecheck")
+  ) {
+    const commands = workflow.typecheck
+      .flatMap((command) => command.split("\n"))
+      .map((line) => `          ${line}`)
+      .join("\n");
+
+    rendered = replaceUniqueTemplateMarker(
+      rendered,
+      DEFAULT_WORKFLOW_TYPECHECK,
+      `      - name: Type check with Effect TypeScript-Go
+        run: |
+${commands}`,
+    );
+  }
+
+  return rendered;
+};
 
 export const validateVitePlusQualitySupport = Effect.fn("validateVitePlusQualitySupport")(
   function* (
     projectDir: string,
     packageRoot: string,
     typescriptPackage: string,
-    typecheck: VitePlusQualityTypecheck,
+    selection: VitePlusQualitySelection,
   ) {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
@@ -93,24 +154,54 @@ export const validateVitePlusQualitySupport = Effect.fn("validateVitePlusQuality
         message: `setup.vitePlus.quality requires direct dependencies: ${missing.join(", ")}`,
       });
     }
+    if (selection.workflow !== undefined) {
+      if (selection.workflow.typecheck.length === 0) {
+        return yield* new VitePlusQualitySupportError({
+          message: "setup.vitePlus.quality.workflow.typecheck requires at least one command",
+        });
+      }
+      for (const command of selection.workflow.typecheck) {
+        if (command.trim().length === 0) {
+          return yield* new VitePlusQualitySupportError({
+            message: "setup.vitePlus.quality.workflow.typecheck commands must not be empty",
+          });
+        }
+      }
+      for (const step of selection.workflow.beforeChecks) {
+        if (step.name.trim().length === 0 || step.run.length === 0) {
+          return yield* new VitePlusQualitySupportError({
+            message:
+              "setup.vitePlus.quality.workflow.beforeChecks steps require a name and at least one command",
+          });
+        }
+        if (step.run.some((command) => command.trim().length === 0)) {
+          return yield* new VitePlusQualitySupportError({
+            message: "setup.vitePlus.quality.workflow.beforeChecks commands must not be empty",
+          });
+        }
+      }
+    }
+    const typecheck = selection.config;
+
+    if (typecheck === undefined) return;
     const conflictingScripts = ["check", "typecheck"].filter(
       (script) => packageJson.scripts?.[script] !== undefined,
     );
 
     if (conflictingScripts.length > 0) {
       return yield* new VitePlusQualitySupportError({
-        message: `setup.vitePlus.quality defines Vite tasks that conflict with package scripts: ${conflictingScripts.join(", ")}`,
+        message: `setup.vitePlus.quality.config defines Vite tasks that conflict with package scripts: ${conflictingScripts.join(", ")}`,
       });
     }
     if (typecheck.concurrency < 1 || typecheck.concurrency > 32) {
       return yield* new VitePlusQualitySupportError({
-        message: "setup.vitePlus.quality typecheck concurrency must be between 1 and 32",
+        message: "setup.vitePlus.quality.config typecheck concurrency must be between 1 and 32",
       });
     }
     if (typecheck.strategy === "single-project" && typecheck.packages.length > 0) {
       return yield* new VitePlusQualitySupportError({
         message:
-          "setup.vitePlus.quality single-project typechecking does not accept workspace packages",
+          "setup.vitePlus.quality.config single-project typechecking does not accept workspace packages",
       });
     }
     const workspacePatterns = Array.isArray(packageJson.workspaces)
@@ -126,21 +217,22 @@ export const validateVitePlusQualitySupport = Effect.fn("validateVitePlusQuality
         !workspacePatterns.every((pattern) => typeof pattern === "string"))
     ) {
       return yield* new VitePlusQualitySupportError({
-        message: "setup.vitePlus.quality workspace typechecking requires package.json workspaces",
+        message:
+          "setup.vitePlus.quality.config workspace typechecking requires package.json workspaces",
       });
     }
     if (typecheck.strategy === "workspace") {
       if (typecheck.packages.length === 0) {
         return yield* new VitePlusQualitySupportError({
           message:
-            "setup.vitePlus.quality workspace typechecking requires explicit package directories",
+            "setup.vitePlus.quality.config workspace typechecking requires explicit package directories",
         });
       }
       const uniquePackages = new Set(typecheck.packages);
 
       if (uniquePackages.size !== typecheck.packages.length) {
         return yield* new VitePlusQualitySupportError({
-          message: "setup.vitePlus.quality workspace typecheck packages must be unique",
+          message: "setup.vitePlus.quality.config workspace typecheck packages must be unique",
         });
       }
       for (const packageDir of typecheck.packages) {
@@ -155,21 +247,21 @@ export const validateVitePlusQualitySupport = Effect.fn("validateVitePlusQuality
           relative.startsWith(`..${path.sep}`)
         ) {
           return yield* new VitePlusQualitySupportError({
-            message: `setup.vitePlus.quality workspace package must be a project-relative subdirectory: ${packageDir}`,
+            message: `setup.vitePlus.quality.config workspace package must be a project-relative subdirectory: ${packageDir}`,
           });
         }
         const workspacePackage = yield* readProjectPackage(absolute).pipe(
           Effect.mapError(
             () =>
               new VitePlusQualitySupportError({
-                message: `setup.vitePlus.quality workspace package is missing a valid package.json: ${packageDir}`,
+                message: `setup.vitePlus.quality.config workspace package is missing a valid package.json: ${packageDir}`,
               }),
           ),
         );
 
         if (workspacePackage.scripts?.typecheck === undefined) {
           return yield* new VitePlusQualitySupportError({
-            message: `setup.vitePlus.quality workspace package requires a typecheck script: ${packageDir}`,
+            message: `setup.vitePlus.quality.config workspace package requires a typecheck script: ${packageDir}`,
           });
         }
       }
@@ -179,7 +271,8 @@ export const validateVitePlusQualitySupport = Effect.fn("validateVitePlusQuality
 
       if (!(yield* fs.exists(tsconfigPath))) {
         return yield* new VitePlusQualitySupportError({
-          message: "setup.vitePlus.quality single-project typechecking requires tsconfig.json",
+          message:
+            "setup.vitePlus.quality.config single-project typechecking requires tsconfig.json",
         });
       }
       const errors: Array<ParseError> = [];
@@ -189,7 +282,7 @@ export const validateVitePlusQualitySupport = Effect.fn("validateVitePlusQuality
 
       if (errors.length > 0 || typeof tsconfig !== "object" || tsconfig === null) {
         return yield* new VitePlusQualitySupportError({
-          message: "setup.vitePlus.quality requires a valid root tsconfig.json",
+          message: "setup.vitePlus.quality.config requires a valid root tsconfig.json",
         });
       }
       const references = (tsconfig as { readonly references?: unknown }).references;
@@ -197,7 +290,7 @@ export const validateVitePlusQualitySupport = Effect.fn("validateVitePlusQuality
       if (Array.isArray(references) && references.length > 0) {
         return yield* new VitePlusQualitySupportError({
           message:
-            "setup.vitePlus.quality single-project typechecking does not support tsconfig project references; select the workspace strategy or use a custom Vite config",
+            "setup.vitePlus.quality.config single-project typechecking does not support tsconfig project references; select the workspace strategy or use a custom Vite config",
         });
       }
     }

package/templates/vite-plus/github-actions-check.yml

@@ -36,6 +36,8 @@ jobs:
       - name: Verify locked Dev Kit setup
         run: vp exec dev-kit apply --locked
 
+      # Dev Kit inserts configured quality.workflow.beforeChecks steps here.
+
       - name: Check formatting
         run: vp fmt --check
 

package/skills/effect-atom-data-fetching/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "Effect Atom Data Fetching"
-  short_description: "Cache HTTP data safely with Effect Atom"
-  default_prompt: "Use $effect-atom-data-fetching to design or debug Effect Atom HTTP queries, caching, polling, invalidation, and SSR integration in a React app."