@danieljvdm/dev-kit 0.7.1 → 0.8.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,24 +270,95 @@ 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. 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 `vp run check` and `vp run typecheck`. The check task
-and CI run `vp fmt --check`, `vp lint`, `vp test`, then the Effect-patched
-compiler through `vp run typecheck`.
+`vp staged`, and defines separate `vp run check` and pure `vp run typecheck`
+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
+{
+  "setup": {
+    "effectTsgo": { "enabled": true },
+    "vitePlus": {
+      "quality": {
+        "config": {
+          "enabled": true,
+          "typecheck": {
+            "strategy": "workspace",
+            "concurrency": 4,
+            "packages": ["apps/web", "packages/core"],
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+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
+{
+  "setup": {
+    "effectTsgo": { "enabled": true },
+    "vitePlus": {
+      "quality": {
+        "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",
+          ],
+        },
+      },
+    },
+  },
+}
+```
+
+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 the
+templates.
 
 ## Effect source checkout
 
@@ -350,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
 
@@ -484,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

@@ -8,7 +8,13 @@
     "effectTsgo": { "enabled": true },
     "vitePlus": {
       "hooks": { "enabled": true },
-      "quality": { "enabled": true },
+      "quality": {
+        "config": {
+          "enabled": true,
+          "typecheck": { "strategy": "single-project" },
+        },
+        "workflow": { "enabled": true },
+      },
     },
   },
   "targets": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieljvdm/dev-kit",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "private": false,
   "description": "Declarative project development toolkit with portable agent skills.",
   "license": "MIT",
@@ -69,6 +69,7 @@
     "@stylistic/eslint-plugin": "5.10.0",
     "effect": "4.0.0-beta.102",
     "jsonc-parser": "3.3.1",
+    "semver": "7.8.5",
     "tsx": "4.22.4"
   },
   "devDependencies": {
@@ -76,6 +77,7 @@
     "@effect/tsgo": "0.24.3",
     "@effect/vitest": "4.0.0-beta.102",
     "@types/node": "25.9.1",
+    "@types/semver": "7.8.0",
     "oxfmt": "0.60.0",
     "oxlint": "1.75.0",
     "typescript": "7.0.2",

package/schema/dev-kit.schema.json

@@ -161,13 +161,105 @@
       }
     },
     "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": {
+        "enabled": {
+          "type": "boolean",
+          "default": false
+        },
+        "typecheck": {
+          "$ref": "#/$defs/vitePlusQualityTypecheckSetup"
+        }
+      }
+    },
+    "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",
+      "additionalProperties": false,
+      "properties": {
+        "strategy": {
+          "enum": ["single-project", "workspace"],
+          "default": "single-project"
+        },
+        "concurrency": {
+          "description": "Maximum concurrent workspace typecheck tasks.",
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 32,
+          "default": 4
+        },
+        "packages": {
+          "description": "Project-relative workspace package directories whose typecheck scripts should run.",
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          },
+          "uniqueItems": true,
+          "default": []
         }
       }
     },

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,19 +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 managed Vite config composes the shared formatter and linter presets,
-configures `vp staged`, and defines cached `check` and `typecheck` Vite tasks.
-The check task and GitHub Actions workflow run `vp fmt --check`, `vp lint`,
-`vp test`, and finally `vp run typecheck` so Effect diagnostics come from the
-patched native compiler.
+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
 
@@ -255,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/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,20 @@ 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,
+  VitePlusTypecheckStrategySchema,
 } from "./manifest.ts";
 export {
   applyEffectSourcePlan,

package/src/manifest.ts

@@ -53,8 +53,38 @@ export const VitePlusHooksSetupSchema = Schema.Struct({
   enabled: Schema.optional(Schema.Boolean),
 });
 
-export const VitePlusQualitySetupSchema = Schema.Struct({
+export const VitePlusTypecheckStrategySchema = Schema.Literals(["single-project", "workspace"]);
+export type VitePlusTypecheckStrategy = typeof VitePlusTypecheckStrategySchema.Type;
+
+export const VitePlusQualityTypecheckSetupSchema = Schema.Struct({
+  strategy: Schema.optional(VitePlusTypecheckStrategySchema),
+  concurrency: Schema.optional(Schema.Int),
+  packages: Schema.optional(Schema.Array(Schema.String)),
+});
+export type VitePlusQualityTypecheckSetup = typeof VitePlusQualityTypecheckSetupSchema.Type;
+
+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;
 
@@ -123,7 +153,19 @@ export type NormalizedManifest = {
         readonly enabled: boolean;
       };
       readonly quality: {
-        readonly enabled: boolean;
+        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>;
+        };
       };
     };
   };
@@ -158,6 +200,8 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
       };
     }
   }
+  const quality = manifest.setup?.vitePlus?.quality;
+  const typecheck = quality?.config?.typecheck;
 
   return {
     exclude: manifest.exclude ?? [],
@@ -186,7 +230,19 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
           enabled: manifest.setup?.vitePlus?.hooks?.enabled ?? false,
         },
         quality: {
-          enabled: manifest.setup?.vitePlus?.quality?.enabled ?? false,
+          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/project-package.ts

@@ -13,6 +13,7 @@ const ProjectPackageSchema = Schema.fromJsonString(
     devDependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
     optionalDependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
     peerDependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    workspaces: Schema.optional(Schema.Unknown),
   }),
 );
 

package/src/sync.ts

@@ -48,6 +48,8 @@ import {
   type VitePlusHooksPlan,
 } from "./vite-plus-hooks.ts";
 import {
+  renderVitePlusConfigTemplate,
+  renderVitePlusWorkflowTemplate,
   validateVitePlusQualitySupport,
   VITE_PLUS_CONFIG_PATH,
   VITE_PLUS_CONFIG_TEMPLATE,
@@ -223,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";
@@ -632,34 +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 content = yield* readGeneratedFileTemplate(packageRoot, generated.sourcePath);
+  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(
@@ -907,17 +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,
+      {
+        ...(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/tool-metadata.ts

@@ -1,3 +1,5 @@
 import packageMetadata from "../package.json" with { type: "json" };
 
 export const DEV_KIT_VERSION = packageMetadata.version;
+export const VITE_PLUS_TESTED_VERSION = packageMetadata.devDependencies["vite-plus"];
+export const VITE_PLUS_SUPPORTED_RANGE = packageMetadata.peerDependencies["vite-plus"];

package/src/vite-plus-dependency.ts

@@ -0,0 +1,70 @@
+import { Effect, FileSystem, Path, Schema } from "effect";
+import semver from "semver";
+
+import { readDirectDependencyNames } from "./project-package.ts";
+import { VITE_PLUS_SUPPORTED_RANGE } from "./tool-metadata.ts";
+
+const InstalledVitePlusPackageSchema = Schema.fromJsonString(
+  Schema.Struct({ version: Schema.String }),
+);
+
+export class VitePlusDependencyError extends Schema.TaggedErrorClass<VitePlusDependencyError>()(
+  "VitePlusDependencyError",
+  { message: Schema.String },
+) {}
+
+export type InstalledVitePlus = {
+  readonly version: string;
+  readonly vpBin: string;
+};
+
+export const validateInstalledVitePlus = Effect.fn("validateInstalledVitePlus")(function* (
+  projectDir: string,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const dependencies = yield* readDirectDependencyNames(projectDir);
+
+  if (!dependencies.includes("vite-plus")) {
+    return yield* new VitePlusDependencyError({
+      message: "vite-plus must be a direct project dependency",
+    });
+  }
+  const packagePath = path.join(projectDir, "node_modules", "vite-plus", "package.json");
+
+  if (!(yield* fs.exists(packagePath))) {
+    return yield* new VitePlusDependencyError({
+      message:
+        "vite-plus must be installed before enabling this setup: node_modules/vite-plus/package.json is missing",
+    });
+  }
+  const installed = yield* fs.readFileString(packagePath).pipe(
+    Effect.flatMap(Schema.decodeUnknownEffect(InstalledVitePlusPackageSchema)),
+    Effect.mapError(
+      () =>
+        new VitePlusDependencyError({
+          message: "installed vite-plus package metadata has no valid version",
+        }),
+    ),
+  );
+
+  if (!semver.valid(installed.version)) {
+    return yield* new VitePlusDependencyError({
+      message: `installed vite-plus package metadata has invalid version: ${installed.version}`,
+    });
+  }
+  if (!semver.satisfies(installed.version, VITE_PLUS_SUPPORTED_RANGE)) {
+    return yield* new VitePlusDependencyError({
+      message: `installed vite-plus ${installed.version} is incompatible with @danieljvdm/dev-kit; supported range: ${VITE_PLUS_SUPPORTED_RANGE}`,
+    });
+  }
+  const vpBin = path.join(projectDir, "node_modules", ".bin", "vp");
+
+  if (!(yield* fs.exists(vpBin))) {
+    return yield* new VitePlusDependencyError({
+      message: "vite-plus is installed but node_modules/.bin/vp is missing",
+    });
+  }
+
+  return { version: installed.version, vpBin } satisfies InstalledVitePlus;
+});

package/src/vite-plus-hooks.ts

@@ -1,7 +1,7 @@
 import { Config, Effect, FileSystem, Path, Schema, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
 
-import { readDirectDependencyNames } from "./project-package.ts";
+import { validateInstalledVitePlus } from "./vite-plus-dependency.ts";
 
 export const VITE_PLUS_HOOKS_DIR = ".vite-hooks";
 export const VITE_PLUS_HOOKS_PATH = `${VITE_PLUS_HOOKS_DIR}/_`;
@@ -121,23 +121,14 @@ const inspectVitePlusHooks = Effect.fn("inspectVitePlusHooks")(function* (projec
 });
 
 export const planVitePlusHooks = Effect.fn("planVitePlusHooks")(function* (projectDir: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const dependencies = yield* readDirectDependencyNames(projectDir);
-
-  if (!dependencies.includes("vite-plus")) {
-    return yield* new VitePlusHooksDependencyError({
-      message: "vite-plus must be a direct project dependency before enabling setup.vitePlus.hooks",
-    });
-  }
-  const vpBin = path.join(projectDir, "node_modules", ".bin", "vp");
-
-  if (!(yield* fs.exists(vpBin))) {
-    return yield* new VitePlusHooksDependencyError({
-      message:
-        "vite-plus must be installed before enabling setup.vitePlus.hooks: node_modules/.bin/vp is missing",
-    });
-  }
+  const { vpBin } = yield* validateInstalledVitePlus(projectDir).pipe(
+    Effect.mapError(
+      (error) =>
+        new VitePlusHooksDependencyError({
+          message: `${error.message} before enabling setup.vitePlus.hooks`,
+        }),
+    ),
+  );
   const viteGitHooks = yield* Config.string("VITE_GIT_HOOKS").pipe(Config.withDefault(""));
   const husky = yield* Config.string("HUSKY").pipe(Config.withDefault(""));
   const action =

package/src/vite-plus-quality.ts

@@ -1,6 +1,9 @@
 import { Effect, FileSystem, Path, Schema } from "effect";
+import { parse as parseJsonc, type ParseError } from "jsonc-parser";
 
+import type { VitePlusQualityWorkflowStep, VitePlusTypecheckStrategy } from "./manifest.ts";
 import { readDirectDependencyNames, readProjectPackage } from "./project-package.ts";
+import { validateInstalledVitePlus } from "./vite-plus-dependency.ts";
 
 export const VITE_PLUS_CONFIG_PATH = "vite.config.ts";
 export const VITE_PLUS_CONFIG_TEMPLATE = "templates/vite-plus/vite.config.ts";
@@ -12,13 +15,136 @@ export class VitePlusQualitySupportError extends Schema.TaggedErrorClass<VitePlu
   { message: Schema.String },
 ) {}
 
+export type VitePlusQualityTypecheck = {
+  readonly strategy: VitePlusTypecheckStrategy;
+  readonly concurrency: number;
+  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,
+  marker: string,
+  replacement: string,
+): string => {
+  const parts = template.split(marker);
+
+  if (parts.length !== 2) {
+    throw new Error(`expected exactly one generated template marker: ${marker}`);
+  }
+
+  return `${parts[0]}${replacement}${parts[1]}`;
+};
+
+const shellQuote = (value: string): string => `'${value.replaceAll("'", `'"'"'`)}'`;
+
+export const renderVitePlusConfigTemplate = (
+  template: string,
+  typecheck: VitePlusQualityTypecheck,
+): string => {
+  if (typecheck.strategy === "single-project") return template;
+  const filters = typecheck.packages
+    .map((packageDir) => `--filter ${shellQuote(`./${packageDir}`)}`)
+    .join(" ");
+  const command = `vp run --cache --concurrency-limit ${typecheck.concurrency} ${filters} --fail-if-no-match typecheck`;
+
+  return replaceUniqueTemplateMarker(
+    template,
+    SINGLE_PROJECT_TYPECHECK_TASK,
+    `      typecheck: {
+        command: ${JSON.stringify(command)},
+        cache: false,
+      },`,
+  );
+};
+
+export const renderVitePlusWorkflowTemplate = (
+  template: string,
+  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) {
+  function* (
+    projectDir: string,
+    packageRoot: string,
+    typescriptPackage: string,
+    selection: VitePlusQualitySelection,
+  ) {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
     const packageJson = yield* readProjectPackage(projectDir);
     const dependencies = yield* readDirectDependencyNames(projectDir);
-    const required = new Set(["vite-plus", "effect", "@effect/tsgo", typescriptPackage]);
+    const required = new Set(["effect", "@effect/tsgo", typescriptPackage]);
+
+    yield* validateInstalledVitePlus(projectDir).pipe(
+      Effect.mapError((error) => new VitePlusQualitySupportError({ message: error.message })),
+    );
 
     if (projectDir !== packageRoot) required.add("@danieljvdm/dev-kit");
     const missing = [...required].filter((dependency) => !dependencies.includes(dependency));
@@ -28,22 +154,145 @@ 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.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.config single-project typechecking does not accept workspace packages",
       });
     }
-    const vpBin = path.join(projectDir, "node_modules", ".bin", "vp");
+    const workspacePatterns = Array.isArray(packageJson.workspaces)
+      ? packageJson.workspaces
+      : typeof packageJson.workspaces === "object" && packageJson.workspaces !== null
+        ? (packageJson.workspaces as { readonly packages?: unknown }).packages
+        : undefined;
 
-    if (!(yield* fs.exists(vpBin))) {
+    if (
+      typecheck.strategy === "workspace" &&
+      (!Array.isArray(workspacePatterns) ||
+        workspacePatterns.length === 0 ||
+        !workspacePatterns.every((pattern) => typeof pattern === "string"))
+    ) {
       return yield* new VitePlusQualitySupportError({
         message:
-          "vite-plus must be installed before enabling setup.vitePlus.quality: node_modules/.bin/vp is missing",
+          "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.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.config workspace typecheck packages must be unique",
+        });
+      }
+      for (const packageDir of typecheck.packages) {
+        const absolute = path.resolve(projectDir, packageDir);
+        const relative = path.relative(projectDir, absolute);
+
+        if (
+          packageDir.length === 0 ||
+          path.isAbsolute(packageDir) ||
+          relative.length === 0 ||
+          relative === ".." ||
+          relative.startsWith(`..${path.sep}`)
+        ) {
+          return yield* new VitePlusQualitySupportError({
+            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.config workspace package is missing a valid package.json: ${packageDir}`,
+              }),
+          ),
+        );
+
+        if (workspacePackage.scripts?.typecheck === undefined) {
+          return yield* new VitePlusQualitySupportError({
+            message: `setup.vitePlus.quality.config workspace package requires a typecheck script: ${packageDir}`,
+          });
+        }
+      }
+    }
+    if (typecheck.strategy === "single-project") {
+      const tsconfigPath = path.join(projectDir, "tsconfig.json");
+
+      if (!(yield* fs.exists(tsconfigPath))) {
+        return yield* new VitePlusQualitySupportError({
+          message:
+            "setup.vitePlus.quality.config single-project typechecking requires tsconfig.json",
+        });
+      }
+      const errors: Array<ParseError> = [];
+      const tsconfig = parseJsonc(yield* fs.readFileString(tsconfigPath), errors, {
+        allowTrailingComma: true,
+      });
+
+      if (errors.length > 0 || typeof tsconfig !== "object" || tsconfig === null) {
+        return yield* new VitePlusQualitySupportError({
+          message: "setup.vitePlus.quality.config requires a valid root tsconfig.json",
+        });
+      }
+      const references = (tsconfig as { readonly references?: unknown }).references;
+
+      if (Array.isArray(references) && references.length > 0) {
+        return yield* new VitePlusQualitySupportError({
+          message:
+            "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

@@ -22,14 +22,21 @@ jobs:
         with:
           persist-credentials: false
 
-      - name: Set up Vite+
-        uses: voidzero-dev/setup-vp@v1
+      # setup-vp's v1 tag is frozen. Keep this v1.16.1 commit current with
+      # Renovate or Dependabot so fixes arrive through reviewed pull requests.
+      - name: Set up Vite+ and install dependencies
+        uses: voidzero-dev/setup-vp@143f5f385f39b1b753ffed1a01ad443811855c8b # v1.16.1
         with:
+          # Vite+ version intentionally resolves from the consumer manifest/lock.
           node-version: "24"
           cache: true
+          run-install: |
+            args: ["--frozen-lockfile", "--ignore-scripts"]
 
-      - name: Install dependencies
-        run: vp install
+      - 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."