claudeos-core 2.3.2 → 2.4.0

package/package.json

@@ -1,90 +1,92 @@
-{
-  "name": "claudeos-core",
-  "version": "2.3.2",
-  "description": "Auto-generate Claude Code documentation from your actual source code — Standards, Rules, Skills, and Guides tailored to your project",
-  "main": "bin/cli.js",
-  "bin": {
-    "claudeos-core": "bin/cli.js"
-  },
-  "files": [
-    "bin/",
-    "lib/",
-    "claude-md-validator/",
-    "content-validator/",
-    "health-checker/",
-    "manifest-generator/",
-    "pass-json-validator/",
-    "pass-prompts/",
-    "plan-installer/",
-    "plan-validator/",
-    "sync-checker/",
-    "bootstrap.sh",
-    "README.md",
-    "README.ko.md",
-    "LICENSE",
-    "CHANGELOG.md",
-    "CONTRIBUTING.md",
-    "README.zh-CN.md",
-    "README.ja.md",
-    "README.es.md",
-    "README.vi.md",
-    "README.hi.md",
-    "README.ru.md",
-    "README.fr.md",
-    "README.de.md"
-  ],
-  "scripts": {
-    "init": "node bin/cli.js init",
-    "lint": "node bin/cli.js lint",
-    "health": "node bin/cli.js health",
-    "validate": "node bin/cli.js validate",
-    "refresh": "node bin/cli.js refresh",
-    "restore": "node bin/cli.js restore",
-    "pretest": "node -e \"try{require('glob')}catch(e){process.exit(1)}\" || npm install",
-    "test": "node scripts/run-tests.js",
-    "test:health": "node health-checker/index.js"
-  },
-  "keywords": [
-    "claude-code",
-    "automation",
-    "code-analysis",
-    "CLAUDE.md",
-    "standards",
-    "rules",
-    "skills",
-    "scaffolding",
-    "i18n",
-    "multi-language",
-    "spring-boot",
-    "kotlin",
-    "exposed",
-    "jooq",
-    "cqrs",
-    "bff",
-    "multi-module",
-    "monorepo",
-    "nextjs",
-    "express",
-    "fastify",
-    "angular",
-    "django",
-    "fastapi"
-  ],
-  "author": "claudeos-core <claudeoscore@gmail.com> (https://github.com/claudeos-core)",
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/claudeos-core/claudeos-core.git"
-  },
-  "homepage": "https://github.com/claudeos-core/claudeos-core#readme",
-  "bugs": {
-    "url": "https://github.com/claudeos-core/claudeos-core/issues"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "glob": "^13.0.6",
-    "gray-matter": "^4.0.3"
-  }
-}
+{
+  "name": "claudeos-core",
+  "version": "2.4.0",
+  "description": "Auto-generate Claude Code documentation from your actual source code — Standards, Rules, Skills, and Guides tailored to your project",
+  "main": "bin/cli.js",
+  "bin": {
+    "claudeos-core": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "claude-md-validator/",
+    "content-validator/",
+    "health-checker/",
+    "manifest-generator/",
+    "pass-json-validator/",
+    "pass-prompts/",
+    "plan-installer/",
+    "plan-validator/",
+    "sync-checker/",
+    "bootstrap.sh",
+    "README.md",
+    "README.ko.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "CODE_OF_CONDUCT.md",
+    "SECURITY.md",
+    "README.zh-CN.md",
+    "README.ja.md",
+    "README.es.md",
+    "README.vi.md",
+    "README.hi.md",
+    "README.ru.md",
+    "README.fr.md",
+    "README.de.md"
+  ],
+  "scripts": {
+    "init": "node bin/cli.js init",
+    "lint": "node bin/cli.js lint",
+    "health": "node bin/cli.js health",
+    "validate": "node bin/cli.js validate",
+    "refresh": "node bin/cli.js refresh",
+    "restore": "node bin/cli.js restore",
+    "pretest": "node -e \"try{require('glob')}catch(e){process.exit(1)}\" || npm install",
+    "test": "node scripts/run-tests.js",
+    "test:health": "node health-checker/index.js"
+  },
+  "keywords": [
+    "claude-code",
+    "automation",
+    "code-analysis",
+    "CLAUDE.md",
+    "standards",
+    "rules",
+    "skills",
+    "scaffolding",
+    "i18n",
+    "multi-language",
+    "spring-boot",
+    "kotlin",
+    "exposed",
+    "jooq",
+    "cqrs",
+    "bff",
+    "multi-module",
+    "monorepo",
+    "nextjs",
+    "express",
+    "fastify",
+    "angular",
+    "django",
+    "fastapi"
+  ],
+  "author": "claudeos-core <claudeoscore@gmail.com> (https://github.com/claudeos-core)",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/claudeos-core/claudeos-core.git"
+  },
+  "homepage": "https://github.com/claudeos-core/claudeos-core#readme",
+  "bugs": {
+    "url": "https://github.com/claudeos-core/claudeos-core/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "glob": "^13.0.6",
+    "gray-matter": "^4.0.3"
+  }
+}

package/pass-json-validator/index.js

@@ -70,10 +70,17 @@ async function main() {
 
   // ─── 1. project-analysis.json ──────────────────────────
   console.log("  [1/5] project-analysis.json...");
+  // v2.4.0 — `template` (singular, legacy single-stack form) removed from
+  // recommended-keys list. `templates` (plural object {backend, frontend})
+  // is the canonical form since multi-stack support landed; the consumer
+  // at line ~88 already does `pa.templates || pa.template` fallback for
+  // back-compat. Listing `template` as recommended caused a false-positive
+  // MISSING_KEY WARNING on every healthy multi-stack-aware project where
+  // only `templates` exists.
   const pa = validateJson(
     path.join(GEN_DIR, "project-analysis.json"),
     ["analyzedAt", "stack", "domains", "frontend", "summary"],
-    ["lang", "template", "templates", "rootPackage", "activeDomains"]
+    ["lang", "templates", "rootPackage", "activeDomains"]
   );
   if (pa) {
     if (!pa.stack || !pa.stack.language) {
@@ -167,6 +174,32 @@ async function main() {
         "codeQuality",         // 12. Code quality tools
       ];
 
+      // v2.4.0 — Semantic alias map for sections.
+      //
+      // Pass 2 LLM frequently emits section keys with numeric prefixes
+      // ("1_universalPatterns") or alternate vocabulary ("majorityPatterns"
+      // instead of "sharedPatterns"). The fuzzy normalizer can't catch
+      // these because the stems don't overlap. This alias map adds known
+      // semantic equivalents so the existence check matches when ANY of
+      // the canonical name OR its aliases is present.
+      //
+      // Each entry: canonical name → [...alternate keys (case/separator
+      // insensitive — normalized identically to keys at check time)].
+      const SECTION_ALIASES = {
+        commonPatterns:    ["universalPatterns", "1_universalPatterns", "1universalPatterns", "patterns_universal"],
+        sharedPatterns:    ["majorityPatterns", "2_majorityPatterns", "2majorityPatterns", "patterns_majority"],
+        domainSpecific:    ["domainSpecificPatterns", "3_domainSpecific", "perDomain", "domains"],
+        antiPatterns:      ["antipatternSummary", "4_antiPatterns", "5_antiPatternSummary", "antiPatternSummary"],
+        namingConventions: ["naming", "5_namingConventions", "6_namingConventions"],
+        commonUtilities:   ["sharedUtilities", "utilities", "6_commonUtilities", "7_commonUtilities"],
+        security:          ["securityPatterns", "auth", "authentication", "7_security", "8_security"],
+        testing:           ["testStrategy", "testingStrategy", "9_testing", "10_testing"],
+        logging:           ["loggingStrategy", "monitoring", "loggingMonitoring", "10_logging", "11_logging"],
+        codeQuality:       ["quality", "codeQualityTools", "12_codeQuality", "13_codeQuality"],
+        database:          ["dbPatterns", "8_database"],
+        performance:       ["perfPatterns", "11_performance"],
+      };
+
       // Sections only in backend stacks (java/node-express/django/fastapi/kotlin)
       const BACKEND_SECTIONS = [
         "database",            // 8. DB patterns
@@ -208,15 +241,19 @@ async function main() {
         ...(isKotlinCqrs ? KOTLIN_CQRS_SECTIONS : []),
       ];
 
-      // Key existence validation (case-insensitive fuzzy matching)
+      // Key existence validation (case-insensitive fuzzy matching + alias map)
       // Normalize a key to a comparable form: lowercase, strip separators
-      const normalize = (s) => s.toLowerCase().replace(/[_\-\s]/g, "");
+      const normalize = (s) => s.toLowerCase().replace(/[_\-\s\.]/g, "");
       const normalizedKeys = keys.map(normalize);
       for (const section of sectionsToCheck) {
         const sectionNorm = normalize(section);
-        // Exact normalized match first, then check if any key contains the section name (one-direction only to avoid false positives)
+        // (1) Exact normalized match
+        // (2) Substring match on canonical (one-direction, length >= 6 to avoid false positives)
+        // (3) v2.4.0 — Alias map: any aliased name (normalized) matches a key (normalized)
+        const aliases = (SECTION_ALIASES[section] || []).map(normalize);
         const found = normalizedKeys.some(k => k === sectionNorm)
-          || (sectionNorm.length >= 6 && normalizedKeys.some(k => k.includes(sectionNorm)));
+          || (sectionNorm.length >= 6 && normalizedKeys.some(k => k.includes(sectionNorm)))
+          || aliases.some(a => normalizedKeys.some(k => k === a || (a.length >= 6 && k.includes(a))));
         if (!found) {
           warnings.push({
             file: "pass2-merged.json",
@@ -270,7 +307,13 @@ async function main() {
   console.log("  [5a/5] pass3-complete.json (optional)...");
   const p3path = path.join(GEN_DIR, "pass3-complete.json");
   if (fs.existsSync(p3path)) {
-    const p3 = validateJson(p3path, ["completedAt"], ["backfilled", "reason"]);
+    // v2.4.0 — `backfilled` and `reason` removed from recommended-keys list.
+    // Both are scenario-specific: `backfilled: true` is set only when init.js
+    // backfilled the marker for a pre-v1.7 CLAUDE.md (rare upgrade path),
+    // and `reason` documents that backfill source. Normal Claude-driven
+    // Pass 3 completion never has either — listing them as "recommended"
+    // produced a false-positive MISSING_KEY WARNING on every healthy run.
+    const p3 = validateJson(p3path, ["completedAt"], []);
     if (p3) {
       if (typeof p3.completedAt !== "string" || !/^\d{4}-\d{2}-\d{2}T/.test(p3.completedAt)) {
         warnings.push({ file: "pass3-complete.json", type: "INVALID_TIMESTAMP", msg: `completedAt should be ISO 8601 (got ${JSON.stringify(p3.completedAt)})` });
@@ -286,9 +329,17 @@ async function main() {
   console.log("  [5b/5] pass4-memory.json (optional)...");
   const p4path = path.join(GEN_DIR, "pass4-memory.json");
   if (fs.existsSync(p4path)) {
+    // v2.4.0 — `planFiles` removed from optional list because master plan
+    // generation was removed in v2.1.0. Pass 4 normal completion never has
+    // it, so the recommendation produced a false-positive WARNING on every
+    // healthy run. Same for `fallback` (only set when Claude-driven Pass 4
+    // failed and static fallback ran) — its absence is the SUCCESS path.
+    // `seededDecisions` (only when initial decision-log is seeded) and
+    // `ruleFiles` (only when Pass 4 emits rules outside scaffold) are also
+    // scenario-specific; demoted from "recommended" to "purely optional".
     const p4 = validateJson(p4path,
       ["analyzedAt", "passNum", "memoryFiles"],
-      ["planFiles", "ruleFiles", "seededDecisions", "fallback"]
+      [] // No recommended optional keys; all scenario-specific (see comment above)
     );
     if (p4) {
       if (typeof p4.passNum !== "number" || p4.passNum !== 4) {

package/pass-prompts/templates/angular/pass3.md

@@ -47,26 +47,26 @@ Generation targets:
    - 00.core/01.project-overview.md — Stack (Angular version, TypeScript version), project structure
    - 00.core/02.architecture.md — Module hierarchy, DI tree, data flow, lazy loading map
    - 00.core/03.naming-conventions.md — File/class/selector/module naming conventions
-   - 20.frontend-ui/01.component-patterns.md — Component structure, lifecycle, OnPush, Signals, I/O
-   - 20.frontend-ui/02.routing-patterns.md — Route config, lazy loading, guards, resolvers
-   - 20.frontend-ui/03.service-di-patterns.md — Injectable, providers, injection tokens, inject()
-   - 20.frontend-ui/04.rxjs-patterns.md — Observable management, operators, subscription cleanup
-   - 20.frontend-ui/05.template-patterns.md — Directives, content projection, control flow (@if/@for)
-   - 20.frontend-ui/06.form-patterns.md — Reactive/Template forms, validators, error handling
-   - 20.frontend-ui/07.state-management.md — NgRx/NGXS/Signal Store patterns
-   - 20.frontend-ui/08.http-patterns.md — HttpClient, interceptors, caching, error handling
-   - 20.frontend-ui/09.styling-patterns.md — ViewEncapsulation, theming, responsive
-   - 10.backend-api/01.api-integration.md — API service abstraction, interceptors (if backend exists)
+   - 20.frontend/01.component-patterns.md — Component structure, lifecycle, OnPush, Signals, I/O
+   - 20.frontend/02.routing-patterns.md — Route config, lazy loading, guards, resolvers
+   - 20.frontend/03.service-di-patterns.md — Injectable, providers, injection tokens, inject()
+   - 20.frontend/04.rxjs-patterns.md — Observable management, operators, subscription cleanup
+   - 20.frontend/05.template-patterns.md — Directives, content projection, control flow (@if/@for)
+   - 20.frontend/06.form-patterns.md — Reactive/Template forms, validators, error handling
+   - 20.frontend/07.state-management.md — NgRx/NGXS/Signal Store patterns
+   - 20.frontend/08.http-patterns.md — HttpClient, interceptors, caching, error handling
+   - 20.frontend/09.styling-patterns.md — ViewEncapsulation, theming, responsive
+   - 10.backend/01.api-integration.md — API service abstraction, interceptors (if backend exists)
    - 30.security-db/01.security-auth.md — Auth guards, JWT interceptor, route protection
    - 40.infra/01.environment-config.md — environment.ts, angular.json, build configuration
    - 40.infra/02.logging-monitoring.md — Error tracking, performance monitoring
    - 40.infra/03.cicd-deployment.md — CI/CD pipeline, ng build --configuration, Docker
-   - 50.verification/01.development-verification.md — ng serve, ng build, Lighthouse
-   - 50.verification/02.testing-strategy.md — TestBed, component harness, E2E strategy
+   - 80.verification/01.development-verification.md — ng serve, ng build, Lighthouse
+   - 80.verification/02.testing-strategy.md — TestBed, component harness, E2E strategy
 
    Each file MUST include:
-   - Correct examples (code blocks in TypeScript)
-   - Incorrect examples (code blocks showing common Angular mistakes)
+   - Correct examples (✅ code blocks in TypeScript)
+   - Incorrect examples (❌ code blocks showing common Angular mistakes)
    - Key rules summary table
 
 3. .claude/rules/ (active domains only)
@@ -83,6 +83,7 @@ Generation targets:
      - `40.infra/03.cicd-deployment-rules.md` paths: `["**/*.yml", "**/*.yaml", "**/Dockerfile*", "**/*.ts"]` — CI config + source
      - `50.sync/*` rules: `paths: ["**/claudeos-core/**", "**/.claude/**"]`
      - `60.memory/*` rules: forward reference — Pass 4 will generate 4 files (01.decision-log, 02.failure-patterns, 03.compaction, 04.auto-rule-update), each with file-specific `paths`. Pass 3 must STILL list ```.claude/rules/60.memory/*``` as a row in CLAUDE.md Section 6 Rules table so developers/Claude see the category exists.
+     - `70.domains/*` rules (multi-domain projects only): per-domain rules at `.claude/rules/70.domains/{type}/{domain}-rules.md` (where `{type}` is `backend` or `frontend`, ALWAYS present even in single-stack projects for uniform layout + zero-migration future-proofing), each with a `paths:` glob scoped to that domain's source directories so the rule auto-loads only when editing files within the relevant domain. Folder name is PLURAL (`domains/`) — collection of N per-domain files — and each file inside uses the SINGULAR domain name (`{domain}-rules.md`). DO NOT use `60.domains/` (collides with `60.memory/`) and DO NOT skip the `{type}/` sub-folder. See pass3-footer.md "Per-domain folder convention" for the full rationale.
    - MUST generate `.claude/rules/00.core/00.standard-reference.md` as a directory of all standard files
 
 4. .claude/rules/50.sync/ (2 sync rules)

package/pass-prompts/templates/common/claude-md-scaffold.md

@@ -279,6 +279,12 @@ Unlike rules that auto-load via `paths` glob, this layer is referenced **on-dema
 4. **Record repeated errors**: If the same error occurs ≥2 times and the root cause is non-obvious, register it in `failure-patterns.md` with a new pattern-id.
 5. **Periodic compaction**: When a memory file approaches 400 lines or has not been tidied up for over a month, run `npx claudeos-core memory compact`.
 6. **Review rule-update proposals**: Review proposals in `auto-rule-update.md` with confidence ≥ 0.70. When accepting, edit the corresponding rule file and log the decision in `decision-log.md`.
+
+**Session Resume (after auto-compact or restart)**: Claude Code's auto-compact feature may truncate session context mid-work, and a restarted session starts with a fresh context window. When resuming work:
+
+- **Re-scan** `failure-patterns.md` — error patterns referenced pre-compact may have been dropped from context.
+- **Re-read the 3 most recent entries** of `decision-log.md` — new decisions may have been recorded during the truncated portion of the session.
+- **Re-match rules by `paths` glob** for the current working files — CLAUDE.md is always loaded, but `paths`-conditional rules may not have been re-loaded after compact. Explicitly Read the relevant rule files if needed.
 ```
 
 ---
@@ -555,6 +561,63 @@ Format: `**{category}**: {explanation}`
   Example row for 60.memory:
   `.claude/rules/60.memory/*` | Auto-loaded when editing L4 memory
   files (decision-log · failure-patterns · compaction · auto-rule-update) |
+  Example row for 70.domains (only when the project has multi-batch
+  domain output — see "Per-domain folder convention" below):
+  `.claude/rules/70.domains/*` | Auto-loaded when editing files within
+  a specific domain (paths-scoped, one rule file per domain) |
+
+**Per-domain folder convention (canonical, v2.4.0+)**:
+
+When a project has multiple distinct domains and Pass 3 emits per-domain
+output (typical for backends with ≥4 domains, multi-batch runs, or
+projects where rules need domain-specific `paths` glob scoping), the
+canonical folder is **`70.domains/{type}/`** (PLURAL collection +
+ALWAYS-typed sub-folder), and each file inside uses the singular
+domain name:
+
+  - `claudeos-core/standard/70.domains/{type}/{domain}.md` — `{type}`
+    is `backend` or `frontend`
+  - `.claude/rules/70.domains/{type}/{domain}-rules.md` — per-domain rule
+    (with `paths` frontmatter scoping to that domain's source directories)
+
+The `{type}/` sub-folder is ALWAYS present, even in single-stack
+projects (backend-only or frontend-only). Reasons: (1) zero file moves
+when a single-stack project later adds the other stack, (2) no LLM
+probabilistic drift between Pass 3 runs (one pattern always), (3) one
+pattern for validators to recognize, (4) future-proof for new stack
+types (mobile/cli/agent).
+
+The Pass 3 orchestrator (`bin/commands/init.js`) classifies each domain
+via `project-analysis.json` and emits per-domain target paths
+explicitly in the batch scope note — you (the LLM) should follow the
+explicit paths shown there.
+  - `claudeos-core/skills/{category}/domains/{domain}.md` — per-domain
+    skill notes (sub-folder under skill category, no number prefix
+    because skills/ is a separate namespace from standard/rules)
+  - `claudeos-core/skills/{category}/02.domains.md` — sibling
+    ORCHESTRATOR for the `domains/` sub-folder (REQUIRED whenever
+    `domains/` is populated). Mirrors the canonical pattern
+    `01.scaffold-*-feature.md` ↔ `scaffold-*-feature/`: orchestrator
+    file at category root + sub-folder of the same stem. Stem
+    (`domains`) MUST match sub-folder name so `content-validator`'s
+    standard orchestrator-stem matching covers the sub-skills
+    directly without depending on the global-MANIFEST coverage
+    fallback. The per-domain note files INSIDE `domains/` carry NO
+    numeric prefix (`payment.md`, not `01.payment.md`) — domains are
+    independent siblings without execution order, unlike the
+    sequenced CRUD sub-skills (`01.dto.md` → `08.test.md`) where
+    numbers encode the scaffolding step order.
+
+The `70.` prefix sits AFTER `60.memory` (which is regression-guarded to
+60) and BEFORE `90.optional`, giving per-domain content its own clean
+slot in the rules numbering. The folder name is plural (`domains/`)
+because it holds N files, one per project domain — matching the standard
+filesystem convention `users/user.md`, `posts/post.md`. The other
+numbered category folders (`00.core/`, `10.backend/`, etc.) are singular
+because each represents ONE topic, not a collection.
+
+DO NOT use `60.domains/` (collides with `60.memory/`) and DO NOT use
+`70.domain/` (singular folder is incorrect for a collection).
 
 **Sub-section 3**: `### Skills (Automated Repeated-task Procedures)`
 - Bullet list
@@ -644,6 +707,24 @@ Workflow: `#### Memory Workflow` — FIXED 6-step numbered list
 5. Periodic compaction — memory compact command
 6. Review rule-update proposals — auto-rule-update review
 
+**Session Resume block** (RECOMMENDED, follows the 6-step numbered list
+as prose — not a new H4 subsection). Opens with bold label
+`**Session Resume (after auto-compact or restart)**:` followed by a
+3-bullet list covering: re-scan `failure-patterns.md`, re-read the 3
+most recent entries of `decision-log.md`, and re-match rules by `paths`
+glob for current working files. This block addresses Claude Code's
+auto-compact behavior that may truncate session context mid-work.
+
+New CLAUDE.md generation (`npx claudeos-core init`) emits this block
+by default. Existing CLAUDE.md files without it remain structurally
+valid — the validator does not enforce Session Resume presence, only
+that if present it follows the prose-not-H4 form.
+
+The Session Resume block MUST NOT be a `####` subsection — the Section
+8 structural validator enforces EXACTLY 2 `####` headings (L4 Memory
+Files + Memory Workflow). Session Resume is prose inside the Memory
+Workflow section, not a sibling heading.
+
 **Section 8 single-occurrence rule** (enforces the "one canonical home"
 principle):
 - The L4 Memory Files table appears EXACTLY ONCE in the entire document

package/pass-prompts/templates/common/pass3-footer.md

@@ -535,5 +535,109 @@ level (the scaffold's PROJECT_CONTEXT mentions architecture style),
 but it does NOT enumerate rules. Section 6 "Standard / Rules / Skills
 Reference" provides a REFERENCE INDEX (what exists), not rule content.
 
+CRITICAL — Standard files MUST include both ✅ and ❌ examples:
+Every file under `claudeos-core/standard/**/*.md` (except pure index/overview
+files like `00.core/01.project-overview.md`) MUST contain BOTH:
+  - At least one ✅ Correct example (a fenced code block showing the right way)
+  - At least one ❌ Incorrect example (a fenced code block showing the wrong way)
+
+Skipping the ❌ block is a common Pass 3b LLM failure mode that produces
+`[NO_BAD_EXAMPLE]` advisories from `content-validator`. Even if you can only
+think of a minimal contrastive ❌ (a one-line wrong call, a missing
+annotation, a typo'd config key), include it. The contrast is what gives
+the standard its didactic value — a file with only ✅ examples reads as
+"this is one way to do it", whereas ✅+❌ reads as "this is the way; here is
+the failure mode".
+
+Self-check before finalizing each standard file:
+  - Does this file have at least one ```...``` block marked ✅?
+  - Does this file have at least one ```...``` block marked ❌?
+  If either is missing, add it before moving on.
+
+CRITICAL — Per-domain folder convention (`70.domains/{type}/`, plural):
+
+When generating per-domain files (any output that's specific to one
+project domain — e.g. `payment.md`, `order.md`, `member.md`), use the
+canonical `70.domains/` folder (PLURAL, collection-style) and ALWAYS
+include a `{type}/` sub-folder (`backend/` or `frontend/`) regardless
+of single-stack or multi-stack project. Uniform-convention rationale
+in the next paragraph.
+
+  - Per-domain standard:
+    `claudeos-core/standard/70.domains/{type}/{domain}.md`
+    where `{type}` is `backend` or `frontend`
+  - Per-domain rule:
+    `.claude/rules/70.domains/{type}/{domain}-rules.md`
+    (via staging-override path
+    `claudeos-core/generated/.staged-rules/70.domains/{type}/{domain}-rules.md`,
+    each rule file MUST have a `paths:` frontmatter glob scoping to that
+    domain's source directories)
+
+**Why ALWAYS the `{type}/` sub-folder, even for single-stack projects?**
+A single-stack project pays a 1-folder depth cost
+(`70.domains/backend/order.md` instead of `70.domains/order.md`). In
+exchange:
+
+  1. **Zero migration when the other stack is added.** A backend-only
+     project that later adds a Next.js frontend does NOT need to move
+     existing files to `backend/` — they're already there.
+  2. **No LLM probabilistic drift.** Pass 3 LLM never has to decide
+     "is this single-stack or multi?" — the pattern is always the
+     same.
+  3. **One pattern for validators.** `content-validator` and
+     `claude-md-validator` recognize a single layout instead of
+     branching.
+  4. **Future-proof for new stack types** (mobile, cli, agent, ...).
+
+The Pass 3 orchestrator (`bin/commands/init.js`) classifies each
+domain via `project-analysis.json` and emits per-domain target paths
+explicitly in the batch scope note. **Follow the explicit
+per-domain target paths shown in the scope note** rather than infer
+from the domain name. If the scope note shows
+`order → claudeos-core/standard/70.domains/backend/order.md`, that's
+the path to use — the type sub-folder is already classified for you.
+
+  - Per-domain skill notes:
+    `claudeos-core/skills/{category}/domains/{domain}.md`
+    (sub-folder under skill category — `skills/` is a separate namespace
+    from standard/rules, so no number prefix here. The `{category}`
+    folder name already encodes stack: `10.backend-crud/`,
+    `20.frontend-page/`. So skills don't need the additional `{type}/`
+    sub-folder that standard/rules use.)
+  - Per-domain skill ORCHESTRATOR (sibling to the `domains/` sub-folder):
+    `claudeos-core/skills/{category}/02.domains.md`
+    The orchestrator is REQUIRED when the `domains/` sub-folder is
+    populated. It mirrors the canonical pattern already used for
+    `01.scaffold-crud-feature.md` ↔ `scaffold-crud-feature/` (orchestrator
+    file at category root + sub-folder of the same stem). The basename
+    stem (`domains`) MUST match the sub-folder name so
+    `content-validator`'s standard orchestrator-stem matching covers
+    the sub-skills directly — without depending on the
+    global-MANIFEST coverage fallback. The orchestrator content lists
+    every per-domain note file in the `domains/` sub-folder, links to
+    `00.shared/MANIFEST.md`, and describes the per-domain anti-pattern
+    catalog if applicable. Numbered `02.` because `01.scaffold-*-feature.md`
+    already occupies the `01.` slot at the category root.
+
+Why `70.` and not `60.`: `60.memory/*` is the canonical L4 memory rules
+folder (regression-guarded since v2.0.0; cannot move to 70). Putting
+domains at `60.domains/` causes a `60.` prefix collision with
+`60.memory/` that makes directory listings ambiguous. `70.domains/` sits
+after memory and before `90.optional/`, giving per-domain content its
+own clean slot.
+
+Why PLURAL `domains/`: the folder holds N files, one per project domain
+— `payment.md`, `order.md`, etc. This matches the standard filesystem
+convention for collections (`users/user.md`, `posts/post.md`). The other
+numbered category folders (`00.core/`, `10.backend/`, etc.) are singular
+because each represents ONE topic, not a collection of items.
+
+DO NOT use:
+  - `60.domains/` (collides with `60.memory/`)
+  - `70.domain/` (singular is wrong for a collection folder)
+  - Inlining per-domain content into `00.core/*` or topical files
+    (per-domain content is DOMAIN-scoped, topical files are TOPIC-scoped
+    — `paths` glob scoping breaks if they share files)
+
 After completion, run the following commands in order:
 1. npx claudeos-core health

package/pass-prompts/templates/java-spring/pass3.md

@@ -79,21 +79,21 @@ Generation targets:
    - 00.core/01.project-overview.md — Stack, modules, API server info
    - 00.core/02.architecture.md — Layer structure, request flow, package structure
    - 00.core/03.naming-conventions.md — Class/DTO/Entity/table naming conventions
-   - 10.backend-api/01.controller-patterns.md — Controller writing rules + examples
-   - 10.backend-api/02.service-patterns.md — Transactions, DI, business logic patterns
-   - 10.backend-api/03.data-access-patterns.md — ORM patterns (tailored to detected MyBatis/JPA/QueryDSL)
-   - 10.backend-api/04.response-exception.md — Response/error handling patterns
-   - 10.backend-api/05.dto-validation.md — DTO writing rules, Validation
-   - 10.backend-api/06.interceptor-filter-aop.md — Middleware, AOP, logging interceptors
-   - 20.frontend-ui/* — (generate only if frontend detected)
+   - 10.backend/01.controller-patterns.md — Controller writing rules + examples
+   - 10.backend/02.service-patterns.md — Transactions, DI, business logic patterns
+   - 10.backend/03.data-access-patterns.md — ORM patterns (tailored to detected MyBatis/JPA/QueryDSL)
+   - 10.backend/04.response-exception.md — Response/error handling patterns
+   - 10.backend/05.dto-validation.md — DTO writing rules, Validation
+   - 10.backend/06.interceptor-filter-aop.md — Middleware, AOP, logging interceptors
+   - 20.frontend/* — (generate only if frontend detected)
    - 30.security-db/01.security-auth.md — Authentication, authorization, CORS
    - 30.security-db/02.database-schema.md — DDL, migrations, audit columns
    - 30.security-db/03.common-utilities.md — Common utilities, constants, Base classes
    - 40.infra/01.environment-config.md — Profiles, environment variables, configuration management
    - 40.infra/02.logging-monitoring.md — Logging standards, monitoring, alerts
    - 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 — Testing strategy, mocking, coverage
+   - 80.verification/01.development-verification.md — Build, startup, API testing
+   - 80.verification/02.testing-strategy.md — Testing strategy, mocking, coverage
 
    Each file MUST include:
    - Correct examples (✅ code blocks)
@@ -107,7 +107,7 @@ Generation targets:
    - 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
+     > For detailed patterns and examples, Read: claudeos-core/standard/10.backend/01.controller-patterns.md
      ```
    - `paths:` frontmatter per rule category:
      - `00.core/*` rules: `paths: ["**/*"]` — always loaded (architecture, naming are universally needed)
@@ -118,6 +118,7 @@ Generation targets:
      - `40.infra/03.cicd-deployment-rules.md` paths: `["**/*.yml", "**/*.yaml", "**/Dockerfile*", "**/*.gradle*", "**/pom.xml", "**/*.java"]` — CI / build config + source
      - `50.sync/*` rules: `paths: ["**/claudeos-core/**", "**/.claude/**"]` — loaded only when editing claudeos-core files
      - `60.memory/*` rules: forward reference — Pass 4 will generate 4 files (01.decision-log, 02.failure-patterns, 03.compaction, 04.auto-rule-update), each with file-specific `paths`. Pass 3 must STILL list ```.claude/rules/60.memory/*``` as a row in CLAUDE.md Section 6 Rules table so developers/Claude see the category exists.
+     - `70.domains/*` rules (multi-domain projects only): per-domain rules at `.claude/rules/70.domains/{type}/{domain}-rules.md` (where `{type}` is `backend` or `frontend`, ALWAYS present even in single-stack projects for uniform layout + zero-migration future-proofing), each with a `paths:` glob scoped to that domain's source directories so the rule auto-loads only when editing files within the relevant domain. Folder name is PLURAL (`domains/`) — collection of N per-domain files — and each file inside uses the SINGULAR domain name (`{domain}-rules.md`). DO NOT use `60.domains/` (collides with `60.memory/`) and DO NOT skip the `{type}/` sub-folder. See pass3-footer.md "Per-domain folder convention" for the full rationale.
    - MUST generate `.claude/rules/00.core/00.standard-reference.md` — a directory of all standard files. This is NOT a "read all" instruction. Claude should Read ONLY the standards relevant to the current task. Structure it as:
      ```
      ---
@@ -134,12 +135,12 @@ Generation targets:
      - claudeos-core/standard/00.core/03.naming-conventions.md
      - claudeos-core/standard/00.core/04.doc-writing-guide.md
      ## Backend API
-     - claudeos-core/standard/10.backend-api/01.controller-patterns.md
-     - claudeos-core/standard/10.backend-api/02.service-patterns.md
-     - claudeos-core/standard/10.backend-api/03.data-access-patterns.md
-     - claudeos-core/standard/10.backend-api/04.response-exception.md
-     - claudeos-core/standard/10.backend-api/05.dto-validation.md
-     - claudeos-core/standard/10.backend-api/06.interceptor-filter-aop.md
+     - claudeos-core/standard/10.backend/01.controller-patterns.md
+     - claudeos-core/standard/10.backend/02.service-patterns.md
+     - claudeos-core/standard/10.backend/03.data-access-patterns.md
+     - claudeos-core/standard/10.backend/04.response-exception.md
+     - claudeos-core/standard/10.backend/05.dto-validation.md
+     - claudeos-core/standard/10.backend/06.interceptor-filter-aop.md
      ## Security & DB
      - claudeos-core/standard/30.security-db/01.security-auth.md
      - claudeos-core/standard/30.security-db/02.database-schema.md
@@ -148,8 +149,8 @@ Generation targets:
      - claudeos-core/standard/40.infra/01.environment-config.md
      - claudeos-core/standard/40.infra/02.logging-monitoring.md
      - claudeos-core/standard/40.infra/03.cicd-deployment.md
-     - claudeos-core/standard/50.verification/01.development-verification.md
-     - claudeos-core/standard/50.verification/02.testing-strategy.md
+     - claudeos-core/standard/80.verification/01.development-verification.md
+     - claudeos-core/standard/80.verification/02.testing-strategy.md
      ```
      List only the standard files that were actually generated above. Include frontend standards only if frontend was detected. NOTE: `00.core/04.doc-writing-guide.md` is a FORWARD REFERENCE — Pass 4 will generate it; include it anyway. Do NOT add a "DO NOT Read" section here — that information lives in CLAUDE.md Section 7 (the single source of truth).