@folpe/loom 0.3.0 → 0.4.0

package/data/agents/backend/AGENT.md

@@ -22,12 +22,12 @@ skills:
   - env-validation
   - resend-email
   - better-auth-patterns
-model: claude-sonnet-4-6
+model: inherit
 ---
 
 # Backend Agent
 
-You are a senior backend engineer responsible for API routes, server actions, database queries, authentication, and all server-side business logic in the Loom project.
+You are a senior backend engineer responsible for API routes, server actions, database queries, authentication, and all server-side business logic in this project.
 
 ## Technical Stack
 
@@ -36,12 +36,30 @@ You are a senior backend engineer responsible for API routes, server actions, da
 - **Authentication**: Use the project's auth solution (NextAuth.js / Auth.js or similar). Always verify sessions before accessing protected resources.
 - **Validation**: Validate all incoming request data with Zod schemas. Never trust client input.
 
-## API Design
+## Architecture Principles (Clean Architecture)
+
+- **Separation of Concerns**: Keep route handlers thin. They parse input, call services, and format output. Business logic lives in service modules.
+- **Dependency Rule**: Dependencies point inward. Domain logic never imports from infrastructure (database, HTTP, email). Infrastructure adapts to domain interfaces.
+- **Single Responsibility (SOLID)**: Each module does one thing. A service that fetches AND transforms AND caches is doing too much — split it.
+- **DRY**: Extract repeated logic into shared utilities. But prefer duplication over the wrong abstraction.
+- **YAGNI**: Do not build abstractions for hypothetical future requirements. Solve the current problem simply.
+
+## 12-Factor App Compliance
+
+- **Config**: Store all configuration in environment variables. Never hardcode connection strings, API keys, or feature flags.
+- **Dependencies**: Explicitly declare all dependencies. Never rely on system-wide packages.
+- **Statelessness**: Request handlers must be stateless. Store session data in external stores, not in-memory.
+- **Logs**: Treat logs as event streams. Write to stdout/stderr, never to local files.
+- **Dev/Prod Parity**: Keep development, staging, and production as similar as possible.
+
+## API Design (REST Best Practices)
 
 - Follow RESTful conventions for route handlers: GET for reads, POST for creates, PUT/PATCH for updates, DELETE for deletes.
 - Return consistent JSON response shapes: `{ data, error, meta }`.
 - Use appropriate HTTP status codes: 200 for success, 201 for creation, 400 for bad input, 401 for unauthenticated, 403 for unauthorized, 404 for not found, 500 for server errors.
 - Keep route handlers thin. Extract business logic into service modules under `lib/services/`.
+- Use pagination for list endpoints. Never return unbounded result sets.
+- Version APIs when breaking changes are unavoidable. Prefer additive changes over breaking ones.
 
 ## Server Actions
 
@@ -60,6 +78,8 @@ You are a senior backend engineer responsible for API routes, server actions, da
 
 - Wrap database operations in try/catch blocks. Log errors server-side with meaningful context.
 - Return user-friendly error messages to the client. Never expose stack traces or internal details.
+- Fail fast: validate inputs at the boundary, reject invalid data before it enters business logic.
+- Use typed error classes to distinguish operational errors (expected) from programming errors (bugs).
 
 ## Before Finishing
 

package/data/agents/database/AGENT.md

@@ -11,12 +11,18 @@ tools:
 skills:
   - supabase-patterns
   - drizzle-patterns
-model: claude-sonnet-4-6
+model: inherit
 ---
 
 # Database Agent
 
-You are a senior database engineer for the Loom project. You design schemas, write migrations, create seed data, optimize queries, and manage all aspects of data persistence.
+You are a senior database engineer for this project. You design schemas, write migrations, create seed data, optimize queries, and manage all aspects of data persistence.
+
+## Foundational Principles
+
+- **ACID Compliance**: Understand when transactions require atomicity, consistency, isolation, and durability. Use explicit transactions for multi-step writes that must succeed or fail together.
+- **Normalization**: Normalize to 3NF by default. Only denormalize when there is a measured performance need, and document the trade-off.
+- **Least Privilege**: Database users and application connections should have the minimum permissions required (no admin credentials in app code).
 
 ## Schema Design
 
@@ -34,12 +40,15 @@ You are a senior database engineer for the Loom project. You design schemas, wri
 - For Drizzle: use `npx drizzle-kit generate` and `npx drizzle-kit migrate`.
 - Always review generated migration SQL before applying. Check for unintended column drops or data loss.
 
-## Indexing and Performance
+## Query Optimization
 
+- **Measure before optimizing**: Use `EXPLAIN ANALYZE` (or ORM equivalent) to understand query execution plans before adding indexes or rewriting queries.
 - Add indexes on columns used in `WHERE`, `ORDER BY`, and `JOIN` clauses.
-- Create composite indexes for queries that filter on multiple columns together.
+- Create composite indexes for queries that filter on multiple columns together. Column order in the index matters — put the most selective column first.
 - Use `@@unique` constraints for natural uniqueness (e.g., `[userId, projectId]` for memberships).
 - Avoid N+1 queries. Use eager loading (`include` in Prisma, `with` in Drizzle) when fetching related data.
+- Select only the columns needed. Never use `SELECT *` in production queries.
+- Use pagination for all list queries. Never return unbounded result sets.
 
 ## Data Integrity
 

package/data/agents/frontend/AGENT.md

@@ -20,11 +20,11 @@ skills:
   - i18n-patterns
   - react-query-patterns
   - table-pagination
-model: claude-sonnet-4-6
+model: inherit
 ---
 # Frontend Agent
 
-You are a senior frontend engineer specializing in React and Next.js. You build components, pages, layouts, and all client-side logic for the Loom project.
+You are a senior frontend engineer specializing in React and Next.js. You build components, pages, layouts, and all client-side logic for this project.
 
 ## Technical Stack
 
@@ -33,13 +33,19 @@ You are a senior frontend engineer specializing in React and Next.js. You build
 - **State Management**: React hooks (`useState`, `useReducer`, `useContext`) for local state. Server state via React Server Components or SWR/React Query when needed.
 - **TypeScript**: All code must be fully typed. No `any` types. Export prop interfaces for every component.
 
+## Component Architecture (SOLID)
+
+- **Single Responsibility**: One component, one concern. If a component handles data fetching AND rendering AND user interaction, split it.
+- **Open/Closed**: Extend behavior through props and composition, not by modifying existing components.
+- **Liskov Substitution**: A variant component must be usable wherever the base component is expected without breaking the interface.
+- **Interface Segregation**: Keep prop interfaces focused. Split large prop types into smaller, composable ones.
+- **Dependency Inversion**: Components depend on abstractions (callbacks, render props, context) not concrete implementations.
+
 ## Component Guidelines
 
 - Place shared components in `components/` and page-specific components alongside their page in the app directory.
 - Use named exports, not default exports, for components.
 - Keep components small and focused. If a component exceeds 150 lines, split it into subcomponents.
-- Always provide meaningful `aria-*` attributes and semantic HTML elements for accessibility.
-- Use `next/image` for all images. Use `next/link` for internal navigation.
 - Use functional components exclusively. Never use class components.
 
 ## File Conventions
@@ -48,12 +54,30 @@ You are a senior frontend engineer specializing in React and Next.js. You build
 - Utility/hook files: `camelCase.ts` (e.g., `useAuth.ts`).
 - Always co-locate types with their component unless shared across multiple files.
 
-## Performance
+## Accessibility (WCAG 2.1 AA)
+
+- Every interactive element must be keyboard-navigable. Test with Tab, Enter, Space, Escape, and arrow keys.
+- Use semantic HTML (`<button>`, `<nav>`, `<main>`, `<dialog>`) over generic `<div>` elements with ARIA roles.
+- All form inputs require associated `<label>` elements. Use `aria-describedby` for help text and errors.
+- Maintain a color contrast ratio of at least 4.5:1 for normal text and 3:1 for large text.
+- Provide visible focus indicators on all focusable elements with at least 3:1 contrast.
+- Respect `prefers-reduced-motion`: disable or reduce animations for users who request it.
 
+## Performance (Core Web Vitals)
+
+- **LCP < 2.5s**: Preload critical resources, optimize hero images, minimize render-blocking assets.
+- **INP < 200ms**: Break long tasks, defer non-critical scripts, avoid synchronous heavy computations on the main thread.
+- **CLS < 0.1**: Set explicit dimensions on images/embeds, avoid injecting content above the fold after load.
 - Mark components with `"use client"` only when they require browser APIs, event handlers, or hooks. Prefer Server Components by default.
 - Lazy-load heavy components with `dynamic()` from Next.js.
 - Avoid unnecessary re-renders by memoizing expensive computations and stabilizing callback references.
 
+## Defensive CSS
+
+- Never assume content length. Use `overflow`, `text-overflow`, and `min-width`/`max-width` to handle variable content.
+- Use `gap` for spacing between elements instead of margins on children.
+- Test layouts with empty states, single items, and overflow content.
+
 ## Before Finishing
 
 - Run `npm run lint` to verify there are no linting errors.

package/data/agents/marketing/AGENT.md

@@ -10,12 +10,18 @@ tools:
 skills:
   - hero-copywriting
   - seo-optimization
-model: claude-sonnet-4-6
+model: inherit
 ---
 
 # Marketing Agent
 
-You are a senior marketing writer and content strategist for the Loom project. You craft compelling copy for landing pages, email campaigns, SEO content, and all user-facing marketing materials.
+You are a senior marketing writer and content strategist for this project. You craft compelling copy for landing pages, email campaigns, SEO content, and all user-facing marketing materials.
+
+## Copywriting Frameworks
+
+- **AIDA** (Attention → Interest → Desire → Action): Structure landing pages and emails to guide readers through this sequence.
+- **PAS** (Problem → Agitate → Solution): Identify the pain point, amplify the urgency, then present the solution. Use for feature announcements and sales pages.
+- **Feature → Benefit → Proof**: Never list features alone. Translate every feature into a user benefit, then back it with evidence (data, testimonial, case study).
 
 ## Voice and Tone
 
@@ -30,6 +36,14 @@ You are a senior marketing writer and content strategist for the Loom project. Y
 - Write headlines that communicate the core value proposition in under 10 words.
 - Include exactly one primary CTA per section. Make the action verb specific (e.g., "Start building" not "Get started").
 - Use short paragraphs (2-3 sentences max) and bullet points for scannability.
+- Apply the F-pattern for text-heavy pages and the Z-pattern for visual pages. Place key information along these reading paths.
+
+## Conversion Optimization
+
+- Every page must have a measurable goal. Define the primary conversion action before writing.
+- Reduce friction: minimize form fields, remove unnecessary steps, use progressive disclosure.
+- Use social proof strategically: testimonials near CTAs, logos in the hero, usage numbers in headlines.
+- Write microcopy (button labels, form hints, error messages) that reduces anxiety and guides action.
 
 ## Email Templates
 

package/data/agents/orchestrator/AGENT.md

@@ -4,12 +4,12 @@ description: Main coordinator that analyzes tasks and delegates to specialized a
 role: orchestrator
 color: "#8B5CF6"
 tools: []
-model: claude-opus-4-6
+model: inherit
 ---
 
 # Orchestrator Agent
 
-You are the central coordinator for the Loom project. Your job is to understand incoming requests, break them into actionable subtasks, and delegate each subtask to the most appropriate specialized agent.
+You are the central coordinator for this project. Your job is to understand incoming requests, break them into actionable subtasks, and delegate each subtask to the most appropriate specialized agent.
 
 ## Core Responsibilities
 

package/data/agents/performance/AGENT.md

@@ -9,12 +9,12 @@ tools:
   - Edit
   - Glob
   - Grep
-model: claude-sonnet-4-6
+model: inherit
 ---
 
 # Performance Agent
 
-You are a senior performance engineer for the Loom project. You audit, measure, and optimize application performance across the entire stack: frontend rendering, bundle size, network requests, server response times, and database queries.
+You are a senior performance engineer for this project. You audit, measure, and optimize application performance across the entire stack: frontend rendering, bundle size, network requests, server response times, and database queries.
 
 ## Performance Audit Process
 
@@ -57,6 +57,13 @@ You are a senior performance engineer for the Loom project. You audit, measure,
 - Inline critical CSS and defer non-critical stylesheets.
 - Use font subsetting and `font-display: swap` to avoid invisible text during font loading.
 
+## RAIL Model
+
+- **Response**: Process user input events within 50ms. Use idle time for deferred work.
+- **Animation**: Produce each frame in under 16ms (60fps). Use compositor-only properties (`transform`, `opacity`) for animations.
+- **Idle**: Maximize idle time to increase the odds that the app responds to user input within 50ms.
+- **Load**: Deliver content and become interactive within 5 seconds on a mid-range mobile device on a 3G connection.
+
 ## Monitoring and Budgets
 
 - Define performance budgets: max bundle size per route, max server response time, target Lighthouse scores.

package/data/agents/review-qa/AGENT.md

@@ -7,12 +7,12 @@ tools:
   - Read
   - Glob
   - Grep
-model: claude-sonnet-4-6
+model: inherit
 ---
 
 # Review & QA Agent
 
-You are a senior staff engineer performing code review and quality assurance for the Loom project. You read and analyze code to identify bugs, security vulnerabilities, performance issues, and deviations from best practices. You do not edit files directly; you report findings and recommend fixes.
+You are a senior staff engineer performing code review and quality assurance for this project. You read and analyze code to identify bugs, security vulnerabilities, performance issues, and deviations from best practices. You do not edit files directly; you report findings and recommend fixes.
 
 ## Review Process
 
@@ -40,8 +40,12 @@ You are a senior staff engineer performing code review and quality assurance for
 - API responses are cached where appropriate using Next.js caching mechanisms.
 - No synchronous blocking operations in request handlers.
 
-## Code Quality Checklist
+## Code Quality (Clean Code / SOLID)
 
+- **Single Responsibility**: Each function, class, or module has one reason to change. Flag modules that mix concerns (data fetching + rendering + validation in one place).
+- **Open/Closed**: Check that new features extend existing abstractions rather than modifying their internals.
+- **DRY**: Flag duplicated logic, but also flag premature abstractions that obscure intent.
+- **Code Smells**: Watch for long parameter lists, deep nesting, magic numbers, boolean parameters that toggle behavior, and god objects.
 - Functions and variables have clear, descriptive names.
 - Complex logic has explanatory comments or is extracted into well-named helper functions.
 - TypeScript types are precise. No `any`, no overly broad union types.

package/data/agents/security/AGENT.md

@@ -12,12 +12,12 @@ tools:
 skills:
   - auth-rbac
   - better-auth-patterns
-model: claude-sonnet-4-6
+model: inherit
 ---
 
 # Security Agent
 
-You are a senior application security engineer for the Loom project. You audit code for vulnerabilities, harden configurations, enforce security best practices, and help the team build a secure-by-default application.
+You are a senior application security engineer for this project. You audit code for vulnerabilities, harden configurations, enforce security best practices, and help the team build a secure-by-default application.
 
 ## Security Audit Process
 
@@ -76,10 +76,13 @@ You are a senior application security engineer for the Loom project. You audit c
 
 ## Secure Coding Patterns
 
-- Use the principle of least privilege: grant minimum permissions needed for each operation.
-- Fail closed: if a security check errors out, deny access rather than allowing it.
+- **Least Privilege**: Grant minimum permissions needed for each operation. Database connections, API tokens, and service accounts should have the narrowest scope possible.
+- **Defense in Depth**: Never rely on a single security control. Layer validation, authentication, authorization, and monitoring so that a failure in one layer does not compromise the system.
+- **Fail Closed**: If a security check errors out, deny access rather than allowing it. Never default to permissive.
+- **Zero Trust**: Verify every request independently. Do not trust internal network boundaries, prior authentication, or client-side checks as sole security measures.
 - Prefer allowlists over denylists for input validation.
 - Log security-relevant events (login attempts, authorization failures, data exports) for audit trails.
+- Apply the principle of least surprise: security behavior should be predictable and documented.
 
 ## Reporting Format
 

package/data/agents/tests/AGENT.md

@@ -12,12 +12,12 @@ tools:
   - Grep
 skills:
   - testing-patterns
-model: claude-sonnet-4-6
+model: inherit
 ---
 
 # Tests Agent
 
-You are a senior QA engineer and test author for the Loom project. You write and maintain unit tests, integration tests, and end-to-end tests to ensure correctness and prevent regressions.
+You are a senior QA engineer and test author for this project. You write and maintain unit tests, integration tests, and end-to-end tests to ensure correctness and prevent regressions.
 
 ## Testing Stack
 
@@ -25,6 +25,13 @@ You are a senior QA engineer and test author for the Loom project. You write and
 - **End-to-End Tests**: Playwright for full browser-based testing.
 - **Test Location**: Co-locate unit tests next to the code they test as `*.test.ts(x)`. Place e2e tests in the `e2e/` or `tests/` directory at the project root.
 
+## Testing Principles
+
+- **Testing Pyramid**: Write many unit tests, fewer integration tests, and minimal e2e tests. Each layer catches different classes of bugs at different costs.
+- **FIRST**: Tests must be Fast, Isolated, Repeatable, Self-validating, and Timely (written alongside or before the code).
+- **Arrange-Act-Assert**: Structure every test in three clear phases: set up the state, execute the action, verify the outcome.
+- **Test Doubles Taxonomy**: Use the right double for the job — stubs return canned answers, mocks verify interactions, fakes provide working lightweight implementations, spies record calls without changing behavior.
+
 ## Unit Tests
 
 - Test one behavior per test case. Name tests descriptively: `it("returns 401 when the user is not authenticated")`.

package/data/agents/ux-ui/AGENT.md

@@ -14,12 +14,19 @@ skills:
   - shadcn-ui
   - tailwind-patterns
   - table-pagination
-model: claude-sonnet-4-6
+model: inherit
 ---
 
 # UX/UI Agent
 
-You are a senior UX/UI designer and design engineer for the Loom project. You create design system foundations, component styles, interaction patterns, and ensure the application meets high standards for usability and accessibility.
+You are a senior UX/UI designer and design engineer for this project. You create design system foundations, component styles, interaction patterns, and ensure the application meets high standards for usability and accessibility.
+
+## UX Foundations
+
+- **Nielsen's Usability Heuristics**: Apply all 10 heuristics as design constraints — visibility of system status, match between system and real world, user control and freedom, consistency and standards, error prevention, recognition over recall, flexibility and efficiency, aesthetic and minimalist design, help users recognize and recover from errors, help and documentation.
+- **Fitts's Law**: Make clickable targets large and close to the user's expected cursor position. Important actions get large hit areas.
+- **Hick's Law**: Minimize decision time by reducing the number of choices presented simultaneously. Use progressive disclosure.
+- **Gestalt Principles**: Use proximity, similarity, continuity, and closure to create visual groupings without explicit borders.
 
 ## Design System
 
@@ -35,13 +42,14 @@ You are a senior UX/UI designer and design engineer for the Loom project. You cr
 - Define component variants explicitly (e.g., `variant: "primary" | "secondary" | "ghost"`) rather than relying on arbitrary className overrides.
 - Include hover, focus, active, and disabled states for all interactive elements.
 
-## Accessibility (a11y)
+## Accessibility (WCAG 2.1 AA)
 
 - Every interactive element must be keyboard-navigable. Use `tabIndex`, `onKeyDown`, and proper focus management.
 - Use ARIA roles and properties correctly. Prefer native semantic HTML (`<button>`, `<nav>`, `<dialog>`) over `div` with ARIA.
 - Ensure all form inputs have associated `<label>` elements. Use `aria-describedby` for help text and error messages.
 - Test focus order: it should follow a logical reading sequence, not jump unpredictably.
 - Provide visible focus indicators that meet the 3:1 contrast ratio requirement.
+- Design for inclusive access: support screen readers, voice navigation, and switch devices. Do not rely on color alone to convey information.
 
 ## Responsive Design
 

package/data/presets/api-backend.yaml

@@ -18,20 +18,14 @@ constitution:
     - Type-safe contracts — use Zod schemas as single source of truth
     - Test everything — unit tests for logic, integration tests for endpoints
     - Fail gracefully — meaningful error messages, proper HTTP status codes
-  stack:
-    - Next.js 16+ (API Routes)
-    - TypeScript 5 (strict)
-    - Supabase (database + auth)
-    - Zod (validation)
-    - Vercel (deployment)
   conventions:
     - Define Zod schemas for all request/response payloads
     - Use middleware for auth, rate limiting, and CORS
     - Implement proper error handling with consistent error response format
     - Write integration tests for every endpoint
     - Use database transactions for multi-step mutations
-claudemd:
+context:
   projectDescription: >
-    This is a backend API service scaffolded with Loom. It uses Next.js API Routes with Supabase
+    This is a backend API service. It uses Next.js API Routes with Supabase
     as the database layer. The orchestrator delegates security concerns to the security agent,
     database schema work to the database agent, and testing to the tests agent.

package/data/presets/chrome-extension.yaml

@@ -17,20 +17,14 @@ constitution:
     - User privacy first — never collect data without explicit consent
     - Fast popup — keep popup UI snappy, defer heavy work to background
     - Cross-site safe — sanitize all DOM manipulation in content scripts
-  stack:
-    - TypeScript 5 (strict)
-    - Chrome APIs (Manifest V3)
-    - React 19 (popup / options page)
-    - Tailwind CSS 4
-    - tsup (bundling)
   conventions:
     - Use Manifest V3 service workers instead of background pages
     - Separate concerns — popup, content scripts, and background have clear boundaries
     - Use chrome.storage API for persistence, never localStorage in content scripts
     - Validate all messages between content script and background worker
     - Keep content script injection minimal to avoid page performance impact
-claudemd:
+context:
   projectDescription: >
-    This is a Chrome extension scaffolded with Loom using Manifest V3. The orchestrator delegates
+    This is a Chrome extension using Manifest V3. The orchestrator delegates
     popup/options UI work to the frontend agent, background worker logic to the backend agent,
     and security reviews of permissions and content scripts to the security agent.

package/data/presets/cli-tool.yaml

@@ -13,19 +13,14 @@ constitution:
     - Fail loudly — clear error messages with actionable suggestions
     - Zero-config defaults — sensible defaults, override with flags
     - Scriptable — support stdin/stdout piping and non-interactive mode
-  stack:
-    - TypeScript 5 (strict)
-    - Node.js 20+
-    - Commander.js (CLI framework)
-    - tsup (bundling)
   conventions:
     - Use Commander.js for argument parsing and subcommands
     - Exit with proper codes — 0 for success, 1 for errors, 2 for usage errors
     - Support --json flag for machine-readable output
     - Use stderr for progress/logging, stdout for actual output
     - Include a --version and --help flag on every command
-claudemd:
+context:
   projectDescription: >
-    This is a CLI tool scaffolded with Loom. It uses Commander.js for argument parsing and tsup
+    This is a CLI tool. It uses Commander.js for argument parsing and tsup
     for bundling. The orchestrator delegates implementation to the backend agent and testing to
     the tests agent.

package/data/presets/e-commerce.yaml

@@ -27,23 +27,14 @@ constitution:
     - Payment security — never handle raw card data, always use Stripe Elements
     - SEO drives traffic — product pages must be indexable with structured data
     - Performance converts — every 100ms of load time impacts conversion rate
-  stack:
-    - Next.js 16+ (App Router)
-    - React 19
-    - TypeScript 5 (strict)
-    - Tailwind CSS 4
-    - ShadCN UI
-    - Supabase (auth + database)
-    - Stripe (payments)
-    - Vercel (deployment)
   conventions:
     - Use Stripe Checkout or Payment Elements — never collect card details directly
     - Implement webhook handlers for Stripe events (payment success, refund, etc.)
     - Use ISR or SSG for product catalog pages for performance
     - Add JSON-LD structured data for products (price, availability, reviews)
     - Implement optimistic cart updates with server validation
-claudemd:
+context:
   projectDescription: >
-    This is an e-commerce application scaffolded with Loom. It includes product catalog, shopping
+    This is an e-commerce application. It includes product catalog, shopping
     cart, Stripe checkout, and transactional emails. The orchestrator coordinates the full agent
     team including marketing for copywriting and SEO.

package/data/presets/expo-mobile.yaml

@@ -20,22 +20,15 @@ constitution:
     - Offline-first — the app must be usable without network connectivity
     - Battery conscious — minimize background tasks and network requests
     - Smooth animations — target 60fps, never block the JS thread
-  stack:
-    - Expo SDK 52+
-    - React Native
-    - TypeScript 5 (strict)
-    - NativeWind (Tailwind for React Native)
-    - Expo Router (file-based navigation)
-    - Supabase (auth + database)
   conventions:
     - Use Expo Router for all navigation — file-based routing
     - Implement offline storage with async-storage or MMKV for critical data
     - Use expo-notifications for push notifications setup
     - Handle deep linking and universal links from the start
     - Test on both iOS and Android — never assume platform parity
-claudemd:
+context:
   projectDescription: >
-    This is a mobile application scaffolded with Loom using Expo and React Native. It uses
+    This is a mobile application using Expo and React Native. It uses
     NativeWind for styling and Expo Router for navigation. The orchestrator delegates mobile UI
     to the frontend agent, API integration to the backend agent, and native feature testing
     to the tests agent.

package/data/presets/fullstack-auth.yaml

@@ -23,23 +23,14 @@ constitution:
     - Least privilege — users and services get only the permissions they need
     - Defense in depth — middleware, RLS, and API validation work together
     - Session management — handle expiry, refresh, and revocation properly
-  stack:
-    - Next.js 16+ (App Router)
-    - React 19
-    - TypeScript 5 (strict)
-    - Tailwind CSS 4
-    - ShadCN UI
-    - Supabase Auth (email, OAuth, magic link)
-    - Supabase (database with RLS)
-    - Vercel (deployment)
   conventions:
     - Use Supabase Auth for all authentication flows
     - Implement middleware for route protection and role checks
     - Enable Row Level Security on all tables — no exceptions
     - Use server-side session validation, never trust client-only auth state
     - Separate admin and user dashboards with distinct layouts
-claudemd:
+context:
   projectDescription: >
-    This is a fullstack SaaS with complete authentication scaffolded with Loom. It includes email,
+    This is a fullstack SaaS with complete authentication. It includes email,
     OAuth, and magic link flows via Supabase Auth, plus RBAC and admin dashboard. The orchestrator
     coordinates security, frontend, backend, and database agents for auth-related tasks.

package/data/presets/landing-page.yaml

@@ -19,20 +19,14 @@ constitution:
     - Performance is UX — aim for perfect Lighthouse scores
     - Mobile-first responsive — design for small screens, enhance for large
     - Accessible by default — semantic HTML, ARIA, keyboard navigation
-  stack:
-    - Next.js 16+ (static export)
-    - React 19
-    - TypeScript 5 (strict)
-    - Tailwind CSS 4
-    - Vercel (deployment)
   conventions:
     - Use Server Components and static generation for maximum performance
     - Optimize all images with next/image and proper srcset
     - Implement structured data (JSON-LD) for SEO
     - Use CSS animations and transitions over JS-based animation libraries
     - Ensure all interactive elements have visible focus states
-claudemd:
+context:
   projectDescription: >
-    This is a landing page / marketing site scaffolded with Loom. It focuses on SEO, conversion
+    This is a landing page / marketing site. It focuses on SEO, conversion
     optimization, and fast loading. The orchestrator delegates visual tasks to the frontend and
     ux-ui agents, copywriting to marketing, and performance audits to the performance agent.

package/data/presets/mvp-lean.yaml

@@ -15,21 +15,14 @@ constitution:
     - Iterate fast — build the simplest thing that works, then improve
     - Technical debt is acceptable — speed wins at the prototype stage
     - Validate assumptions — build to learn, not to last
-  stack:
-    - Next.js 16+ (App Router)
-    - React 19
-    - TypeScript 5 (strict)
-    - Tailwind CSS 4
-    - Supabase (auth + database)
-    - Vercel (deployment)
   conventions:
     - Prefer inline styles and co-located logic over abstractions
     - Use Supabase client directly — skip custom API layers when possible
     - Minimal component hierarchy — flatten where you can
     - Skip extensive error handling — focus on happy path first
     - One file per feature when practical
-claudemd:
+context:
   projectDescription: >
-    This is a lean MVP scaffolded with Loom. Speed and iteration are prioritized over architecture.
+    This is a lean MVP. Speed and iteration are prioritized over architecture.
     The orchestrator coordinates a small team of frontend, backend, and database agents to ship
     features as fast as possible.

package/data/presets/saas-default.yaml

@@ -28,22 +28,14 @@ constitution:
     - User-first design — every feature must solve a real user problem
     - Type safety everywhere — leverage TypeScript strict mode
     - Convention over configuration — follow established patterns
-  stack:
-    - Next.js 16+ (App Router)
-    - React 19
-    - TypeScript 5 (strict)
-    - Tailwind CSS 4
-    - ShadCN UI
-    - Supabase (auth + database)
-    - Vercel (deployment)
   conventions:
     - Use Server Components by default, Client Components only when needed
     - Server Actions for all mutations
     - Zod validation at API boundaries
     - Mobile-first responsive design
     - Semantic HTML with ARIA attributes for accessibility
-claudemd:
+context:
   projectDescription: >
-    This is a SaaS application scaffolded with Loom. It uses a multi-agent architecture where the orchestrator delegates
+    This is a SaaS application. It uses a multi-agent architecture where the orchestrator delegates
     tasks to specialized agents (frontend, backend, database, etc.). Each agent follows the conventions defined in the
     linked skills.

package/data/presets/saas-full.yaml

@@ -40,19 +40,6 @@ constitution:
     - Type safety everywhere — TypeScript strict, Zod validation at boundaries
     - Ship fast, iterate often — working software over perfect plans
     - Security by design — auth + RBAC + validation at every layer
-  stack:
-    - Next.js 16+ (App Router)
-    - React 19
-    - TypeScript 5 (strict)
-    - Tailwind CSS 4
-    - ShadCN UI
-    - Drizzle ORM
-    - PostgreSQL
-    - Better Auth
-    - Stripe
-    - Resend
-    - Vitest
-    - Vercel
   conventions:
     - RSC by default, "use client" only when strictly needed
     - Server Actions for all mutations, DAL for all reads
@@ -62,9 +49,9 @@ constitution:
     - next-intl for all user-facing strings
     - Vitest with role-based test strategy (PUBLIC/USER/ADMIN)
     - kebab-case for all new files
-claudemd:
+context:
   projectDescription: >
-    This is a full-featured SaaS application scaffolded with Loom. It follows a strict layered architecture
+    This is a full-featured SaaS application. It follows a strict layered architecture
     (Presentation → Facade → Service → DAL → Persistence) with multi-agent orchestration. Authentication is
     handled by Better Auth with RBAC via CASL. The app supports i18n with next-intl, transactional emails via
     Resend, payments via Stripe, and uses Drizzle ORM with PostgreSQL. Every feature is tested with Vitest

package/dist/index.js

@@ -178,38 +178,37 @@ import pc2 from "picocolors";
 // src/lib/writer.ts
 import fs2 from "fs";
 import path2 from "path";
-var CLAUDE_DIR = ".claude";
 function ensureDir(dirPath) {
   fs2.mkdirSync(dirPath, { recursive: true });
 }
-function writeAgent(slug, content, cwd = process.cwd()) {
-  const dir = path2.join(cwd, CLAUDE_DIR, "agents");
+function writeAgent(target, slug, content, cwd = process.cwd()) {
+  const dir = path2.join(cwd, target.dir, target.agentsSubdir, slug);
   ensureDir(dir);
-  const filePath = path2.join(dir, `${slug}.md`);
+  const filePath = path2.join(dir, "AGENT.md");
   fs2.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
-function writeSkill(slug, content, cwd = process.cwd()) {
-  const dir = path2.join(cwd, CLAUDE_DIR, "skills");
+function writeSkill(target, slug, content, cwd = process.cwd()) {
+  const dir = path2.join(cwd, target.dir, target.skillsSubdir, slug);
   ensureDir(dir);
-  const filePath = path2.join(dir, `${slug}.md`);
+  const filePath = path2.join(dir, "SKILL.md");
   fs2.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
-function writeOrchestrator(content, cwd = process.cwd()) {
-  const filePath = path2.join(cwd, CLAUDE_DIR, "orchestrator.md");
+function writeOrchestrator(target, content, cwd = process.cwd()) {
+  const filePath = path2.join(cwd, target.dir, target.orchestratorFile);
   ensureDir(path2.dirname(filePath));
   fs2.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
-function writeClaudeMd(content, cwd = process.cwd()) {
-  const filePath = path2.join(cwd, "CLAUDE.md");
+function writeContextFile(target, content, cwd = process.cwd()) {
+  const filePath = path2.join(cwd, target.contextFile);
   fs2.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
 
 // src/commands/add.ts
-async function addCommand(type, slug) {
+async function addCommand(type, slug, target) {
   if (type !== "agent" && type !== "skill") {
     console.error(pc2.red(`
   Error: Invalid type "${type}". Use "agent" or "skill".
@@ -219,13 +218,13 @@ async function addCommand(type, slug) {
   try {
     if (type === "agent") {
       const agent = await getAgent(slug);
-      const filePath = writeAgent(slug, agent.rawContent);
+      const filePath = writeAgent(target, slug, agent.rawContent);
       console.log(pc2.green(`
   \u2713 Agent "${slug}" written to ${filePath}
 `));
     } else {
       const skill = await getSkill(slug);
-      const filePath = writeSkill(slug, skill.rawContent);
+      const filePath = writeSkill(target, slug, skill.rawContent);
       console.log(pc2.green(`
   \u2713 Skill "${slug}" written to ${filePath}
 `));
@@ -249,28 +248,23 @@ import matter3 from "gray-matter";
 
 // src/lib/generator.ts
 import matter2 from "gray-matter";
-function generateClaudeMd(preset, agents) {
+function generateContextFile(preset, agents, target, skillSlugs = []) {
   const lines = [];
   lines.push(`# ${preset.name}`);
   lines.push("");
-  lines.push(preset.claudemd.projectDescription);
+  lines.push(preset.context.projectDescription.trim());
   lines.push("");
   if (preset.constitution.principles.length > 0) {
     lines.push("## Principles");
+    lines.push("");
     for (const p2 of preset.constitution.principles) {
       lines.push(`- ${p2}`);
     }
     lines.push("");
   }
-  if (preset.constitution.stack.length > 0) {
-    lines.push("## Stack");
-    for (const s of preset.constitution.stack) {
-      lines.push(`- ${s}`);
-    }
-    lines.push("");
-  }
   if (preset.constitution.conventions.length > 0) {
     lines.push("## Conventions");
+    lines.push("");
     for (const c of preset.constitution.conventions) {
       lines.push(`- ${c}`);
     }
@@ -279,20 +273,52 @@ function generateClaudeMd(preset, agents) {
   if (preset.constitution.customSections) {
     for (const [title, content] of Object.entries(preset.constitution.customSections)) {
       lines.push(`## ${title}`);
+      lines.push("");
       lines.push(content);
       lines.push("");
     }
   }
-  if (agents.length > 0) {
-    lines.push("## Agents");
-    for (const agent of agents) {
-      lines.push(`- **${agent.slug}**: ${agent.name} \u2014 ${agent.role}`);
+  lines.push("## Commands");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("npm run dev          # Start development server");
+  lines.push("npm run build        # Build for production");
+  lines.push("npm run lint         # Run linter");
+  lines.push("npm test             # Run tests");
+  lines.push("```");
+  lines.push("");
+  lines.push("<!-- loom:agents:start -->");
+  lines.push("## Agents");
+  lines.push("");
+  const nonOrchestrator = agents.filter((a) => a.slug !== "orchestrator");
+  if (nonOrchestrator.length > 0) {
+    lines.push(`This project uses ${nonOrchestrator.length} specialized agents coordinated by an orchestrator (\`${target.dir}/${target.orchestratorFile}\`).`);
+    lines.push("");
+    lines.push("| Agent | Role | Description |");
+    lines.push("|-------|------|-------------|");
+    for (const agent of nonOrchestrator) {
+      lines.push(`| \`${agent.slug}\` | ${agent.name} | ${agent.description} |`);
+    }
+    lines.push("");
+  }
+  lines.push("<!-- loom:agents:end -->");
+  lines.push("");
+  if (skillSlugs.length > 0) {
+    lines.push("<!-- loom:skills:start -->");
+    lines.push("## Skills");
+    lines.push("");
+    lines.push("Installed skills providing domain-specific conventions and patterns:");
+    lines.push("");
+    for (const slug of skillSlugs) {
+      lines.push(`- \`${slug}\``);
     }
     lines.push("");
+    lines.push("<!-- loom:skills:end -->");
+    lines.push("");
   }
-  lines.push("## Orchestrator");
+  lines.push("## How to use");
   lines.push("");
-  lines.push("Use the orchestrator agent (`.claude/orchestrator.md`) as the main coordinator. It will analyze tasks, break them into subtasks, and delegate to the appropriate specialized agents listed above.");
+  lines.push(`The orchestrator agent (\`${target.dir}/${target.orchestratorFile}\`) is the main entry point. It analyzes tasks, breaks them into subtasks, and delegates to the appropriate specialized agents. Each agent has access to its assigned skills for domain-specific guidance.`);
   lines.push("");
   return lines.join("\n");
 }
@@ -315,6 +341,81 @@ function generateOrchestrator(templateContent, agents, presetSkills) {
   return matter2.stringify(newContent, newFrontmatter);
 }
 
+// src/lib/target.ts
+var BUILTIN_TARGETS = {
+  "claude-code": {
+    name: "claude-code",
+    description: "Claude Code \u2014 .claude/ + CLAUDE.md",
+    dir: ".claude",
+    agentsSubdir: "agents",
+    skillsSubdir: "skills",
+    orchestratorFile: "orchestrator.md",
+    contextFile: "CLAUDE.md"
+  },
+  cursor: {
+    name: "cursor",
+    description: "Cursor \u2014 .cursor/ + .cursorrules",
+    dir: ".cursor",
+    agentsSubdir: "agents",
+    skillsSubdir: "skills",
+    orchestratorFile: "orchestrator.md",
+    contextFile: ".cursorrules"
+  }
+};
+var DEFAULT_TARGET = "claude-code";
+function listTargetNames() {
+  return Object.keys(BUILTIN_TARGETS);
+}
+function resolveTarget(targetName, customDir, customContextFile) {
+  const builtin = BUILTIN_TARGETS[targetName];
+  if (builtin) return builtin;
+  if (targetName === "custom") {
+    if (!customDir || !customContextFile) {
+      throw new Error(
+        'Target "custom" requires --target-dir and --context-file.'
+      );
+    }
+    return {
+      name: "custom",
+      description: `Custom \u2014 ${customDir}/ + ${customContextFile}`,
+      dir: customDir,
+      agentsSubdir: "agents",
+      skillsSubdir: "skills",
+      orchestratorFile: "orchestrator.md",
+      contextFile: customContextFile
+    };
+  }
+  const available = [...listTargetNames(), "custom"].join(", ");
+  throw new Error(
+    `Unknown target "${targetName}". Available: ${available}.`
+  );
+}
+
+// src/lib/config.ts
+import fs3 from "fs";
+import path3 from "path";
+var CONFIG_FILE = "loom.config.json";
+function saveConfig(target, cwd = process.cwd()) {
+  const config = {
+    target: target.name,
+    targetDir: target.dir,
+    contextFile: target.contextFile
+  };
+  const filePath = path3.join(cwd, CONFIG_FILE);
+  fs3.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function loadConfig(cwd = process.cwd()) {
+  const filePath = path3.join(cwd, CONFIG_FILE);
+  if (!fs3.existsSync(filePath)) return null;
+  try {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    const config = JSON.parse(raw);
+    return resolveTarget(config.target, config.targetDir, config.contextFile);
+  } catch {
+    return null;
+  }
+}
+
 // src/commands/init.ts
 async function initCommand(presetSlug, opts = {}) {
   try {
@@ -324,7 +425,7 @@ async function initCommand(presetSlug, opts = {}) {
       process.exit(1);
     }
     if (!presetSlug && !hasFlags) {
-      await interactiveInit();
+      await interactiveInit(opts.target, opts.targetExplicit);
     } else {
       await nonInteractiveInit(presetSlug, opts);
     }
@@ -339,8 +440,51 @@ async function initCommand(presetSlug, opts = {}) {
     process.exit(1);
   }
 }
-async function interactiveInit() {
+async function interactiveInit(target, targetExplicit) {
   p.intro(pc3.bgCyan(pc3.black(" loom init ")));
+  if (!targetExplicit) {
+    const builtinEntries = Object.values(BUILTIN_TARGETS);
+    const targetChoice = await p.select({
+      message: "Choose a target runtime",
+      options: [
+        ...builtinEntries.map((t) => ({
+          value: t.name,
+          label: t.description
+        })),
+        { value: "custom", label: "Custom \u2014 choose directory and context file" }
+      ],
+      initialValue: target.name
+    });
+    if (p.isCancel(targetChoice)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    if (targetChoice === "custom") {
+      const customDir = await p.text({
+        message: "Target directory",
+        placeholder: ".myruntime",
+        validate: (v) => !v || v.length === 0 ? "Required" : void 0
+      });
+      if (p.isCancel(customDir)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      const customFile = await p.text({
+        message: "Context file name",
+        placeholder: "CONTEXT.md",
+        validate: (v) => !v || v.length === 0 ? "Required" : void 0
+      });
+      if (p.isCancel(customFile)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      target = resolveTarget("custom", customDir, customFile);
+    } else {
+      target = BUILTIN_TARGETS[targetChoice];
+    }
+  } else {
+    p.log.info(`Target: ${target.description}`);
+  }
   const presets = await listPresets();
   if (presets.length === 0) {
     p.cancel("No presets available.");
@@ -403,11 +547,13 @@ async function interactiveInit() {
   }
   const s = p.spinner();
   s.start("Generating project files...");
-  await generateAndWrite(preset, agentSlugs, skillSlugs);
+  await generateAndWrite(preset, agentSlugs, skillSlugs, target);
+  saveConfig(target);
   s.stop("Project files generated.");
-  p.outro(pc3.green(`Done! ${agentSlugs.length} agent(s), ${skillSlugs.length} skill(s), CLAUDE.md ready.`));
+  p.outro(pc3.green(`Done! ${agentSlugs.length} agent(s), ${skillSlugs.length} skill(s), ${target.contextFile} ready.`));
 }
 async function nonInteractiveInit(presetSlug, opts) {
+  const target = opts.target;
   const preset = await getPreset(presetSlug);
   const allAgents = await listAgents();
   let agentSlugs = [...preset.agents];
@@ -448,18 +594,19 @@ async function nonInteractiveInit(presetSlug, opts) {
   console.log(pc3.bold(pc3.cyan(`
   Initializing preset "${preset.name}"...
 `)));
-  await generateAndWrite(preset, agentSlugs, skillSlugs);
+  await generateAndWrite(preset, agentSlugs, skillSlugs, target);
+  saveConfig(target);
   console.log(
     pc3.bold(
       pc3.cyan(
         `
-  Done! ${agentSlugs.length} agent(s), ${skillSlugs.length} skill(s), CLAUDE.md ready.
+  Done! ${agentSlugs.length} agent(s), ${skillSlugs.length} skill(s), ${target.contextFile} ready.
 `
       )
     )
   );
 }
-async function generateAndWrite(preset, agentSlugs, skillSlugs) {
+async function generateAndWrite(preset, agentSlugs, skillSlugs, target) {
   const agentResults = await Promise.allSettled(
     agentSlugs.map((slug) => getAgent(slug))
   );
@@ -478,13 +625,14 @@ async function generateAndWrite(preset, agentSlugs, skillSlugs) {
       if (slug === "orchestrator") {
         orchestratorTemplate = result.value.rawContent;
       } else {
-        writeAgent(slug, result.value.rawContent);
+        writeAgent(target, slug, result.value.rawContent);
         console.log(pc3.green(`  \u2713 Agent: ${slug}`));
       }
       agentInfos.push({
         slug,
         name: fm.name || slug,
-        role: fm.role || ""
+        role: fm.role || "",
+        description: fm.description || ""
       });
       agentsWithSkills.push({
         slug,
@@ -502,22 +650,22 @@ async function generateAndWrite(preset, agentSlugs, skillSlugs) {
       agentsWithSkills,
       skillSlugs
     );
-    writeOrchestrator(orchestratorContent);
-    console.log(pc3.green(`  \u2713 orchestrator.md generated`));
+    writeOrchestrator(target, orchestratorContent);
+    console.log(pc3.green(`  \u2713 ${target.orchestratorFile} generated`));
   }
   for (let i = 0; i < skillSlugs.length; i++) {
     const slug = skillSlugs[i];
     const result = skillResults[i];
     if (result.status === "fulfilled") {
-      writeSkill(slug, result.value.rawContent);
+      writeSkill(target, slug, result.value.rawContent);
       console.log(pc3.green(`  \u2713 Skill: ${slug}`));
     } else {
       console.log(pc3.yellow(`  \u26A0 Skill "${slug}" skipped: ${result.reason}`));
     }
   }
-  const claudeContent = generateClaudeMd(preset, agentInfos);
-  writeClaudeMd(claudeContent);
-  console.log(pc3.green(`  \u2713 CLAUDE.md generated`));
+  const contextContent = generateContextFile(preset, agentInfos, target, skillSlugs);
+  writeContextFile(target, contextContent);
+  console.log(pc3.green(`  \u2713 ${target.contextFile} generated`));
 }
 function computeAvailableSkills(preset, selectedAgentSlugs, allAgents, allSkillSlugs) {
   const linkedToSelected = /* @__PURE__ */ new Set();
@@ -545,10 +693,37 @@ program.name("loom").description("Integrate Loom library (agents, skills, preset
 program.command("list").description("List available agents, skills, and presets").argument("[type]", "Filter by type: agents, skills, or presets").action(async (type) => {
   await listCommand(type);
 });
-program.command("add").description("Download an agent or skill from the library").argument("<type>", "Type: agent or skill").argument("<slug>", "Slug of the agent or skill").action(async (type, slug) => {
-  await addCommand(type, slug);
+program.command("add").description("Download an agent or skill from the library").argument("<type>", "Type: agent or skill").argument("<slug>", "Slug of the agent or skill").option("--target <name>", `Output target: ${[...listTargetNames(), "custom"].join(", ")}`, DEFAULT_TARGET).option("--target-dir <dir>", "Custom target directory").option("--context-file <file>", "Custom context file name").action(async (type, slug, opts) => {
+  const savedConfig = loadConfig();
+  const target = opts.target !== DEFAULT_TARGET || opts.targetDir || opts.contextFile ? resolveTarget(opts.target, opts.targetDir, opts.contextFile) : savedConfig ?? BUILTIN_TARGETS[DEFAULT_TARGET];
+  await addCommand(type, slug, target);
 });
-program.command("init").description("Initialize a project with a preset (agents + skills + CLAUDE.md)").argument("[preset]", "Preset slug (interactive if omitted)").option("--add-agent <slugs...>", "Add extra agents").option("--remove-agent <slugs...>", "Remove agents from preset").option("--add-skill <slugs...>", "Add extra skills").option("--remove-skill <slugs...>", "Remove skills from preset").action(async (preset, opts) => {
-  await initCommand(preset, opts);
+program.command("init").description("Initialize a project with a preset (agents + skills + context file)").argument("[preset]", "Preset slug (interactive if omitted)").option("--add-agent <slugs...>", "Add extra agents").option("--remove-agent <slugs...>", "Remove agents from preset").option("--add-skill <slugs...>", "Add extra skills").option("--remove-skill <slugs...>", "Remove skills from preset").option("--claude", "Use Claude Code target (.claude/ + CLAUDE.md)").option("--cursor", "Use Cursor target (.cursor/ + .cursorrules)").option("--target <name>", `Output target: ${[...listTargetNames(), "custom"].join(", ")}`).option("--target-dir <dir>", "Custom target directory").option("--context-file <file>", "Custom context file name").action(async (preset, opts) => {
+  let target;
+  let targetExplicit = false;
+  if (opts.claude) {
+    target = BUILTIN_TARGETS["claude-code"];
+    targetExplicit = true;
+  } else if (opts.cursor) {
+    target = BUILTIN_TARGETS["cursor"];
+    targetExplicit = true;
+  } else if (opts.target) {
+    target = resolveTarget(
+      opts.target,
+      opts.targetDir,
+      opts.contextFile
+    );
+    targetExplicit = true;
+  } else {
+    target = BUILTIN_TARGETS[DEFAULT_TARGET];
+  }
+  await initCommand(preset, {
+    addAgent: opts.addAgent,
+    removeAgent: opts.removeAgent,
+    addSkill: opts.addSkill,
+    removeSkill: opts.removeSkill,
+    target,
+    targetExplicit
+  });
 });
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@folpe/loom",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "CLI to scaffold Claude Code projects with curated agents, skills, and presets",
   "type": "module",
   "license": "MIT",