@withmata/blueprints 0.3.2 → 0.3.4

package/.claude/skills/scaffold-foundation/SKILL.md

@@ -7,30 +7,120 @@ description: Set up a Turborepo + pnpm monorepo skeleton (skip for single-repo a
 
 Set up the monorepo project skeleton using the foundation blueprint. **For single-repo applications** (standalone Next.js, Node, or Bun apps), skip this command and go directly to feature blueprints (`/scaffold-db`, `/scaffold-auth`) — they detect single-repo projects and adapt automatically.
 
-## Step 1: Read the Blueprint
+This skill operates in two modes:
 
-Read the full foundation blueprint and all template files:
+- **Install mode** (default) — fresh scaffold of the full monorepo skeleton
+- **Upgrade mode** — detects an existing foundation install and offers to apply updates (new features added to blueprints since the original install)
+
+## Step 1: Read the Blueprints
+
+Read the foundation blueprint and all template files:
 
 ```
 ~/.withmata/blueprints/blueprints/foundation/monorepo-turbo/BLUEPRINT.md
 ~/.withmata/blueprints/blueprints/foundation/monorepo-turbo/files/**/*
 ```
 
+Also read the feature blueprints that foundation can optionally include:
+
+```
+~/.withmata/blueprints/blueprints/features/env-t3/BLUEPRINT.md
+~/.withmata/blueprints/blueprints/features/env-t3/files/**/*
+~/.withmata/blueprints/blueprints/features/tailwind-v4/BLUEPRINT.md
+~/.withmata/blueprints/blueprints/features/tailwind-v4/files/**/*
+~/.withmata/blueprints/blueprints/features/ui-shared-components/BLUEPRINT.md
+~/.withmata/blueprints/blueprints/features/ui-shared-components/files/**/*
+```
+
 If not found, run `npx @withmata/blueprints` to install.
 
-The BLUEPRINT.md contains the full architecture documentation, naming conventions, folder conventions, and file manifest. Follow it precisely.
+The BLUEPRINT.md files contain the full architecture documentation, naming conventions, folder conventions, and file manifests. Follow them precisely.
 
-## Step 2: Read Project Context
+## Step 1.5: Read Project Context
 
 Check if `.project-context.md` exists in the target project root:
 
 - **If it has a Discovery section**: use the product name to derive the npm scope (e.g., "Acme Dashboard" -> `@acme`). Use technical constraints to inform any decisions.
 
-- **If it has a Foundation section already**: warn the user. Ask: "Foundation was already set up. Do you want to re-scaffold (destructive — replaces existing structure) or skip?"
+- **If it has a Foundation section already**: switch to upgrade mode (Step 1.6).
+
+- **If no context file exists**: that is fine. Ask the user directly for the product name and npm scope. Proceed with install mode.
+
+## Step 1.6: Upgrade Mode
+
+When foundation is already installed, run migrations first, then check for template updates and missing features.
+
+### 1.6a: System Migrations
+
+Check for legacy patterns from older blueprint versions and offer to migrate them. Run these checks in order:
+
+**Migration: Separate maintenance skills → consolidated `project-maintenance/`**
+
+Scan `.claude/skills/` in the project for individual maintenance skill directories:
+- `auth-maintenance/`
+- `db-maintenance/`
+- `env-maintenance/`
+- `tailwind-maintenance/`
+- `ui-maintenance/`
+- `monorepo-maintenance/`
+
+If any are found:
+1. Read each `SKILL.md` to extract the maintenance rules (the `### {name} maintenance` sections)
+2. Create (or update) `.claude/skills/project-maintenance/SKILL.md` with the consolidated frontmatter and all extracted sections
+3. Remove the old individual directories
+4. Report: "Migrated {n} separate maintenance skills into one `project-maintenance/SKILL.md`"
+
+**Migration: `foundation_completed` → `installed_at`**
+
+Check `.project-context.md` for `foundation_completed:` under `## Foundation`. If found, rename the field to `installed_at:`.
+
+**Future migrations go here.** Each migration should:
+- Check for the legacy pattern
+- Only run if the legacy pattern is detected (idempotent)
+- Report what was changed
+- Be safe to run multiple times (no-op if already migrated)
 
-- **If no context file exists**: that is fine. Ask the user directly for the product name and npm scope.
+### 1.6b: Template Updates and Missing Features
 
-## Step 3: Understand Current State
+After migrations, compare what's currently in the project against what the blueprints now offer:
+
+1. **Foundation file updates** — Compare each foundation template file against the installed version. Flag files where the blueprint template has changed (e.g., updated `turbo.json` task structure, new fields in `package.json`).
+
+2. **Missing features** — Check `.project-context.md` Installed Blueprints for:
+   - `env-t3` — Is it installed? If not, apply it automatically (env validation is not optional).
+   - `tailwind-v4` + `ui-shared-components` — Are they installed? If not, flag as available (frontend UI is optional).
+
+3. **Present findings to the user:**
+
+   ```
+   Foundation was installed on <date>. Here's what's available:
+
+   Migrations applied:
+     ✓ Consolidated 4 maintenance skills into project-maintenance/SKILL.md
+     ✓ Renamed foundation_completed → installed_at in project context
+
+   Updates to existing files:
+     ☐ turbo.json — new task caching strategy
+     ☐ apps/web/next.config.ts — updated config pattern
+
+   Auto-applying:
+     ✓ Validated environment variables (env-t3) — type-safe env with client/server split
+
+   New features (not yet installed):
+     ☐ Frontend UI setup (tailwind-v4 + ui-shared-components) — full design system and shared component library
+
+   Which would you like to apply?
+   ```
+
+4. Apply only what the user selects. For each selected feature, follow its blueprint's integration steps (adapted to the existing project). Skip configuration questions where the answer is already in `.project-context.md`.
+
+5. Update `.project-context.md` with the newly installed features and update `installed_at` date.
+
+After upgrade mode completes, skip to Step 7 (Summarize).
+
+## Step 2: Understand Current State
+
+*(Install mode only — skipped in upgrade mode)*
 
 Explore the target project directory:
 
@@ -40,12 +130,20 @@ Explore the target project directory:
 
 ## Step 4: Ask Configuration Questions
 
-Only three questions — skip any already answered by project context:
+*(Install mode only — skipped in upgrade mode)*
+
+Core questions — skip any already answered by project context:
 
 1. **npm scope** — "What npm scope should internal packages use? (e.g., @acme)" Default: derive from product name.
 2. **Project name** — "What is the human-readable project name?" (for metadata, page titles). Default: from discovery context.
 3. **Node.js version** — "Target Node.js version?" Default: `>=22`.
 
+Optional feature question — ask after the core questions:
+
+4. **Frontend UI** — "Will this project have frontend work? If yes, I'll set up the full Tailwind design system and a shared UI component library (`packages/ui/`) with shadcn/ui. (Y/n)" Default: yes. If yes, applies both tailwind-v4 and ui-shared-components together.
+
+**Note:** Validated environment variables (env-t3) are always set up — not optional. Every app gets type-safe env validation.
+
 ## Step 5: Scaffold
 
 Create the monorepo skeleton by adapting all files from the blueprint. Replace placeholders:
@@ -66,7 +164,7 @@ From `files/root/`, create at project root:
 
 From `files/config/`, create:
 - `config/typescript-config/` — base.json, nextjs.json, react-library.json, package.json
-- `config/tailwind-config/` — shared-styles.css, postcss.config.js, package.json
+- `config/tailwind-config/` — shared-styles.css, postcss.config.mjs, package.json
 
 ### 5c. Next.js App Shell
 
@@ -93,9 +191,73 @@ After creating all files:
 2. Run `pnpm install` to verify the workspace configuration is valid
 3. Verify the dev server starts: `pnpm dev` (briefly — just check it boots)
 
+## Step 5.5: Optional Features
+
+Apply the optional features the user said yes to in Step 4. Each feature follows its own blueprint's integration steps but within the same session — no need to run separate scaffold commands.
+
+### 5.5a. Environment Variables (always applied)
+
+Follow the `env-t3` blueprint's integration steps:
+
+1. Create `apps/web/src/env/client.ts` and `apps/web/src/env/server.ts` from env-t3 templates
+2. Replace the foundation's `apps/web/env.ts` with the split pattern
+3. Update `apps/web/next.config.ts` — replace `import "./env"` with:
+   ```typescript
+   import "./src/env/server";
+   import "./src/env/client";
+   ```
+4. Create `apps/web/.env.example` from env-t3 template — replace `{{APP_NAME}}`
+5. Create `apps/web/.env.local` (empty)
+6. Ensure `@t3-oss/env-nextjs` and `zod` are in `apps/web/package.json` dependencies
+
+### 5.5b. Frontend UI Setup (if opted in)
+
+When the user opts in to frontend work, apply both tailwind-v4 and ui-shared-components together as a single step.
+
+**Tailwind design system** — follow the `tailwind-v4` blueprint's integration steps:
+
+1. Replace `config/tailwind-config/shared-styles.css` with the full version from the tailwind-v4 blueprint (includes `tw-animate-css`, `shadcn/tailwind.css`, `tailwind-scrollbar-hide`, sidebar tokens, chart tokens)
+2. Merge tailwind-v4 dependencies into `config/tailwind-config/package.json`:
+   - Add `@tailwindcss/typography`, `shadcn`, `tailwind-scrollbar-hide`, `tw-animate-css` to `dependencies`
+
+**Shared UI package** — follow the `ui-shared-components` blueprint's integration steps:
+
+1. Create `packages/ui/` with all files from the ui blueprint:
+   - `package.json` — replace `{{SCOPE}}`
+   - `tsconfig.json` — replace `{{SCOPE}}`
+   - `components.json`
+   - `styles/globals.css` — replace `{{SCOPE}}`
+   - `utils/cn.ts`
+   - `utils/cva.ts`
+2. Create empty directories: `packages/ui/components/ui/`, `packages/ui/icons/`, `packages/ui/icons/logos/`
+3. Update `apps/web/app/globals.css` to import UI styles:
+   ```css
+   @import "tailwindcss";
+   @import "{{SCOPE}}/tailwind-config";
+   @import "{{SCOPE}}/ui/styles";
+   @plugin "@tailwindcss/typography";
+
+   @source "../../packages/ui";
+   ```
+   Compute the `@source` relative path based on the actual directory structure.
+
+### 5.5d. Re-install
+
+If any optional features were applied:
+1. Run `pnpm install` again to wire new workspace dependencies
+2. Verify `pnpm dev` still boots cleanly
+
 ## Step 6: Update Project Context
 
-Append the `## Foundation` section to `.project-context.md`:
+**This step is mandatory.** The `.project-context.md` file is how other blueprints and future runs of `/scaffold-foundation` (upgrade mode) know what's been set up. Without it, every subsequent blueprint runs blind.
+
+If `.project-context.md` does not exist, create it now:
+
+```markdown
+# Project Context
+```
+
+Then append the `## Foundation` section:
 
 ```yaml
 ## Foundation
@@ -103,10 +265,11 @@ monorepo_tool: turborepo
 package_manager: pnpm
 npm_scope: "<scope>"
 node_version: ">=22"
+project_type: monorepo
 workspaces:
   apps: ["web"]
   apis: []
-  packages: []
+  packages: ["ui"]  # if frontend UI was applied, otherwise []
   config: ["typescript-config", "tailwind-config"]
 framework: next.js (app router)
 typescript: strict
@@ -114,24 +277,39 @@ linter: biome
 styling: tailwind-v4
 env_validation: t3-env + zod
 module_resolution: node subpath imports (#prefix)
-foundation_completed: <date>
+installed_at: <date>
+```
+
+Then append `## Installed Blueprints` with entries for every feature that was applied:
+
+```markdown
+## Installed Blueprints
 ```
 
-If `.project-context.md` does not exist, create it with the standard header and the Foundation section.
+- Always add the `env-t3` project context block (see env-t3 BLUEPRINT.md)
+- If frontend UI was applied: add both the `tailwind-v4` and `ui-shared-components` project context blocks (see their BLUEPRINT.md files)
+
+**Verify the file exists and is well-formed before proceeding to Step 7.** If it's missing or empty, that is a bug — fix it before summarizing.
 
 ### Create Maintenance Skill
 
-Create a project-level maintenance skill for the monorepo foundation:
+All blueprints share a single project-level maintenance skill. Create or append to:
+
+**File:** `<project>/.claude/skills/project-maintenance/SKILL.md`
 
-**File:** `<project>/.claude/skills/monorepo-maintenance/SKILL.md`
+If the file does not exist, create it with the frontmatter header:
 
 ```yaml
 ---
-name: monorepo-maintenance
-description: Maintenance rules for the Turborepo monorepo foundation. Invoke when modifying workspace configs, shared packages, or Turbo tasks.
+name: project-maintenance
+description: Maintenance rules for all installed blueprints. Invoke when modifying schemas, env vars, auth config, workspace configs, UI components, or Tailwind tokens.
 user-invocable: false
 ---
+```
+
+Then append sections for each blueprint applied in this run. Foundation always adds:
 
+```markdown
 ### Monorepo maintenance
 - After every code change: format with Biome (`pnpm biome check --write .`) before considering work complete
 - After adding new workspace packages: verify `pnpm-workspace.yaml` patterns match, run `pnpm install`
@@ -139,21 +317,58 @@ user-invocable: false
 - After changing `turbo.json`: verify task ordering with `pnpm turbo run <task> --dry`
 - After adding workspace dependencies: run `pnpm install` to create workspace links
 - Keep `turbo.json` tasks with `cache: false` for any task with side effects (migrations, code generation)
+
+### env-t3 maintenance
+- After adding a new env var: add it to the env schema file (client.ts or server.ts), `.env.example`, and `.env.local`
+- NEXT_PUBLIC_* vars go in env/client.ts with explicit runtimeEnv mapping; server vars go in env/server.ts
+- After removing an env var: remove from schema, .env.example, and .env.local
+- Never access process.env directly — always use the typed env objects (clientEnv, serverEnv, or env)
+- Keep .env.example documented with section headers and local/production hints
+```
+
+If frontend UI was applied, also append:
+
+```markdown
+### tailwind-v4 maintenance
+- After adding a new color: add CSS variable to both :root and .dark selectors in shared-styles.css, then map in @theme inline
+- After adding a new app: import the tailwind-config package in the app's globals.css
+- After upgrading Tailwind: check for @import, @theme, or @custom-variant breaking changes
+- Never use tailwind.config.js — all configuration is CSS-based in shared-styles.css
+- Colors use OKLCH color space — do not use hex or RGB
+
+### ui-shared-components maintenance
+- Add shadcn components via `pnpm dlx shadcn@latest add <name>` from packages/ui/
+- Use cn() for all className composition — never concatenate class strings manually
+- Internal imports use #prefix (#components/ui/button); cross-package imports use @scope/ui/components/ui/button
+- After adding a new export directory: add to both exports and imports in packages/ui/package.json
+- After adding a new consuming app: add @import and @source directive to the app's globals.css
 ```
 
 ## Step 7: Summarize
 
 Tell the user:
 
-- Project structure overview (directory tree)
+### Install Mode Summary
+
+- Project structure overview (directory tree — include optional features that were applied)
 - What was configured (scope, Node version, tooling)
+- Which optional features were included
 - How to start development: `pnpm dev`
-- Available feature blueprints to install next
-- Suggest: "Run `/scaffold-auth` to add authentication. Other feature blueprints: ui-shared-components, tailwind-v4, db-drizzle-postgres."
+- If frontend UI was set up: how to add shadcn components (`cd packages/ui && pnpm dlx shadcn@latest add button`)
+- Available feature blueprints to install next: `/scaffold-db`, `/scaffold-auth`
+
+### Upgrade Mode Summary
+
+- What was updated (list files that changed)
+- What new features were added (env, tailwind, UI)
+- Any manual steps remaining
+- Suggest next steps based on what's still not installed
 
 ## Important Notes
 
 - Never overwrite existing files without asking.
 - Preserve all `// CONFIGURE:` comments in generated files so the user can find customization points.
-- The Tailwind config is intentionally minimal — the UI feature blueprint extends it with shadcn, animations, and component-specific styles.
+- In upgrade mode, be conservative — only modify files that the blueprints own. Don't touch user-customized files (check for differences from the template before replacing).
+- If the user has customized colors in `shared-styles.css` or added variables to `env.ts`, ask before replacing. Offer to merge their customizations into the new version.
 - Feature blueprints will add scripts to root `package.json` and tasks to `turbo.json` — the foundation provides the base that they extend.
+- The individual `/scaffold-env`, `/scaffold-tailwind`, and `/scaffold-ui` skills still exist for projects that didn't use foundation or want to add features later. The foundation's optional feature steps follow the same blueprints — no duplication.

package/.claude/skills/scaffold-tailwind/SKILL.md

@@ -29,6 +29,29 @@ Check if `.project-context.md` exists in the target project root:
   - Use this to determine if `config/tailwind-config/` exists
 
 - **If it does not exist**: proceed normally — explore the project manually
+- **If `tailwind-v4` is in Installed Blueprints**: switch to upgrade mode (Step 1.6)
+
+## Step 1.6: Upgrade Mode
+
+If `tailwind-v4` is found in `.project-context.md` under `## Installed Blueprints`, switch to upgrade mode.
+
+1. **Read installed state** — from project context, get `files_modified`, `choices`, and `installed_at`
+2. **Compare templates against installed files:**
+   - `config/tailwind-config/shared-styles.css` — compare against current blueprint template. Look for new imports (`@import`), new tokens in `@theme inline`, new CSS variables in `:root` and `.dark`, new base layer rules.
+   - `config/tailwind-config/package.json` — compare dependencies. Look for new or updated packages.
+3. **Present findings:**
+   ```
+   tailwind-v4 was installed on <date>. Checking for updates...
+
+   Updated files:
+     ☐ shared-styles.css — new tokens added (e.g., new sidebar variants, chart colors)
+     ☐ package.json — new dependency: <package>
+
+   Apply updates?
+   ```
+4. **Apply selectively** — `shared-styles.css` is a blueprint-owned file (users customize colors but the structure is ours). For color value changes, ask before overwriting. For new token additions (new `--color-*` vars), safe to append.
+5. **Update project context** — update `installed_at` date
+6. **Skip to Step 6 (Output Summary)**
 
 ## Step 2: Understand the Target Project
 
@@ -111,6 +134,7 @@ Append an entry to `.project-context.md` under `## Installed Blueprints`:
 ```yaml
 ### tailwind-v4
 blueprint: tailwind-v4
+installed_at: <date>
 choices:
   include_sidebar_tokens: <true|false>
   include_chart_tokens: <true|false>
@@ -127,17 +151,21 @@ packages_added:
 
 ### Create Maintenance Skill
 
-Create a project-level maintenance skill:
+Append to the shared project-level maintenance skill at `<project>/.claude/skills/project-maintenance/SKILL.md`.
 
-**File:** `<project>/.claude/skills/tailwind-maintenance/SKILL.md`
+If the file does not exist, create it with frontmatter:
 
 ```yaml
 ---
-name: tailwind-maintenance
-description: Maintenance rules for Tailwind v4 design system. Invoke when modifying theme tokens, colors, or adding new apps.
+name: project-maintenance
+description: Maintenance rules for all installed blueprints. Invoke when modifying schemas, env vars, auth config, workspace configs, UI components, or Tailwind tokens.
 user-invocable: false
 ---
+```
 
+Then append:
+
+```markdown
 ### tailwind-v4 maintenance
 - After adding a new color: add CSS variable to both :root and .dark selectors in shared-styles.css, then map in @theme inline
 - After adding a new app: import the tailwind-config package in the app's globals.css
@@ -146,6 +174,8 @@ user-invocable: false
 - Colors use OKLCH color space — do not use hex or RGB
 ```
 
+If a `### tailwind-v4 maintenance` section already exists in the file, skip — do not duplicate.
+
 ## Step 6: Output Summary
 
 ### Packages Added

package/.claude/skills/scaffold-ui/SKILL.md

@@ -32,6 +32,41 @@ Check if `.project-context.md` exists in the target project root:
 
 When project context provides clear answers, skip the corresponding questions in Step 3.
 
+If `ui-shared-components` is in Installed Blueprints, switch to upgrade mode (Step 1.6).
+
+## Step 1.6: Upgrade Mode
+
+If `ui-shared-components` is found in `.project-context.md` under `## Installed Blueprints`, switch to upgrade mode.
+
+1. **Read installed state** — from project context, get `files_created`, `choices`, and `installed_at`
+2. **Compare templates against installed files:**
+   - `packages/ui/package.json` — compare exports, imports, dependencies. Look for new export patterns, updated deps.
+   - `packages/ui/components.json` — compare shadcn config. Look for updated aliases or style changes.
+   - `packages/ui/utils/cn.ts` — compare utility implementation.
+   - `packages/ui/utils/cva.ts` — compare CVA re-export.
+   - `packages/ui/styles/globals.css` — compare style imports.
+   - `packages/ui/tsconfig.json` — compare TypeScript config.
+   - Check consuming app `globals.css` — verify `@import` and `@source` directives are present and correct.
+3. **Present findings:**
+   ```
+   ui-shared-components was installed on <date>. Checking for updates...
+
+   Updated files:
+     ☐ packages/ui/package.json — new export patterns or dependencies
+     ☐ packages/ui/components.json — updated shadcn configuration
+
+   New files:
+     ☐ packages/ui/utils/cva.ts — new utility (didn't exist in previous version)
+
+   Unchanged:
+     ✓ packages/ui/utils/cn.ts — no changes
+
+   Apply updates?
+   ```
+4. **Apply selectively** — `package.json` exports and `components.json` are blueprint-owned. `components/ui/` files are user-owned (shadcn-generated) — never touch those.
+5. **Update project context** — update `installed_at` date
+6. **Skip to Step 6 (Output Summary)**
+
 ## Step 2: Understand the Target Project
 
 ### 2a. Detect Project Type
@@ -128,6 +163,7 @@ Append an entry to `.project-context.md` under `## Installed Blueprints`:
 ```yaml
 ### ui-shared-components
 blueprint: ui-shared-components
+installed_at: <date>
 choices:
   shadcn_style: <style>
   icon_library: <library>
@@ -142,17 +178,21 @@ packages_added:
 
 ### Create Maintenance Skill
 
-Create a project-level maintenance skill:
+Append to the shared project-level maintenance skill at `<project>/.claude/skills/project-maintenance/SKILL.md`.
 
-**File:** `<project>/.claude/skills/ui-maintenance/SKILL.md`
+If the file does not exist, create it with frontmatter:
 
 ```yaml
 ---
-name: ui-maintenance
-description: Maintenance rules for shared UI component library. Invoke when adding components, icons, or modifying the UI package.
+name: project-maintenance
+description: Maintenance rules for all installed blueprints. Invoke when modifying schemas, env vars, auth config, workspace configs, UI components, or Tailwind tokens.
 user-invocable: false
 ---
+```
 
+Then append:
+
+```markdown
 ### ui-shared-components maintenance
 - Add shadcn components via `pnpm dlx shadcn@latest add <name>` from packages/ui/
 - Use cn() for all className composition — never concatenate class strings manually
@@ -161,6 +201,8 @@ user-invocable: false
 - After adding a new consuming app: add @import and @source directive to the app's globals.css
 ```
 
+If a `### ui-shared-components maintenance` section already exists in the file, skip — do not duplicate.
+
 ## Step 6: Output Summary
 
 ### Packages to Install

package/ENGINEERING.md

@@ -43,5 +43,5 @@ These preferences apply to ALL blueprints in this repo and to any project scaffo
 - **Project context:** Every blueprint appends to `.project-context.md` in the target project root — tool-agnostic location readable by any AI coding tool
 - **Skills live in `.claude/skills/<name>/SKILL.md`** — single source of truth. Installed globally to `~/.claude/skills/`, `~/.config/opencode/skills/`, `~/.cursor/skills/` via the CLI. OpenCode and Cursor also read `~/.claude/skills/` as a cross-tool fallback.
 - **Rules/preferences are in `ENGINEERING.md`** — tool-specific files (`CLAUDE.md`, `AGENTS.md`, `.cursor/rules/engineering.mdc`) point to it
-- **Available skills:** `/new-project`, `/discover`, `/scaffold-foundation`, `/scaffold-auth`, `/scaffold-db`, `/audit`, plus `blueprint-catalog` (background, auto-invoked)
+- **Available skills:** `/new-project`, `/discover`, `/scaffold-foundation`, `/scaffold-env`, `/scaffold-tailwind`, `/scaffold-ui`, `/scaffold-auth`, `/scaffold-db`, `/audit`, plus `blueprint-catalog` (background, auto-invoked)
 - **BLUEPRINT.md required** in every blueprint directory. Placeholder blueprints must still have a BLUEPRINT.md documenting intended scope.

package/blueprints/features/auth-better-auth/BLUEPRINT.md

@@ -1,5 +1,9 @@
 # Auth Blueprint — Better Auth + Drizzle
 
+## Tier
+
+Feature
+
 ## Problem
 
 Full authentication and authorization for a TypeScript monorepo: multi-provider social login, email/password with verification, password reset, organization-based multi-tenancy with role-based permissions (owner/admin/member), invitation system, and session management with cookie-based route protection.

package/blueprints/features/db-drizzle-postgres/BLUEPRINT.md

@@ -551,6 +551,7 @@ Appends to `.project-context.md` under `## Installed Blueprints`:
 ```yaml
 ### db-drizzle-postgres
 blueprint: db-drizzle-postgres
+installed_at: <date>
 choices:
   schema_group: {{GROUP}}
   include_example: true|false

package/blueprints/features/env-t3/BLUEPRINT.md

@@ -297,6 +297,7 @@ Appends to `.project-context.md` under `## Installed Blueprints`:
 ```yaml
 ### env-t3
 blueprint: env-t3
+installed_at: <date>
 choices:
   nextjs_env_location: src/env/
   backend_env_location: src/env.ts

package/blueprints/features/tailwind-v4/BLUEPRINT.md

@@ -252,6 +252,7 @@ Appends to `.project-context.md` under `## Installed Blueprints`:
 ```yaml
 ### tailwind-v4
 blueprint: tailwind-v4
+installed_at: <date>
 choices:
   include_sidebar_tokens: true
   include_chart_tokens: true

package/blueprints/features/ui-shared-components/BLUEPRINT.md

@@ -338,6 +338,7 @@ Appends to `.project-context.md` under `## Installed Blueprints`:
 ```yaml
 ### ui-shared-components
 blueprint: ui-shared-components
+installed_at: <date>
 choices:
   shadcn_style: new-york
   icon_library: lucide

package/blueprints/foundation/monorepo-turbo/BLUEPRINT.md

@@ -372,7 +372,7 @@ linter: biome
 styling: tailwind-v4
 env_validation: t3-env + zod
 module_resolution: node subpath imports (#prefix)
-foundation_completed: <date>
+installed_at: <date>
 ```
 
 

package/dist/index.js

@@ -6,7 +6,7 @@ import pc3 from "picocolors";
 
 // src/constants.ts
 var API_URL = process.env["WITHMATA_API_URL"] || "https://blueprints.withmata.dev";
-var VERSION = "0.3.2";
+var VERSION = "0.3.4";
 
 // src/steps/auth.ts
 import { log } from "@clack/prompts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withmata/blueprints",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Set up AI-powered project blueprints for Claude Code, OpenCode, and Cursor",
   "type": "module",
   "bin": {