claudeos-core 1.5.0 → 1.6.0

package/pass-prompts/templates/node-nestjs/pass2.md

@@ -0,0 +1,97 @@
+Read all pass1-*.json files from the claudeos-core/generated/ directory and
+merge all domain analysis results into a single unified report.
+
+Merge items:
+
+1. Universal Patterns (shared by 100% of all domains)
+   - Module structure (@Module imports, providers, exports conventions)
+   - Controller style (@Controller, decorators, parameter handling)
+   - **Response flow**: Which layer wraps the response? (Controller vs Service/UseCase)
+     Record the definitive answer. If an orchestration layer exists, describe it.
+   - Service dependency injection strategy (@Injectable, custom providers)
+   - Data access patterns (ORM, Repository injection)
+   - DTO/validation rules (class-validator, class-transformer, mapped types)
+   - Error handling patterns (ExceptionFilter, HttpException hierarchy)
+   - Guard/Interceptor/Pipe execution order
+
+2. Majority Patterns (shared by 50%+ of domains)
+   - Specify which domains share them
+
+3. Domain-Specific Patterns (unique to a single domain)
+   - File upload: which domain
+   - WebSocket: which domain
+   - Queue/job processing: which domain
+   - External API integration: which domain
+   - Caching: which domain
+   - CQRS: which domain
+   - Microservices: which domain
+   - Scheduling: which domain
+
+4. Anti-pattern Summary
+   - Consolidate all inconsistencies found across domains
+   - Classify by severity (CRITICAL / HIGH / MEDIUM / LOW)
+
+5. Naming Conventions Summary
+   - File/directory naming (kebab-case, camelCase, PascalCase)
+   - File entry pattern (index.ts vs module-named files — pick ONE that the project actually uses)
+   - DTO/type naming conventions
+   - Route URL patterns
+   - Module/package structure conventions
+
+6. Common Types/Interfaces List
+   - Shared type definition files with EXACT import paths
+   - Utility functions with EXACT import paths
+   - Path aliases used in the project
+   - Custom decorators with EXACT names
+   - Environment variable types
+   - Constants/Enum management
+
+7. Security/Authentication Patterns
+   - JWT strategy (PassportModule, JwtModule)
+   - Guard hierarchy (AuthGuard, RolesGuard, custom guards)
+   - CORS configuration
+   - Rate Limiting (@nestjs/throttler)
+   - Per-environment security settings
+
+8. Database Patterns
+   - Table/collection naming conventions
+   - Migration strategy
+   - Seed data management
+   - Audit columns (createdAt, updatedAt, deletedAt)
+   - Soft delete patterns
+   - Index/constraints
+
+9. Testing Strategy Summary
+   - Test coverage level
+   - Test classification system (unit/integration/E2E)
+   - Test.createTestingModule patterns
+   - Mocking strategy (overrideProvider, jest.mock)
+   - Test naming conventions
+   - DB test strategy
+
+10. Logging/Monitoring Strategy
+    - Logger standard (NestJS Logger vs pino/winston)
+    - Log level policy
+    - Structured logging approach
+    - LoggingInterceptor patterns
+
+11. Performance Patterns
+    - Caching strategy (@CacheKey, @CacheTTL, cache-manager)
+    - Query optimization status
+    - Async processing (Bull queues, scheduling)
+    - Connection pool configuration
+
+12. Code Quality Tools
+    - Lint/Format tools (ESLint, Prettier, Biome)
+    - Pre-commit hooks (husky, lint-staged)
+    - CI integration status
+
+13. NestJS Architecture Patterns
+    - Module organization (feature modules, shared modules, global modules)
+    - Dynamic modules (forRoot/forRootAsync, forFeature)
+    - Custom providers (useFactory, useClass, useValue, useExisting)
+    - Circular dependency resolution (forwardRef)
+    - Lifecycle hooks (OnModuleInit, OnModuleDestroy, OnApplicationBootstrap)
+
+Do not generate code. Merge only.
+Save results to claudeos-core/generated/pass2-merged.json.

package/pass-prompts/templates/node-nestjs/pass3.md

@@ -0,0 +1,121 @@
+Read claudeos-core/generated/project-analysis.json and
+claudeos-core/generated/pass2-merged.json, then
+generate all ClaudeOS-Core files based on the analysis results.
+
+Do not read the original source code again. Reference only the analysis results.
+
+CRITICAL — Package Manager Consistency:
+Check `stack.packageManager` in project-analysis.json (e.g., "pnpm", "yarn", "npm").
+ALL generated files MUST use ONLY that detected package manager's commands.
+For example, if packageManager is "pnpm": use `pnpm run build`, `pnpm run dev`, `pnpm install`, etc.
+NEVER mix npm/yarn/pnpm commands. Also check `scripts` field in the project's package.json
+for actual script names (e.g., "eslint" not "lint", "typecheck" not "tsc --noEmit").
+
+CRITICAL — Cross-file Consistency:
+Rules (.claude/rules/) and Standards (claudeos-core/standard/) MUST NOT contradict each other.
+If a standard defines a specific pattern (e.g., import path, file naming, API usage),
+the corresponding rule MUST use the same pattern. Before generating each rule file,
+verify it is consistent with the related standard file.
+
+CRITICAL — Code Example Accuracy:
+ALL code examples in rules and standards MUST use EXACT method names, class names,
+and signatures from pass2-merged.json analysis data.
+Do NOT paraphrase, rename, or infer API names.
+If a method signature is not captured in the analysis data,
+write "See corresponding standard for exact API" instead of guessing.
+
+CRITICAL — Response Flow Consistency:
+Determine from pass2-merged.json which layer (Controller vs Service/UseCase) calls
+the response wrapper. This MUST be identical across architecture.md, controller-patterns.md,
+response-exception.md, and controller-rules.md. Do NOT describe different response flows in different files.
+
+CRITICAL — CLAUDE.md Reference Table Completeness:
+The reference table in CLAUDE.md MUST list ALL generated standard files, not just core.
+Include all frontend-ui, backend-api, security-db, infra, and verification standards.
+
+Generation targets:
+
+1. CLAUDE.md (project root)
+   - Role definition (NestJS backend developer)
+   - Build & Run Commands (use ONLY the detected packageManager)
+   - Core architecture diagram (Module → Controller → Service → Repository)
+   - DB table/collection naming
+   - Standard/Skills/Guide reference table
+
+2. claudeos-core/standard/ (active domains only)
+   - 00.core/01.project-overview.md — Stack, modules, API server info
+   - 00.core/02.architecture.md — NestJS module structure, DI container, request lifecycle (middleware → guard → interceptor → pipe → handler → interceptor → filter)
+   - 00.core/03.naming-conventions.md — File/variable/type/decorator naming conventions
+   - 10.backend-api/01.controller-patterns.md — @Controller, decorators, parameter binding, response handling
+   - 10.backend-api/02.service-patterns.md — @Injectable, DI, transactions, business logic
+   - 10.backend-api/03.data-access-patterns.md — ORM patterns, repository injection, query optimization
+   - 10.backend-api/04.response-exception.md — Response interceptor, HttpException hierarchy, ExceptionFilter
+   - 10.backend-api/05.validation-dto.md — class-validator, class-transformer, mapped types, ValidationPipe
+   - 10.backend-api/06.guard-interceptor-pipe.md — Guards (auth/role), Interceptors (logging/cache/transform), Pipes (validation/parse)
+   - 10.backend-api/07.module-provider-patterns.md — @Module structure, dynamic modules (forRoot/forFeature), custom providers, global modules
+   - 30.security-db/01.security-auth.md — JWT, Passport, Guards, CORS, @nestjs/throttler
+   - 30.security-db/02.database-schema.md — Migrations, seeds, schema conventions
+   - 30.security-db/03.common-utilities.md — Custom decorators, shared providers, constants
+   - 40.infra/01.environment-config.md — @nestjs/config, ConfigModule, environment validation
+   - 40.infra/02.logging-monitoring.md — NestJS Logger/pino, LoggingInterceptor, health checks
+   - 40.infra/03.cicd-deployment.md — CI/CD pipeline, deployment strategy
+   - 50.verification/01.development-verification.md — Build, startup, API testing
+   - 50.verification/02.testing-strategy.md — Test.createTestingModule, mocking, E2E
+
+   Each file MUST include:
+   - Correct examples (✅ code blocks)
+   - Incorrect examples (❌ code blocks)
+   - Key rules summary table
+
+3. .claude/rules/ (active domains only)
+   - Write the full rule content directly in each file (self-contained, no external references)
+   - Include 5-15 lines of key rules with concrete examples
+   - Do NOT use @import — it is not a Claude Code feature and does not work
+   - Each rule file MUST end with a `## Reference` section linking to the corresponding standard file(s):
+     ```
+     ## Reference
+     > For detailed patterns and examples, Read: claudeos-core/standard/10.backend-api/01.controller-patterns.md
+     ```
+   - `paths:` frontmatter per rule category:
+     - `00.core/*` rules: `paths: ["**/*"]`
+     - `10.backend/*` rules: `paths: ["**/*"]`
+     - `30.security-db/*` rules: `paths: ["**/*"]`
+     - `40.infra/*` rules: `paths: ["**/*.json", "**/*.env*", "**/config/**", "**/Dockerfile*", "**/*.yml", "**/*.yaml"]`
+     - `50.sync/*` rules: `paths: ["**/claudeos-core/**", "**/.claude/**"]`
+   - MUST generate `.claude/rules/00.core/00.standard-reference.md` — directory of all standard files.
+     List only the standard files that were actually generated above.
+
+4. .claude/rules/50.sync/ (3 sync rules)
+   - 01.standard-sync.md — Remind AI to update plan/10 when standard is modified
+   - 02.rules-sync.md — Remind AI to update plan/20 when rules is modified
+   - 03.skills-sync.md — Remind AI to update plan/30 when skills is modified
+
+5. claudeos-core/skills/ (active domains only)
+   - 10.backend-crud/01.scaffold-crud-feature.md (orchestrator)
+   - 10.backend-crud/scaffold-crud-feature/01~08 (sub-skills: module, controller, service, repository, dto, migration, test, index)
+   - 00.shared/MANIFEST.md (skill registry)
+
+6. claudeos-core/guide/ (all)
+   - 01.onboarding/01.overview.md
+   - 01.onboarding/02.quickstart.md
+   - 01.onboarding/03.glossary.md
+   - 02.usage/01.faq.md
+   - 02.usage/02.real-world-examples.md
+   - 02.usage/03.do-and-dont.md
+   - 03.troubleshooting/01.troubleshooting.md
+   - 04.architecture/01.file-map.md
+   - 04.architecture/02.pros-and-cons.md
+
+7. claudeos-core/plan/ (Master Plan)
+   - 10.standard-master.md — CLAUDE.md + all standard/ files as <file> blocks
+   - 20.rules-master.md — All rules/ (except sync) as <file> blocks
+   - 21.sync-rules-master.md — All sync rules (code block format)
+   - 30.backend-skills-master.md — All backend skills as <file> blocks
+   - 40.guides-master.md — All guide/ files as <file> blocks
+
+8. claudeos-core/database/
+   - 01.schema-overview.md — Table/collection list, relationship description
+   - 02.migration-guide.md — Migration procedure, rollback methods
+
+9. claudeos-core/mcp-guide/
+   - 01.mcp-overview.md — List of MCP servers in use, integration methods

package/pass-prompts/templates/vue-nuxt/pass1.md

@@ -0,0 +1,119 @@
+Read claudeos-core/generated/project-analysis.json and
+perform a deep analysis of the following domains only: {{DOMAIN_GROUP}}
+
+For each domain, select one representative file per layer, read its code, and analyze it.
+Prioritize files with the richest patterns.
+
+Analysis items (per domain):
+
+1. Page/Routing Patterns
+   - Routing approach (Nuxt file-based routing vs Vue Router manual config)
+   - Layout structure (layouts/, default.vue, custom layouts)
+   - Dynamic routes ([id].vue, [...slug].vue)
+   - Page directory conventions (pages/ structure)
+   - Middleware usage (defineNuxtRouteMiddleware, navigation guards)
+   - Route meta and page meta (definePageMeta)
+   - Loading/error handling (error.vue, NuxtErrorBoundary)
+
+2. Component Patterns
+   - Component structure (SFC <script setup>, Options API, Composition API)
+   - Props definition (defineProps, withDefaults, runtime vs type-only)
+   - Emits definition (defineEmits)
+   - Slots usage (named slots, scoped slots)
+   - Styling approach (<style scoped>, CSS Modules, Tailwind, UnoCSS)
+   - UI library (Vuetify, PrimeVue, Radix Vue, Naive UI, Element Plus)
+   - Component classification (UI, Feature, Layout, Page)
+   - Component entry file pattern: index.vue vs ComponentName.vue
+   - Directory structure pattern: record exact convention
+   - Auto-imports (Nuxt auto-import, unplugin-auto-import)
+   - Reuse patterns (composables, provide/inject, renderless components)
+   - Accessibility (ARIA, semantic HTML, keyboard navigation)
+
+3. Data Fetching Patterns
+   - Nuxt: useFetch, useAsyncData, $fetch, server routes (server/api/)
+   - Vue: Axios, fetch, TanStack Query/Vue Query
+   - SSR data fetching (Nuxt server-side, useRequestHeaders)
+   - Client-side data fetching (onMounted, watch)
+   - Caching strategy (Nuxt payload, SWR, stale-while-revalidate)
+   - Error/loading state handling (pending, error, refresh)
+   - Streaming/Suspense
+
+4. State Management Patterns
+   - Pinia stores (defineStore, setup stores vs option stores)
+   - Composables for shared state (useState in Nuxt)
+   - URL state (useRoute, useRouter, query params)
+   - Form state (VeeValidate, FormKit, vuelidate)
+   - Provide/Inject patterns
+
+5. Configuration/Environment Patterns
+   - Environment variable management (NUXT_PUBLIC_, VITE_, .env separation)
+   - nuxt.config.ts / vite.config.ts settings
+   - Runtime config (useRuntimeConfig)
+   - Build optimization (Nitro presets, SSR/SSG/SPA modes)
+   - Module system (Nuxt modules, Vite plugins)
+
+6. Logging/Monitoring Patterns
+   - Client error tracking (Sentry, DataDog RUM)
+   - Server logging (consola, pino, h3 logger)
+   - Performance monitoring (Web Vitals, Lighthouse)
+   - Analytics tools (Google Analytics, PostHog, Plausible)
+
+7. Testing Patterns
+   - Test framework (Vitest, Jest, Playwright, Cypress)
+   - Component testing (@vue/test-utils, @testing-library/vue)
+   - E2E testing strategy
+   - Mocking strategy (MSW, vi.mock)
+   - Test naming conventions
+   - Nuxt testing (@nuxt/test-utils)
+
+8. Domain-Specific Patterns
+   - Authentication (Nuxt Auth, @sidebase/nuxt-auth, custom)
+   - Internationalization (@nuxtjs/i18n, vue-i18n)
+   - File upload (presigned URL, client direct upload)
+   - Real-time features (WebSocket, SSE, Socket.io)
+   - SEO optimization (useSeoMeta, useHead, OG tags)
+   - Image optimization (nuxt/image, @nuxt/image)
+   - API versioning strategy
+
+9. Anti-patterns / Inconsistencies
+   - Mixing Options API and Composition API
+   - Unnecessary reactivity (ref vs reactive misuse)
+   - Patterns inconsistent with other domains
+   - Performance issues (unnecessary watchers, large bundle, layout shift)
+   - Type safety issues
+   - Accessibility issues
+
+Do not create or modify source files. Analysis only.
+Save results to claudeos-core/generated/pass1-{{PASS_NUM}}.json in the following format:
+
+{
+  "analyzedAt": "ISO timestamp",
+  "passNum": {{PASS_NUM}},
+  "domains": ["auth", "dashboard", "settings", "shared"],
+  "analysisPerDomain": {
+    "dashboard": {
+      "representativeFiles": {
+        "page": "pages/dashboard/index.vue",
+        "layout": "layouts/dashboard.vue",
+        "component": "components/dashboard/StatsCard.vue",
+        "composable": "composables/useDashboard.ts",
+        "store": "stores/dashboard.ts"
+      },
+      "patterns": {
+        "page": { ... },
+        "component": { ... },
+        "dataFetching": { ... },
+        "stateManagement": { ... },
+        "config": { ... },
+        "logging": { ... },
+        "testing": { ... }
+      },
+      "specialPatterns": [],
+      "antiPatterns": []
+    }
+  },
+  "crossDomainCommon": {
+    "description": "Patterns commonly used across domains in this group",
+    "patterns": []
+  }
+}

package/pass-prompts/templates/vue-nuxt/pass2.md

@@ -0,0 +1,83 @@
+Read all pass1-*.json files from the claudeos-core/generated/ directory and
+merge all domain analysis results into a single unified report.
+
+Merge items:
+
+1. Universal Patterns (shared by 100% of all domains)
+   - Page/routing structure (Nuxt file-based vs Vue Router)
+   - Component writing conventions (SFC, <script setup>, Props/Emits)
+   - Data fetching strategy (useFetch/useAsyncData vs client-side)
+   - State management approach (Pinia, composables)
+   - Error/loading handling patterns
+   - Middleware usage
+
+2. Majority Patterns (shared by 50%+ of domains)
+   - Specify which domains share them
+
+3. Domain-Specific Patterns (unique to a single domain)
+   - Auth: which domain
+   - Real-time features: which domain
+   - File upload: which domain
+   - i18n: which domain
+   - SEO optimization: which domain
+
+4. Anti-pattern Summary
+   - Consolidate all inconsistencies found across domains
+   - Classify by severity (CRITICAL / HIGH / MEDIUM / LOW)
+
+5. Naming Conventions Summary
+   - File/directory naming (kebab-case, PascalCase)
+   - Component file pattern (index.vue vs ComponentName.vue)
+   - Composable naming (use* prefix)
+   - Store naming conventions
+   - Route/page naming patterns
+
+6. Shared Types/Components List
+   - Common UI components with EXACT import paths
+   - Shared composables with exact import paths
+   - Utility functions with EXACT import paths
+   - Auto-import configuration (which composables/components are auto-imported)
+   - Path aliases used in the project
+   - Environment variable types
+   - Constants/Enum management
+
+7. Security/Authentication Patterns
+   - Authentication approach (Nuxt Auth, custom middleware)
+   - Route protection strategy (middleware, navigation guards)
+   - CSRF/XSS prevention
+   - Environment variable management (NUXT_PUBLIC_, VITE_)
+   - Content security policy
+
+8. Performance Patterns
+   - SSR/SSG/SPA mode usage
+   - Image optimization (nuxt/image)
+   - Bundle optimization (dynamic import, tree shaking)
+   - Caching strategy (Nitro cache, CDN)
+   - Web Vitals status
+
+9. Testing Strategy Summary
+   - Test coverage level
+   - Test classification system (unit/component/E2E)
+   - Mocking strategy (MSW, vi.mock)
+   - Test naming conventions
+
+10. Logging/Monitoring Strategy
+    - Error tracking approach (Sentry, DataDog)
+    - Analytics tools
+    - Web Vitals monitoring
+
+11. Code Quality Tools
+    - Lint/Format tools (ESLint, Prettier, Biome)
+    - Pre-commit hooks (husky, lint-staged)
+    - TypeScript strict mode
+    - CI integration status
+
+12. Vue/Nuxt Architecture Patterns
+    - Nuxt module usage (list of @nuxt/* and third-party modules)
+    - Nitro server configuration (server routes, middleware, plugins)
+    - Plugin system (Nuxt plugins, Vue plugins)
+    - Composable organization (shared vs domain-specific)
+    - Auto-import scope and configuration
+
+Do not generate code. Merge only.
+Save results to claudeos-core/generated/pass2-merged.json.

package/pass-prompts/templates/vue-nuxt/pass3.md

@@ -0,0 +1,100 @@
+Read claudeos-core/generated/project-analysis.json and
+claudeos-core/generated/pass2-merged.json, then
+generate all ClaudeOS-Core files based on the analysis results.
+
+Do not read the original source code again. Reference only the analysis results.
+
+CRITICAL — Package Manager Consistency:
+Check `stack.packageManager` in project-analysis.json (e.g., "pnpm", "yarn", "npm").
+ALL generated files MUST use ONLY that detected package manager's commands.
+NEVER mix npm/yarn/pnpm commands. Also check `scripts` field in the project's package.json
+for actual script names.
+
+CRITICAL — Cross-file Consistency:
+Rules (.claude/rules/) and Standards (claudeos-core/standard/) MUST NOT contradict each other.
+
+CRITICAL — Code Example Accuracy:
+ALL code examples MUST use EXACT method names, class names, and signatures from pass2-merged.json.
+Do NOT paraphrase, rename, or infer API names.
+
+CRITICAL — CLAUDE.md Reference Table Completeness:
+The reference table in CLAUDE.md MUST list ALL generated standard files.
+
+Generation targets:
+
+1. CLAUDE.md (project root)
+   - Role definition (Vue/Nuxt frontend developer)
+   - Build & Run Commands (use ONLY the detected packageManager)
+   - Core architecture diagram
+   - Directory structure description
+   - Standard/Skills/Guide reference table
+
+2. claudeos-core/standard/ (active domains only)
+   - 00.core/01.project-overview.md — Stack, routing approach, deployment environment
+   - 00.core/02.architecture.md — Nuxt/Vue structure, component hierarchy, data flow, Nitro server
+   - 00.core/03.naming-conventions.md — File/component/composable/store naming conventions
+   - 20.frontend-ui/01.component-patterns.md — SFC, <script setup>, Props/Emits, slots, provide/inject
+   - 20.frontend-ui/02.page-routing-patterns.md — Pages/layouts/dynamic routes/middleware/definePageMeta
+   - 20.frontend-ui/03.data-fetching.md — useFetch, useAsyncData, $fetch, server routes, caching
+   - 20.frontend-ui/04.state-management.md — Pinia stores, composables, useState, form state
+   - 20.frontend-ui/05.styling-patterns.md — Scoped styles, CSS Modules, Tailwind/UnoCSS, theming
+   - 10.backend-api/01.server-routes.md — Nitro server routes (server/api/), H3 event handlers
+   - 30.security-db/01.security-auth.md — Auth, middleware protection, environment variables
+   - 40.infra/01.environment-config.md — Runtime config, nuxt.config.ts, Nitro presets
+   - 40.infra/02.logging-monitoring.md — Error tracking, analytics, Web Vitals
+   - 40.infra/03.cicd-deployment.md — CI/CD, deployment (Vercel/Netlify/Docker), preview
+   - 50.verification/01.development-verification.md — Build, startup, Lighthouse
+   - 50.verification/02.testing-strategy.md — Vitest, @vue/test-utils, E2E, @nuxt/test-utils
+
+   Each file MUST include:
+   - Correct examples (✅ code blocks)
+   - Incorrect examples (❌ code blocks)
+   - Key rules summary table
+
+3. .claude/rules/ (active domains only)
+   - Write the full rule content directly in each file (self-contained)
+   - Include 5-15 lines of key rules with concrete examples
+   - Do NOT use @import
+   - Each rule file MUST end with a `## Reference` section
+   - `paths:` frontmatter per rule category:
+     - `00.core/*` rules: `paths: ["**/*"]`
+     - `10.backend/*` rules: `paths: ["**/*"]`
+     - `20.frontend/*` rules: `paths: ["**/*"]`
+     - `30.security-db/*` rules: `paths: ["**/*"]`
+     - `40.infra/*` rules: `paths: ["**/*.json", "**/*.env*", "**/nuxt.config.*", "**/vite.config.*", "**/Dockerfile*", "**/*.yml", "**/*.yaml"]`
+     - `50.sync/*` rules: `paths: ["**/claudeos-core/**", "**/.claude/**"]`
+   - MUST generate `.claude/rules/00.core/00.standard-reference.md` — directory of all standard files
+
+4. .claude/rules/50.sync/ (3 sync rules)
+   - 01.standard-sync.md
+   - 02.rules-sync.md
+   - 03.skills-sync.md
+
+5. claudeos-core/skills/ (active domains only)
+   - 20.frontend-page/01.scaffold-page-feature.md (orchestrator)
+   - 20.frontend-page/scaffold-page-feature/01~08 (sub-skills: page, layout, component, composable, server-route, test, style, index)
+   - 00.shared/MANIFEST.md (skill registry)
+
+6. claudeos-core/guide/ (all)
+   - 01.onboarding/01.overview.md
+   - 01.onboarding/02.quickstart.md
+   - 01.onboarding/03.glossary.md
+   - 02.usage/01.faq.md
+   - 02.usage/02.real-world-examples.md
+   - 02.usage/03.do-and-dont.md
+   - 03.troubleshooting/01.troubleshooting.md
+   - 04.architecture/01.file-map.md
+   - 04.architecture/02.pros-and-cons.md
+
+7. claudeos-core/plan/ (Master Plan)
+   - 10.standard-master.md — CLAUDE.md + all standard/ files as <file> blocks
+   - 20.rules-master.md — All rules/ (except sync) as <file> blocks
+   - 21.sync-rules-master.md — All sync rules (code block format)
+   - 30.frontend-skills-master.md — All frontend skills as <file> blocks
+   - 40.guides-master.md — All guide/ files as <file> blocks
+
+8. claudeos-core/database/
+   - 01.schema-overview.md — DB schema description (if applicable)
+
+9. claudeos-core/mcp-guide/
+   - 01.mcp-overview.md — List of MCP servers in use, integration methods

package/plan-installer/domain-grouper.js

@@ -50,7 +50,8 @@ function selectTemplates(stack) {
   // Backend template (requires a backend framework; language-only fallback skipped for pure frontend projects)
   if (stack.language === "kotlin") templates.backend = "kotlin-spring";
   else if (stack.language === "java") templates.backend = "java-spring";
-  else if (stack.framework === "express" || stack.framework === "nestjs") templates.backend = "node-express";
+  else if (stack.framework === "nestjs") templates.backend = "node-nestjs";
+  else if (stack.framework === "express") templates.backend = "node-express";
   else if (stack.framework === "fastify") templates.backend = "node-fastify";
   else if (stack.framework === "django") templates.backend = "python-django";
   else if (stack.framework === "fastapi" || stack.framework === "flask") templates.backend = "python-fastapi";
@@ -58,8 +59,10 @@ function selectTemplates(stack) {
   else if (stack.language === "python" && stack.framework) templates.backend = "python-fastapi";
 
   // Frontend template
-  if (stack.frontend === "nextjs" || stack.frontend === "react" || stack.frontend === "vue") {
+  if (stack.frontend === "nextjs" || stack.frontend === "react") {
     templates.frontend = "node-nextjs";
+  } else if (stack.frontend === "vue") {
+    templates.frontend = "vue-nuxt";
   } else if (stack.frontend === "angular") {
     templates.frontend = "angular";
   }

package/plan-installer/prompt-generator.js

@@ -36,10 +36,7 @@ function generatePrompts(templates, lang, templatesDir, generatedDir) {
   function readTemplate(templateName, passName) {
     const src = path.join(templatesDir, templateName, `${passName}.md`);
     if (!existsSafe(src)) return null;
-    let body = readFileSafe(src);
-    body = body.replace(/^Project root path:.*\nInterpret all file paths.*\n\n?---\n\n?/s, "");
-    body = body.replace(/\nAfter completion, run the following commands in order:[\s\S]*$/, "");
-    return body;
+    return readFileSafe(src);
   }
 
   const activeTemplates = [templates.backend, templates.frontend].filter(Boolean);

package/plan-installer/scanners/scan-frontend.js

@@ -15,8 +15,11 @@ async function scanFrontendDomains(stack, ROOT) {
 
   // ── Angular ──
   if (stack.frontend === "angular") {
-    // Angular feature modules: src/app/*/ with *.component.ts or *.module.ts
-    const angularAppDirs = await glob("{src/app,app}/*/", { cwd: ROOT });
+    // Angular feature modules: src/app/*/ with *.component.ts or *.module.ts (+ monorepo apps/*/)
+    const angularAppDirs = [
+      ...await glob("{src/app,app}/*/", { cwd: ROOT }),
+      ...await glob("{apps,packages}/*/src/app/*/", { cwd: ROOT, ignore: ["**/node_modules/**"] }),
+    ];
     const skipAngularDirs = ["shared", "core", "common", "layout", "layouts", "environments", "assets", "styles", "testing", "utils"];
     for (const dir of angularAppDirs) {
       const name = path.basename(dir.replace(/\/$/, ""));
@@ -51,16 +54,20 @@ async function scanFrontendDomains(stack, ROOT) {
 
   // ── Next.js/React/Vue ──
   if (stack.frontend === "nextjs" || stack.frontend === "react" || stack.frontend === "vue") {
-    // App Router / Pages Router domains
+    // App Router / Pages Router domains (standard + monorepo apps/*/)
     const allDirs = [
       ...await glob("{app,src/app}/*/", { cwd: ROOT }),
       ...await glob("{pages,src/pages}/*/", { cwd: ROOT }),
+      ...await glob("{apps,packages}/*/app/*/", { cwd: ROOT, ignore: ["**/node_modules/**"] }),
+      ...await glob("{apps,packages}/*/src/app/*/", { cwd: ROOT, ignore: ["**/node_modules/**"] }),
+      ...await glob("{apps,packages}/*/pages/*/", { cwd: ROOT, ignore: ["**/node_modules/**"] }),
+      ...await glob("{apps,packages}/*/src/pages/*/", { cwd: ROOT, ignore: ["**/node_modules/**"] }),
     ];
-    const skipPages = ["api", "_app", "_document", "fonts"];
+    const skipPages = ["api", "_app", "_document", "fonts", "not-found", "error", "loading"];
     for (const dir of allDirs) {
       const name = path.basename(dir);
       if (skipPages.includes(name) || name.startsWith("(") || name.startsWith("[") || name.startsWith("_") || name.startsWith(".")) continue;
-      const files = await glob(`${dir}**/*.{tsx,jsx,ts,js,vue}`, { cwd: ROOT });
+      const files = await glob(`${dir.replace(/\\/g, "/")}**/*.{tsx,jsx,ts,js,vue}`, { cwd: ROOT });
       if (files.length > 0) {
         const pages = files.filter(f => /page\.|index\./.test(f)).length;
         const layouts = files.filter(f => /layout\./.test(f)).length;
@@ -81,7 +88,7 @@ async function scanFrontendDomains(stack, ROOT) {
       for (const dir of fsdDirs) {
         const name = path.basename(dir);
         if (["ui", "common", "shared", "lib", "config", "index"].includes(name)) continue;
-        const files = await glob(`${dir}**/*.{tsx,jsx,ts,js,vue}`, { cwd: ROOT, ignore: ["**/*.spec.*", "**/*.test.*", "**/*.stories.*"] });
+        const files = await glob(`${dir.replace(/\\/g, "/")}**/*.{tsx,jsx,ts,js,vue}`, { cwd: ROOT, ignore: ["**/*.spec.*", "**/*.test.*", "**/*.stories.*"] });
         if (files.length > 0) {
           const uiFiles = files.filter(f => /\bui\b/.test(f)).length;
           const modelFiles = files.filter(f => /model|store|hook/.test(f)).length;
@@ -95,7 +102,7 @@ async function scanFrontendDomains(stack, ROOT) {
     for (const dir of compDirs) {
       const name = path.basename(dir);
       if (["ui", "common", "shared", "layout", "icons"].includes(name)) continue;
-      const files = await glob(`${dir}**/*.{tsx,jsx,vue}`, { cwd: ROOT });
+      const files = await glob(`${dir.replace(/\\/g, "/")}**/*.{tsx,jsx,vue}`, { cwd: ROOT });
       if (files.length >= 2) {
         frontendDomains.push({ name: `comp-${name}`, type: "frontend", components: files.length, totalFiles: files.length });
       }