claudeos-core 2.4.0 → 2.4.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (12) hide show
  1. package/CHANGELOG.md +74 -3
  2. package/README.de.md +253 -195
  3. package/README.es.md +242 -184
  4. package/README.fr.md +240 -182
  5. package/README.hi.md +248 -190
  6. package/README.ja.md +247 -189
  7. package/README.ko.md +220 -162
  8. package/README.md +163 -105
  9. package/README.ru.md +254 -196
  10. package/README.vi.md +250 -192
  11. package/README.zh-CN.md +252 -194
  12. package/package.json +1 -1
package/README.hi.md CHANGED
@@ -7,44 +7,40 @@
7
7
  [![license](https://img.shields.io/npm/l/claudeos-core.svg?color=blue)](LICENSE)
8
8
  [![downloads](https://img.shields.io/npm/dm/claudeos-core.svg?logo=npm&color=blue&label=downloads)](https://www.npmjs.com/package/claudeos-core)
9
9
 
10
- **अपने वास्तविक स्रोत कोड से Claude Code दस्तावेज़ स्वतः उत्पन्न करें।** एक CLI टूल जो आपके प्रोजेक्ट का स्थैतिक विश्लेषण करता है, फिर 4-pass Claude पाइपलाइन चलाकर `.claude/rules/`, standards, skills और guides उत्पन्न करता है — ताकि Claude Code सामान्य परिपाटियों के बजाय **आपके प्रोजेक्ट की** परिपाटियों का पालन करे।
10
+ **एक ऐसा CLI tool जो आपके actual source code को पढ़कर `CLAUDE.md` और `.claude/rules/` खुद generate कर देता है। Node.js scanner, 4-pass Claude pipeline और 5 validators मिलकर काम करते हैं। 12 stacks और 10 भाषाएँ support हैं, और जो path code में नहीं है वो output में भी नहीं आएगा।**
11
11
 
12
12
  ```bash
13
13
  npx claudeos-core init
14
14
  ```
15
15
 
16
+ [**12 stacks**](#supported-stacks) पर सीधे चलता है (monorepos भी)। एक command, कोई config नहीं, बीच में रुक जाए तो वहीं से resume होता है, और बार-बार चलाने पर भी safe है।
17
+
16
18
  [🇺🇸 English](README.md) · [🇰🇷 한국어](README.ko.md) · [🇨🇳 中文](README.zh-CN.md) · [🇯🇵 日本語](README.ja.md) · [🇪🇸 Español](README.es.md) · [🇻🇳 Tiếng Việt](README.vi.md) · [🇷🇺 Русский](README.ru.md) · [🇫🇷 Français](README.fr.md) · [🇩🇪 Deutsch](README.de.md)
17
19
 
18
20
  ---
19
21
 
20
22
  ## यह क्या है?
21
23
 
22
- आप Claude Code का उपयोग करते हैं। यह स्मार्ट है, लेकिन यह **आपके प्रोजेक्ट की परिपाटियाँ** नहीं जानता:
23
- - आपकी टीम MyBatis का उपयोग करती है, लेकिन Claude JPA कोड उत्पन्न करता है।
24
- - आपका wrapper `ApiResponse.ok()` है, लेकिन Claude `ResponseEntity.success()` लिखता है।
25
- - आपके packages `controller/order/` हैं, लेकिन Claude `order/controller/` बनाता है।
24
+ Claude Code हर नए session पर framework के generic defaults पर वापस चला जाता है। आपकी team **MyBatis** use करती है, फिर भी Claude JPA का code लिख देता है। आपका response wrapper `ApiResponse.ok()` है, फिर भी Claude `ResponseEntity.success()` लिखता है। Packages आपने layer-first design किए हैं, मगर Claude domain-first structure बना देता है। हर repo के लिए `.claude/rules/` खुद से लिखकर रखना इसका एक हल है, लेकिन जैसे ही code evolve होता है आपके rules drift करने लगते हैं।
26
25
 
27
- इसलिए आप उत्पन्न हर फ़ाइल को ठीक करने में काफ़ी समय लगाते हैं।
26
+ **ClaudeOS-Core यही काम deterministically करता है, सीधे आपके actual source code से।** पहले एक Node.js scanner project को पढ़ता है, यानी stack, ORM, package layout और file paths सब निकाल लेता है। उसके बाद 4-pass Claude pipeline पूरा set generate करती है। `CLAUDE.md`, auto-load होने वाले `.claude/rules/`, standards, skills — ये सब एक explicit path allowlist के अंदर ही बनते हैं, और LLM इस दायरे से बाहर नहीं जा सकता। आखिर में 5 validators output को ship होने से पहले verify कर लेते हैं।
28
27
 
29
- **ClaudeOS-Core इसे ठीक करता है।** यह आपके वास्तविक स्रोत कोड को स्कैन करता है, आपकी परिपाटियों का पता लगाता है, और `.claude/rules/` में नियमों का एक पूरा सेट लिखता है — वह डायरेक्टरी जिसे Claude Code स्वचालित रूप से पढ़ता है। अगली बार जब आप कहेंगे _"orders के लिए CRUD बनाओ"_, Claude पहली कोशिश में ही आपकी परिपाटियों का पालन करेगा।
28
+ नतीजा यह है कि same input के लिए हमेशा byte-identical output मिलता है, चाहे 10 भाषाओं में से कोई भी चुनी जाए, और कभी invented path नहीं आएगा। (विस्तार से नीचे [क्या इसे अलग बनाता है](#क्या-इसे-अलग-बनाता-है) में।)
30
29
 
31
- ```
32
- पहले: आप → Claude Code → "सामान्य रूप से अच्छा" कोड → मैन्युअल फ़िक्सिंग
33
- बाद में: आप → Claude Code → आपके प्रोजेक्ट से मेल खाता कोड → सीधे उपयोग
34
- ```
30
+ लंबे चलने वाले projects के लिए एक अलग [Memory Layer](#memory-layer-वैकल्पिक-दीर्घकालिक-प्रोजेक्ट्स-के-लिए) भी seed होता है।
35
31
 
36
32
  ---
37
33
 
38
- ## एक वास्तविक प्रोजेक्ट पर देखें
34
+ ## वास्तविक प्रोजेक्ट पर देखें
39
35
 
40
- [`spring-boot-realworld-example-app`](https://github.com/gothinkster/spring-boot-realworld-example-app) पर चलाएँ — Java 11 · Spring Boot 2.6 · MyBatis · SQLite · 187 source files. आउटपुट: **75 generated files**, कुल समय **53 minutes**, सभी validators ✅।
36
+ [`spring-boot-realworld-example-app`](https://github.com/gothinkster/spring-boot-realworld-example-app) पर इसे चलाकर देखा गया। Java 11, Spring Boot 2.6, MyBatis, SQLite, कुल 187 source files. Output: **75 generated files**, total time **53 मिनट**, और सभी validators ✅।
41
37
 
42
38
  <p align="center">
43
39
  <img src="docs/assets/spring-boot-realworld-demo.gif" alt="ClaudeOS-Core init running on spring-boot-realworld-example-app — stack detection, 4-pass pipeline, validators, completion summary" width="769">
44
40
  </p>
45
41
 
46
42
  <details>
47
- <summary><strong>📺 टर्मिनल आउटपुट (टेक्स्ट संस्करण, खोज और कॉपी के लिए)</strong></summary>
43
+ <summary><strong>Terminal output (text version, search और copy के लिए)</strong></summary>
48
44
 
49
45
  ```text
50
46
  ╔════════════════════════════════════════════════════╗
@@ -79,18 +75,18 @@ npx claudeos-core init
79
75
  [██████████░░░░░░░░░░] 50% (2/4)
80
76
 
81
77
  [6] Pass 3 — Generating all files...
82
- 🚀 Pass 3 split mode (3a → 3b → 3c → 3d-aux)
78
+ Pass 3 split mode (3a → 3b → 3c → 3d-aux)
83
79
  ✅ 3a complete (2m 57s) — pass3a-facts.md (187-path allowlist)
84
80
  ✅ 3b complete (18m 49s) — CLAUDE.md + 19 standards + 20 rules
85
81
  ✅ 3c complete (12m 35s) — 13 skills + 9 guides
86
82
  ✅ 3d-aux complete (3m 18s) — database/ + mcp-guide/
87
- 🎉 Pass 3 split complete: 4/4 stages successful
83
+ Pass 3 split complete: 4/4 stages successful
88
84
  [███████████████░░░░░] 75% (3/4)
89
85
 
90
86
  [7] Pass 4 — Memory scaffolding...
91
- 📦 Pass 4 staged-rules: 6 rule files moved to .claude/rules/
87
+ Pass 4 staged-rules: 6 rule files moved to .claude/rules/
92
88
  ✅ Pass 4 complete (5m)
93
- 📋 Gap-fill: all 12 expected files already present
89
+ Gap-fill: all 12 expected files already present
94
90
  [████████████████████] 100% (4/4)
95
91
 
96
92
  ╔═══════════════════════════════════════╗
@@ -119,37 +115,45 @@ npx claudeos-core init
119
115
  </details>
120
116
 
121
117
  <details>
122
- <summary><strong>📄 आपकी <code>CLAUDE.md</code> में क्या होता है (वास्तविक अंश)</strong></summary>
118
+ <summary><strong>असली <code>CLAUDE.md</code> में आखिर क्या लिखा जाता है (वास्तविक excerpt — Section 1 + 2)</strong></summary>
123
119
 
124
120
  ```markdown
125
- ## 4. Core Architecture
126
-
127
- ### Core Patterns
128
-
129
- - **Hexagonal ports & adapters**: domain ports live in `io.spring.core.{aggregate}`
130
- and are implemented by `io.spring.infrastructure.repository.MyBatis{Aggregate}Repository`.
131
- The domain layer has zero MyBatis imports.
132
- - **CQRS-lite read/write split (same DB)**: write side goes through repository ports
133
- + entities; read side is a separate `readservice` package whose `@Mapper`
134
- interfaces return `*Data` DTOs directly (no entity hydration).
135
- - **No aggregator/orchestrator layer**: multi-source orchestration happens inside
136
- application services (e.g., `ArticleQueryService`); there is no `*Aggregator`
137
- class in the codebase.
138
- - **Application-supplied UUIDs**: entity constructors assign their own UUID; PK is
139
- passed via `#{user.id}` on INSERT. The global
140
- `mybatis.configuration.use-generated-keys=true` flag is dead config
141
- (auto-increment is unused).
142
- - **JWT HS512 authentication**: `io.spring.infrastructure.service.DefaultJwtService`
143
- is the sole token subject in/out; `io.spring.api.security.JwtTokenFilter`
144
- extracts the token at the servlet layer.
121
+ # CLAUDE.md — spring-boot-realworld-example-app
122
+
123
+ > Reference implementation of the RealWorld backend specification on
124
+ > Java 11 + Spring Boot 2.6, exposing both REST and GraphQL endpoints
125
+ > over a hexagonal MyBatis persistence layer.
126
+
127
+ #### 1. Role Definition
128
+
129
+ As the senior developer for this repository, you are responsible for
130
+ writing, modifying, and reviewing code. Responses must be written in English.
131
+ A Java Spring Boot REST + GraphQL API server organized around a hexagonal
132
+ (ports & adapters) architecture, with a CQRS-lite read/write split inside
133
+ an XML-driven MyBatis persistence layer and JWT-based authentication.
134
+
135
+ #### 2. Project Overview
136
+
137
+ | Item | Value |
138
+ |---|---|
139
+ | Language | Java 11 |
140
+ | Framework | Spring Boot 2.6.3 |
141
+ | Build Tool | Gradle (Groovy DSL) |
142
+ | Persistence | MyBatis 3 via `mybatis-spring-boot-starter:2.2.2` (no JPA) |
143
+ | Database | SQLite (`org.xerial:sqlite-jdbc:3.36.0.3`) — `dev.db` (default), `:memory:` (test) |
144
+ | Migration | Flyway — single baseline `V1__create_tables.sql` |
145
+ | API Style | REST (`io.spring.api.*`) + GraphQL via Netflix DGS `:4.9.21` |
146
+ | Authentication | JWT HS512 (`jjwt-api:0.11.2`) + Spring Security `PasswordEncoder` |
147
+ | Server Port | 8080 (default) |
148
+ | Test Stack | JUnit Jupiter 5, Mockito, AssertJ, rest-assured, spring-mock-mvc |
145
149
  ```
146
150
 
147
- ध्यान दें: ऊपर के सभी दावे वास्तविक स्रोत पर आधारित हैं — class names, package paths, configuration keys और dead-config flag तक — सब Claude द्वारा फ़ाइल लिखने से पहले scanner द्वारा निकाले गए हैं।
151
+ ऊपर table में जो भी value है — exact dependency coordinates, `dev.db` filename, `V1__create_tables.sql` migration नाम, "no JPA" तक — वो सब Claude के file लिखने से पहले scanner ने `build.gradle`, `application.properties` और source tree से सीधे निकाला है। एक भी value guess नहीं की गई।
148
152
 
149
153
  </details>
150
154
 
151
155
  <details>
152
- <summary><strong>🛡️ एक वास्तविक auto-loaded rule (<code>.claude/rules/10.backend/03.data-access-rules.md</code>)</strong></summary>
156
+ <summary><strong>एक असली auto-loaded rule (<code>.claude/rules/10.backend/01.controller-rules.md</code>)</strong></summary>
153
157
 
154
158
  ````markdown
155
159
  ---
@@ -157,298 +161,352 @@ paths:
157
161
  - "**/*"
158
162
  ---
159
163
 
160
- # Data Access Rules
164
+ #### Controller Rules
165
+
166
+ ##### REST (`io.spring.api.*`)
161
167
 
162
- ## XML-only SQL
163
- - Every SQL statement lives in `src/main/resources/mapper/*.xml`.
164
- NO `@Select` / `@Insert` / `@Update` / `@Delete` annotations on `@Mapper` methods.
165
- - Each `@Mapper` interface has exactly one XML file at
166
- `src/main/resources/mapper/{InterfaceName}.xml`.
167
- - `<mapper namespace="...">` MUST be the fully qualified Java interface name.
168
- The single existing exception is `TransferData.xml` (free-form `transfer.data`).
168
+ - Controllers are the SOLE response wrapper for HTTP — no aggregator/facade above them.
169
+ Return `ResponseEntity<?>` or a body Spring serializes via `JacksonCustomizations`.
170
+ - Each controller method calls exactly ONE application service method. Multi-source
171
+ composition lives in the application service.
172
+ - Controllers MUST NOT import `io.spring.infrastructure.*`. No direct `@Mapper` access.
173
+ - Validate command-param arguments with `@Valid`. Custom JSR-303 constraints live under
174
+ `io.spring.application.{aggregate}.*`.
175
+ - Resolve the current user via `@AuthenticationPrincipal User`.
176
+ - Let exceptions propagate to `io.spring.api.exception.CustomizeExceptionHandler`
177
+ (`@ControllerAdvice`). Do NOT `try/catch` business exceptions inside the controller.
169
178
 
170
- ## Dynamic SQL
171
- - `<if>` predicates MUST guard both null and empty:
172
- `<if test="X != null and X != ''">`. Empty-only is the existing HIGH-severity bug pattern.
173
- - Prefer `LIMIT n OFFSET m` over MySQL-style `LIMIT m, n`.
179
+ ##### GraphQL (`io.spring.graphql.*`)
174
180
 
175
- ## Examples
181
+ - DGS components (`@DgsComponent`) are the sole GraphQL response wrappers.
182
+ Use `@DgsQuery` / `@DgsData` / `@DgsMutation`.
183
+ - Resolve the current user via `io.spring.graphql.SecurityUtil.getCurrentUser()`.
184
+
185
+ ##### Examples
176
186
 
177
187
  ✅ Correct:
178
- ```xml
179
- <update id="update">
180
- UPDATE articles
181
- <set>
182
- <if test="article.title != null and article.title != ''">title = #{article.title},</if>
183
- updated_at = #{article.updatedAt}
184
- </set>
185
- WHERE id = #{article.id}
186
- </update>
188
+ ```java
189
+ @PostMapping
190
+ public ResponseEntity<?> createArticle(@AuthenticationPrincipal User user,
191
+ @Valid @RequestBody NewArticleParam param) {
192
+ Article article = articleCommandService.createArticle(param, user);
193
+ ArticleData data = articleQueryService.findById(article.getId(), user)
194
+ .orElseThrow(ResourceNotFoundException::new);
195
+ return ResponseEntity.ok(Map.of("article", data));
196
+ }
187
197
  ```
188
198
 
189
199
  ❌ Incorrect:
190
- ```xml
191
- <mapper namespace="article.mapper"> <!-- NO — namespace MUST be FQCN -->
200
+ ```java
201
+ @PostMapping
202
+ public ResponseEntity<?> create(@RequestBody NewArticleParam p) {
203
+ try {
204
+ articleCommandService.createArticle(p, currentUser);
205
+ } catch (Exception e) { // NO — let CustomizeExceptionHandler handle it
206
+ return ResponseEntity.status(500).body(e.getMessage()); // NO — leaks raw message
207
+ }
208
+ return ResponseEntity.ok().build();
209
+ }
192
210
  ```
193
211
  ````
194
212
 
195
- `paths: ["**/*"]` glob का अर्थ है कि जब भी आप प्रोजेक्ट की किसी भी फ़ाइल को संपादित करते हैं, Claude Code इस rule को स्वचालित रूप से लोड कर लेता है। ✅/❌ उदाहरण इस codebase की वास्तविक परिपाटियों और मौजूदा बग पैटर्न से सीधे आते हैं।
213
+ `paths: ["**/*"]` glob का मतलब है कि project में जब भी कोई file edit हो, Claude Code इस rule को अपने आप load कर लेता है। Rule में जितने भी class names, package paths और exception handlers हैं, वो सब scanned source से सीधे आए हैं। यानी project का असली `CustomizeExceptionHandler` और `JacksonCustomizations` जैसा है, वैसा ही यहाँ झलकता है।
196
214
 
197
215
  </details>
198
216
 
199
217
  <details>
200
- <summary><strong>🧠 एक स्वतः उत्पन्न <code>decision-log.md</code> seed (वास्तविक अंश)</strong></summary>
218
+ <summary><strong>Auto-generated <code>decision-log.md</code> seed (वास्तविक excerpt)</strong></summary>
201
219
 
202
220
  ```markdown
203
- ## 2026-04-26 — CQRS-lite read/write split inside the persistence layer
204
-
205
- - **Context:** Writes go through `core.*Repository` port → `MyBatis*Repository`
206
- adapter → `io.spring.infrastructure.mybatis.mapper.{Aggregate}Mapper`.
207
- Reads bypass the domain port: application service →
208
- `io.spring.infrastructure.mybatis.readservice.{Concept}ReadService` directly,
209
- returning flat `*Data` DTOs from `io.spring.application.data.*`.
210
- - **Options considered:** Single repository surface returning hydrated entities
211
- for both reads and writes.
212
- - **Decision:** Same database, two `@Mapper` packages — `mapper/` (write side,
213
- operates on core entities) and `readservice/` (read side, returns `*Data` DTOs).
214
- Read DTOs avoid entity hydration overhead.
215
- - **Consequences:** Reads are NOT routed through the domain port — this is
216
- intentional, not a bug. Application services may inject both a `*Repository`
217
- (writes) and one or more `*ReadService` interfaces (reads) at the same time.
218
- Do NOT add hydrate-then-map glue in the read path.
221
+ #### 2026-04-26 — Hexagonal ports & adapters with MyBatis-only persistence
222
+
223
+ - **Context:** `io.spring.core.*` exposes `*Repository` ports (e.g.,
224
+ `io.spring.core.article.ArticleRepository`) implemented by
225
+ `io.spring.infrastructure.repository.MyBatis*Repository` adapters.
226
+ The domain layer has zero `org.springframework.*` /
227
+ `org.apache.ibatis.*` / `io.spring.infrastructure.*` imports.
228
+ - **Options considered:** JPA/Hibernate, Spring Data, MyBatis-Plus
229
+ `BaseMapper`. None adopted.
230
+ - **Decision:** MyBatis 3 (`mybatis-spring-boot-starter:2.2.2`) with
231
+ hand-written XML statements under `src/main/resources/mapper/*.xml`.
232
+ Hexagonal port/adapter wiring keeps the domain framework-free.
233
+ - **Consequences:** Every SQL lives in XML — `@Select`/`@Insert`/`@Update`/`@Delete`
234
+ annotations are forbidden. New aggregates require both a
235
+ `core.{aggregate}.{Aggregate}Repository` port AND a
236
+ `MyBatis{Aggregate}Repository` adapter; introducing a JPA repository would
237
+ split the persistence model.
219
238
  ```
220
239
 
221
- Pass 4 `pass2-merged.json` से निकाले गए architectural निर्णयों के साथ `decision-log.md` को seed करता है ताकि भविष्य के sessions याद रखें कि codebase जैसा है _वैसा क्यों है_ — सिर्फ़ यह नहीं कि _कैसा दिखता है_।
240
+ Pass 4 `pass2-merged.json` से निकले architectural decisions को `decision-log.md` में पहले से भर देता है। इसका फायदा यह है कि अगले sessions में codebase जैसा दिख रहा है उसका *क्या* ही नहीं, *क्यों* भी याद रहता है। हर option ("JPA/Hibernate", "MyBatis-Plus") और हर consequence असली `build.gradle` dependency block पर ही टिका हुआ है।
222
241
 
223
242
  </details>
224
243
 
225
244
  ---
226
245
 
227
- ## Quick Start
246
+ ## परीक्षण किया गया
247
+
248
+ ClaudeOS-Core असली OSS projects पर लिए गए reference benchmarks के साथ ship होता है। अगर आपने इसे किसी public repo पर चलाया है, तो [issue खोल दीजिए](https://github.com/claudeos-core/claudeos-core/issues), हम इसे table में जोड़ देंगे।
249
+
250
+ | Project | Stack | Scanned → Generated | Status |
251
+ |---|---|---|---|
252
+ | [`spring-boot-realworld-example-app`](https://github.com/gothinkster/spring-boot-realworld-example-app) | Java 11 · Spring Boot 2.6 · MyBatis · SQLite | 187 → 75 files | ✅ सभी 5 validators pass |
253
+
254
+ ---
255
+
256
+ ## त्वरित शुरुआत
228
257
 
229
- **पूर्वापेक्षाएँ:** Node.js 18+, [Claude Code](https://docs.anthropic.com/en/docs/claude-code) इंस्टॉल और प्रमाणित।
258
+ **Prerequisites:** Node.js 18+, और [Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed व authenticated।
230
259
 
231
260
  ```bash
232
- # 1. अपने प्रोजेक्ट रूट पर जाएँ
261
+ # 1. अपने project root पर जाएँ
233
262
  cd my-spring-boot-project
234
263
 
235
- # 2. init चलाएँ (यह आपके कोड का विश्लेषण करता है और Claude से rules लिखने को कहता है)
264
+ # 2. init चलाएँ (यह code analyze करता है और Claude से rules लिखवाता है)
236
265
  npx claudeos-core init
237
266
 
238
- # 3. हो गया। Claude Code खोलें और कोडिंग शुरू करें — आपके rules पहले से लोड हैं।
267
+ # 3. हो गया। Claude Code खोलिए और काम शुरू कीजिए — rules पहले से loaded हैं।
239
268
  ```
240
269
 
241
- `init` समाप्त होने के बाद **आपको क्या मिलता है**:
270
+ `init` खत्म होने के बाद structure कुछ ऐसा दिखेगा।
242
271
 
243
272
  ```
244
273
  your-project/
245
274
  ├── .claude/
246
- │ └── rules/ ← Claude Code द्वारा स्वतः लोड
275
+ │ └── rules/ ← Claude Code इन्हें auto-load करता है
247
276
  │ ├── 00.core/ (सामान्य rules — naming, architecture)
248
- │ ├── 10.backend/ (backend stack rules, यदि लागू हो)
249
- │ ├── 20.frontend/ (frontend stack rules, यदि लागू हो)
250
- │ ├── 30.security-db/ (security & DB परिपाटियाँ)
277
+ │ ├── 10.backend/ (backend stack rules, अगर हैं तो)
278
+ │ ├── 20.frontend/ (frontend stack rules, अगर हैं तो)
279
+ │ ├── 30.security-db/ (security और DB conventions)
251
280
  │ ├── 40.infra/ (env, logging, CI/CD)
252
- │ ├── 50.sync/ (doc-sync रिमाइंडर — rules only)
253
- │ ├── 60.memory/ (memory rules — Pass 4, rules only)
281
+ │ ├── 50.sync/ (doc-sync reminders — सिर्फ rules में)
282
+ │ ├── 60.memory/ (memory rules — Pass 4, सिर्फ rules में)
254
283
  │ ├── 70.domains/{type}/ (per-domain rules, type = backend|frontend)
255
- │ └── 80.verification/ (testing strategy + build verification रिमाइंडर)
284
+ │ └── 80.verification/ (testing strategy और build verification reminders)
256
285
  ├── claudeos-core/
257
- │ ├── standard/ ← Reference docs (श्रेणी संरचना का दर्पण)
286
+ │ ├── standard/ ← Reference docs (वही category structure)
258
287
  │ │ ├── 00.core/ (project overview, architecture, naming)
259
- │ │ ├── 10.backend/ (backend reference — backend stack पर)
260
- │ │ ├── 20.frontend/ (frontend reference — frontend stack पर)
261
- │ │ ├── 30.security-db/ (security & DB reference)
288
+ │ │ ├── 10.backend/ (backend reference — backend stack हो तो)
289
+ │ │ ├── 20.frontend/ (frontend reference — frontend stack हो तो)
290
+ │ │ ├── 30.security-db/ (security और DB reference)
262
291
  │ │ ├── 40.infra/ (env / logging / CI-CD reference)
263
292
  │ │ ├── 70.domains/{type}/ (per-domain reference)
264
- │ │ ├── 80.verification/ (build / startup / testing reference — standard only)
265
- │ │ └── 90.optional/ (stack-specific extras — standard only)
266
- │ ├── skills/ (Claude द्वारा लागू किए जा सकने वाले पुनः-प्रयोग योग्य पैटर्न)
267
- │ ├── guide/ (सामान्य कार्यों के लिए how-to गाइड)
268
- │ ├── database/ (schema overview, migration गाइड)
269
- │ ├── mcp-guide/ (MCP integration नोट्स)
293
+ │ │ ├── 80.verification/ (build / startup / testing reference — सिर्फ standard में)
294
+ │ │ └── 90.optional/ (stack-specific extras — सिर्फ standard में)
295
+ │ ├── skills/ (reusable patterns जिन्हें Claude apply कर सकता है)
296
+ │ ├── guide/ (आम tasks के how-to guides)
297
+ │ ├── database/ (schema overview, migration guide)
298
+ │ ├── mcp-guide/ (MCP integration notes)
270
299
  │ └── memory/ (decision log, failure patterns, compaction)
271
- └── CLAUDE.md (वह index जिसे Claude सबसे पहले पढ़ता है)
300
+ └── CLAUDE.md (Claude सबसे पहले इसी index को पढ़ता है)
272
301
  ```
273
302
 
274
- `rules/` और `standard/` के बीच एक ही संख्या prefix साझा करने वाली श्रेणियाँ एक ही वैचारिक क्षेत्र को दर्शाती हैं (उदाहरण: `10.backend` rules ↔ `10.backend` standards)। केवल-rules श्रेणियाँ: `50.sync` (doc sync रिमाइंडर) और `60.memory` (Pass 4 memory)। केवल-standard श्रेणी: `90.optional` (बिना enforcement के stack-specific extras)। अन्य सभी prefix (`00`, `10`, `20`, `30`, `40`, `70`, `80`) `rules/` और `standard/` दोनों में दिखाई देते हैं। अब Claude Code आपका प्रोजेक्ट जानता है।
303
+ जिन categories का number prefix `rules/` और `standard/` दोनों में same है, वो एक ही area की हैं (जैसे `10.backend` rules ↔ `10.backend` standards)। सिर्फ rules में रहने वाली categories हैं `50.sync` (doc sync reminders) और `60.memory` (Pass 4 memory)। सिर्फ standard में रहने वाली एक है `90.optional` (बिना enforcement के stack-specific extras)। बाकी सारे prefixes (`00`, `10`, `20`, `30`, `40`, `70`, `80`) दोनों जगह मौजूद हैं। अब Claude Code आपके project को जानता है।
275
304
 
276
305
  ---
277
306
 
278
307
  ## यह किसके लिए है?
279
308
 
280
- | आप हैं... | यह आपकी मदद करता है... |
309
+ | आप कौन हैं... | यह जो pain हटाता है |
281
310
  |---|---|
282
- | **Claude Code के साथ नया प्रोजेक्ट शुरू करने वाले एकल डेवलपर** | "Claude को मेरी परिपाटियाँ सिखाने" का चरण पूरी तरह छोड़ देने में |
283
- | **साझा मानक बनाए रखने वाले team lead** | `.claude/rules/` को अद्यतन रखने के थकाऊ हिस्से को स्वचालित करने में |
284
- | **Claude Code का पहले से उपयोग करने वाले लेकिन उत्पन्न कोड को ठीक करते-करते थके हुए** | Claude को "सामान्य रूप से अच्छे" पैटर्न के बजाय आपके पैटर्न का पालन करवाने में |
311
+ | **Solo dev जो Claude Code से नया project शुरू कर रहा है** | "हर session में Claude को conventions फिर से सिखाओ" — यह झंझट खत्म। `CLAUDE.md` और 8-category `.claude/rules/` एक ही pass में बन जाते हैं। |
312
+ | **Team lead जो कई repos में shared standards maintain करता है** | जब लोग packages rename करते हैं, ORMs बदलते हैं, या response wrappers switch करते हैं, तब `.claude/rules/` drift करने लगते हैं। ClaudeOS-Core इन्हें deterministically फिर से sync कर देता है। Same input = byte-identical output, कोई diff noise नहीं। |
313
+ | **पहले से Claude Code use कर रहे हैं लेकिन generated code ठीक करते-करते थक चुके हैं** | गलत response wrapper, गलत package layout, MyBatis project में JPA code, centralized middleware के बावजूद बिखरा हुआ `try/catch` — यह सब scanner आपके असली conventions निकालकर रोकता है, और हर Claude pass एक explicit path allowlist पर ही चलता है। |
314
+ | **नए repo पर onboarding कर रहे हैं** (existing project, team join कर रहे हैं) | Repo पर `init` चलाइए, एक living architecture map मिल जाता है — CLAUDE.md में stack table, ✅/❌ examples के साथ per-layer rules, और बड़े decisions के पीछे "why" से seed किया हुआ decision log (JPA vs MyBatis, REST vs GraphQL, वगैरह)। 5 files पढ़ना 5,000 source files पढ़ने से कहीं तेज़ है। |
315
+ | **हिन्दी / कोरियाई / जापानी / चीनी समेत 7 अन्य भाषाओं में काम कर रहे हैं** | अधिकांश Claude Code rule generators सिर्फ English में लिखते हैं। ClaudeOS-Core पूरा set **10 भाषाओं** (`en/ko/ja/zh-CN/es/vi/hi/ru/fr/de`) में लिखता है, और structural validation **byte-identical** रहता है — output language कोई भी हो, `claude-md-validator` का verdict same रहता है। |
316
+ | **Monorepo पर काम कर रहे हैं** (Turborepo, pnpm/yarn workspaces, Lerna) | एक ही run में backend और frontend domains अलग-अलग prompts से analyze होते हैं। `apps/*/` और `packages/*/` खुद-ब-खुद walk हो जाते हैं, और per-stack rules `70.domains/{type}/` के नीचे emit होते हैं। |
317
+ | **OSS में contribute कर रहे हैं या experiment कर रहे हैं** | Output gitignore-friendly है। `claudeos-core/` आपकी local working dir है, और ship सिर्फ `CLAUDE.md` + `.claude/` को करना है। बीच में रुक जाए तो resume-safe, और re-runs पर idempotent — आपके manual edits बिना `--force` के बच जाते हैं। |
285
318
 
286
- **यदि उपयुक्त नहीं:** यदि आप scan चरण के बिना दिन एक से काम करने वाला agents/skills/rules का one-size-fits-all preset bundle चाहते हैं ([docs/hi/comparison.md](docs/hi/comparison.md) देखें कि क्या कहाँ फिट होता है), या आपका प्रोजेक्ट अभी [समर्थित stacks](#supported-stacks) में से किसी से मेल नहीं खाता।
319
+ **यह आपके लिए सही नहीं है अगर:** आपको एक one-size-fits-all preset bundle चाहिए जो scan step के बिना day one से काम करे (कौन सा tool कहाँ fit होता है, यह [docs/hi/comparison.md](docs/hi/comparison.md) में है), या आपका project अभी [supported stacks](#supported-stacks) में से किसी में नहीं आता, या फिर आपको सिर्फ एक `CLAUDE.md` चाहिए। उस case में built-in `claude /init` ही काफी है, अलग tool install करने की जरूरत नहीं।
287
320
 
288
321
  ---
289
322
 
290
323
  ## यह कैसे काम करता है?
291
324
 
292
- ClaudeOS-Core सामान्य Claude Code workflow को उलट देता है:
325
+ ClaudeOS-Core typical Claude Code workflow को उल्टा करके चलाता है।
293
326
 
294
327
  ```
295
- सामान्य: आप प्रोजेक्ट का वर्णन करते हैं → Claude आपके stack का अनुमान लगाता है → Claude docs लिखता है
296
- यह: कोड आपके stack को पढ़ता है → कोड पुष्ट तथ्य Claude को देता है → Claude तथ्यों से docs लिखता है
328
+ सामान्य: आप project describe करते हैं → Claude आपके stack का अंदाज़ा लगाता है → Claude docs लिखता है
329
+ यह: Code आपके stack को पढ़ता है → Code confirmed facts Claude को देता है → Claude उन्हीं facts से docs लिखता है
297
330
  ```
298
331
 
299
- मूल विचार: **Node.js scanner पहले आपके स्रोत कोड को पढ़ता है** (deterministic, कोई AI नहीं), फिर 4-pass Claude पाइपलाइन दस्तावेज़ लिखती है, scanner ने जो पाया है उसके द्वारा सीमित। Claude ऐसे paths या frameworks का आविष्कार नहीं कर सकता जो वास्तव में आपके कोड में नहीं हैं।
332
+ Pipeline **तीन stages** में चलती है, और LLM call के दोनों तरफ code रहता है।
333
+
334
+ **1. Step A — Scanner (deterministic, कोई LLM नहीं)।** एक Node.js scanner project root को walk करता है, `package.json` / `build.gradle` / `pom.xml` / `pyproject.toml` पढ़ता है, `.env*` files parse करता है (`PASSWORD/SECRET/TOKEN/JWT_SECRET/...` जैसी sensitive variables को redact करते हुए), architecture pattern classify करता है (Java के 5 patterns A/B/C/D/E, Kotlin CQRS / multi-module, Next.js App vs Pages Router, FSD, components-pattern), domains discover करता है, और मौजूदा हर source file path का explicit allowlist बनाता है। इसका output है `project-analysis.json`, जो आगे की हर चीज़ के लिए single source of truth बन जाता है।
335
+
336
+ **2. Step B — 4-Pass Claude pipeline (Step A के facts के दायरे में)।**
337
+ - **Pass 1** हर domain group के representative files पढ़ता है और प्रति domain करीब 50–100 conventions निकालता है — response wrappers, logging libraries, error handling, naming conventions, test patterns वगैरह। यह domain group पर एक बार चलता है (`max 4 domains, 40 files per group`), इसलिए context कभी overflow नहीं होता।
338
+ - **Pass 2** सारे per-domain analysis को project-wide picture में merge कर देता है, और जहाँ disagreement हो वहाँ dominant convention चुन लेता है।
339
+ - **Pass 3** `CLAUDE.md`, `.claude/rules/`, `claudeos-core/standard/`, skills और guides लिखता है। यह stages में split होता है (`3a` facts → `3b-core/3b-N` rules+standards → `3c-core/3c-N` skills+guides → `3d-aux` database+mcp-guide), जिससे `pass2-merged.json` बड़ा होने पर भी हर stage का prompt LLM के context window में आ जाता है। 16 या उससे ज्यादा domains वाले projects के लिए 3b/3c को ≤15-domain batches में sub-divide कर दिया जाता है।
340
+ - **Pass 4** L4 memory layer को seed करता है (`decision-log.md`, `failure-patterns.md`, `compaction.md`, `auto-rule-update.md`) और कुछ universal scaffold rules जोड़ता है। Pass 4 को **`CLAUDE.md` modify करने की इजाज़त नहीं है** — Pass 3 का Section 8 ही authoritative है।
341
+
342
+ **3. Step C — Verification (deterministic, कोई LLM नहीं)।** पाँच validators output check करते हैं:
343
+ - `claude-md-validator` — `CLAUDE.md` पर 25 structural checks (8 sections, H3/H4 counts, memory file uniqueness, T1 canonical heading invariant)। यह language-invariant है, यानी `--lang` कोई भी हो, verdict same रहता है।
344
+ - `content-validator` — 10 content checks, जिनमें path-claim verification (`STALE_PATH` invented `src/...` references पकड़ता है) और MANIFEST drift detection शामिल हैं।
345
+ - `pass-json-validator` — Pass 1/2/3/4 की JSON well-formedness और stack-aware section count check।
346
+ - `plan-validator` — plan ↔ disk consistency (legacy, v2.1.0 के बाद से ज़्यादातर no-op)।
347
+ - `sync-checker` — 7 tracked dirs पर disk ↔ `sync-map.json` registration consistency।
348
+
349
+ तीन severity tiers (`fail` / `warn` / `advisory`) रखे गए हैं, ताकि जिन LLM hallucinations को user खुद ठीक कर सकता है, उनकी वजह से CI deadlock न हो जाए।
300
350
 
301
- पूर्ण architecture के लिए, [docs/hi/architecture.md](docs/hi/architecture.md) देखें।
351
+ पूरी चीज़ एक invariant पर टिकी है: **Claude वही paths cite कर सकता है जो आपके code में असल में मौजूद हैं**, क्योंकि Step A उसे एक finite allowlist देता है। फिर भी अगर LLM कुछ invent करने की कोशिश करे (कुछ खास seeds पर rare है, मगर होता है), तो Step C docs ship होने से पहले उसे पकड़ लेता है।
352
+
353
+ हर pass के internals, marker-based resume, Claude Code के `.claude/` sensitive-path block का staged-rules workaround और stack detection की अंदरूनी logic के लिए [docs/hi/architecture.md](docs/hi/architecture.md) देखें।
302
354
 
303
355
  ---
304
356
 
305
357
  ## Supported Stacks
306
358
 
307
- 12 stacks, आपकी प्रोजेक्ट फ़ाइलों से स्वतः पहचाने जाते हैं:
359
+ 12 stacks, project files से auto-detected।
308
360
 
309
361
  **Backend:** Java/Spring Boot · Kotlin/Spring Boot · Node/Express · Node/Fastify · Node/NestJS · Python/Django · Python/FastAPI · Python/Flask
310
362
 
311
363
  **Frontend:** Node/Next.js · Node/Vite · Angular · Vue/Nuxt
312
364
 
313
- मल्टी-stack प्रोजेक्ट (उदाहरण: Spring Boot backend + Next.js frontend) सीधे काम करते हैं।
365
+ Multi-stack projects (जैसे Spring Boot backend + Next.js frontend) भी out of the box चलते हैं।
314
366
 
315
- पहचान नियमों और प्रत्येक scanner क्या निकालता है, के लिए [docs/hi/stacks.md](docs/hi/stacks.md) देखें।
367
+ Detection rules और हर scanner क्या निकालता है, यह [docs/hi/stacks.md](docs/hi/stacks.md) में है।
316
368
 
317
369
  ---
318
370
 
319
- ## दैनिक Workflow
371
+ ## दैनिक वर्कफ़्लो
320
372
 
321
- तीन commands ~95% उपयोग को कवर करते हैं:
373
+ ये तीन commands ~95% use cases cover कर लेते हैं।
322
374
 
323
375
  ```bash
324
- # प्रोजेक्ट पर पहली बार
376
+ # Project पर पहली बार
325
377
  npx claudeos-core init
326
378
 
327
- # आपके द्वारा standards या rules मैन्युअल रूप से संपादित करने के बाद
379
+ # जब standards या rules manually edit किए हों
328
380
  npx claudeos-core lint
329
381
 
330
- # हेल्थ चेक (commit से पहले, या CI में चलाएँ)
382
+ # Health check (commit से पहले या CI में)
331
383
  npx claudeos-core health
332
384
  ```
333
385
 
334
- memory layer के रखरखाव के लिए दो और:
335
-
336
- ```bash
337
- # failure-patterns लॉग का compaction (समय-समय पर चलाएँ)
338
- npx claudeos-core memory compact
339
-
340
- # बार-बार होने वाले failure patterns को proposed rules में बढ़ाएँ
341
- npx claudeos-core memory propose-rules
342
- ```
343
-
344
- प्रत्येक command के पूर्ण options के लिए, [docs/hi/commands.md](docs/hi/commands.md) देखें।
386
+ हर command के पूरे options [docs/hi/commands.md](docs/hi/commands.md) में हैं। Memory layer commands (`memory compact`, `memory propose-rules`) नीचे [Memory Layer](#memory-layer-वैकल्पिक-दीर्घकालिक-प्रोजेक्ट्स-के-लिए) section में documented हैं।
345
387
 
346
388
  ---
347
389
 
348
- ## यह क्या अलग बनाता है
390
+ ## क्या इसे अलग बनाता है
349
391
 
350
- अधिकांश Claude Code documentation tools विवरण से उत्पन्न करते हैं (आप टूल को बताते हैं, टूल Claude को बताता है)। ClaudeOS-Core आपके वास्तविक स्रोत कोड से उत्पन्न करता है (टूल पढ़ता है, टूल Claude को बताता है क्या पुष्ट है, Claude केवल वही लिखता है जो पुष्ट है)।
392
+ ज़्यादातर Claude Code documentation tools description से generate करते हैं — आप tool को बताते हैं, tool Claude को बताता है। ClaudeOS-Core इसके बजाय आपके actual source code से generate करता है। Tool खुद code पढ़ता है, फिर Claude को बताता है कि क्या confirmed है, और Claude सिर्फ उतना ही लिखता है।
351
393
 
352
- तीन ठोस परिणाम:
394
+ इसके तीन ठोस नतीजे हैं।
353
395
 
354
- 1. **Deterministic stack detection.** एक ही प्रोजेक्ट + एक ही कोड = एक ही आउटपुट। "इस बार Claude ने अलग नतीजा दिया" नहीं।
355
- 2. **No invented paths.** Pass 3 prompt हर अनुमत स्रोत path को स्पष्ट रूप से सूचीबद्ध करता है; Claude ऐसे paths का उल्लेख नहीं कर सकता जो मौजूद नहीं हैं।
356
- 3. **Multi-stack aware.** Backend और frontend domains एक ही run में अलग-अलग analysis prompts का उपयोग करते हैं।
396
+ 1. **Deterministic stack detection.** Same project + same code = same output। "इस बार Claude थोड़ा अलग roll हो गया" वाली बात नहीं होती।
397
+ 2. **No invented paths.** Pass 3 prompt में हर allowed source path explicitly listed होता है, इसलिए Claude ऐसे paths cite ही नहीं कर सकता जो मौजूद नहीं हैं।
398
+ 3. **Multi-stack aware.** एक ही run में backend और frontend domains अलग-अलग analysis prompts use करते हैं।
357
399
 
358
- अन्य tools के साथ side-by-side scope तुलना के लिए, [docs/hi/comparison.md](docs/hi/comparison.md) देखें। तुलना **प्रत्येक टूल क्या करता है** के बारे में है, न कि **कौन बेहतर है** — अधिकांश पूरक हैं।
400
+ दूसरे tools के साथ side-by-side scope comparison के लिए [docs/hi/comparison.md](docs/hi/comparison.md) देखें। यह तुलना **हर tool क्या करता है** के बारे में है, **कौन सा बेहतर है** के बारे में नहीं — असल में ज़्यादातर एक-दूसरे के complementary हैं।
359
401
 
360
402
  ---
361
403
 
362
- ## Verification (post-generation)
404
+ ## सत्यापन (जनरेशन के बाद)
363
405
 
364
- Claude द्वारा docs लिखने के बाद, कोड उन्हें सत्यापित करता है। पाँच अलग-अलग validators:
406
+ Claude docs लिख चुकने के बाद उन्हें code verify करता है। पाँच अलग-अलग validators।
365
407
 
366
- | Validator | यह क्या जाँचता है | किसके द्वारा चलाया जाता है |
408
+ | Validator | क्या check करता है | किसके through चलता है |
367
409
  |---|---|---|
368
- | `claude-md-validator` | CLAUDE.md की संरचनात्मक अपरिवर्तनीयताएँ (8 sections, language-invariant) | `claudeos-core lint` |
369
- | `content-validator` | Path दावे वास्तव में मौजूद हैं; manifest स्थिरता | `health` (advisory) |
370
- | `pass-json-validator` | Pass 1 / 2 / 3 / 4 आउटपुट well-formed JSON हैं | `health` (warn) |
371
- | `plan-validator` | सहेजी गई plan disk से मेल खाती है | `health` (fail-on-error) |
372
- | `sync-checker` | Disk फ़ाइलें `sync-map.json` registrations से मेल खाती हैं (orphaned/unregistered detection) | `health` (fail-on-error) |
410
+ | `claude-md-validator` | CLAUDE.md structural invariants (8 sections, language-invariant) | `claudeos-core lint` |
411
+ | `content-validator` | Path claims सच में मौजूद हैं या नहीं; manifest consistency | `health` (advisory) |
412
+ | `pass-json-validator` | Pass 1 / 2 / 3 / 4 outputs well-formed JSON हैं या नहीं | `health` (warn) |
413
+ | `plan-validator` | Saved plan disk से match करता है या नहीं | `health` (fail-on-error) |
414
+ | `sync-checker` | Disk files `sync-map.json` registrations से match करते हैं (orphaned/unregistered detection) | `health` (fail-on-error) |
373
415
 
374
- `health-checker` चार runtime validators को तीन-tier severity (fail / warn / advisory) के साथ orchestrate करता है और CI के लिए उपयुक्त code के साथ exit होता है। `claude-md-validator` `lint` command के माध्यम से अलग चलता है क्योंकि संरचनात्मक drift एक re-init संकेत है, न कि soft warning। कभी भी चलाएँ:
416
+ `health-checker` इन चारों runtime validators को three-tier severity (fail / warn / advisory) के साथ orchestrate करता है और CI के लिए सही exit code लौटाता है। `claude-md-validator` अलग से `lint` command से चलता है, क्योंकि structural drift सिर्फ soft warning नहीं, re-init का signal है। जब मन हो, चला लीजिए।
375
417
 
376
418
  ```bash
377
419
  npx claudeos-core health
378
420
  ```
379
421
 
380
- प्रत्येक validator के विस्तृत checks के लिए, [docs/hi/verification.md](docs/hi/verification.md) देखें।
422
+ हर validator के individual checks [docs/hi/verification.md](docs/hi/verification.md) में detail से दिए हैं।
381
423
 
382
424
  ---
383
425
 
384
- ## Memory Layer (वैकल्पिक, लंबे चलने वाले प्रोजेक्ट के लिए)
426
+ ## Memory Layer (वैकल्पिक, दीर्घकालिक प्रोजेक्ट्स के लिए)
385
427
 
386
- v2.0 के बाद, ClaudeOS-Core चार फ़ाइलों के साथ एक `claudeos-core/memory/` फ़ोल्डर लिखता है:
428
+ ऊपर वाली scaffolding pipeline के अलावा, ClaudeOS-Core उन projects के लिए एक `claudeos-core/memory/` folder भी seed करता है जिनका context एक session से ज़्यादा खिंचता है। यह वैकल्पिक है — अगर आपको सिर्फ `CLAUDE.md` और rules चाहिए तो इसे ignore कर सकते हैं।
387
429
 
388
- - `decision-log.md` — append-only "हमने X के बजाय Y क्यों चुना"
389
- - `failure-patterns.md` — frequency/importance स्कोर के साथ बार-बार होने वाली त्रुटियाँ
390
- - `compaction.md` — समय के साथ memory को कैसे auto-compact किया जाता है
391
- - `auto-rule-update.md` — पैटर्न जो नए rules बनने चाहिए
430
+ चार files हैं, और सब Pass 4 लिखता है।
392
431
 
393
- आप `npx claudeos-core memory propose-rules` चलाकर Claude से हाल के failure patterns देखने और जोड़ने के लिए नए rules सुझाने को कह सकते हैं।
432
+ - `decision-log.md` — append-only "हमने X की जगह Y क्यों चुना", `pass2-merged.json` से seed होता है
433
+ - `failure-patterns.md` — frequency / importance scores के साथ बार-बार आने वाली errors
434
+ - `compaction.md` — समय के साथ memory कैसे auto-compact होती है
435
+ - `auto-rule-update.md` — वो patterns जिन्हें नए rules बनना चाहिए
394
436
 
395
- memory model और lifecycle के लिए, [docs/hi/memory-layer.md](docs/hi/memory-layer.md) देखें।
437
+ इस layer को समय के साथ maintain करने के लिए दो commands हैं।
438
+
439
+ ```bash
440
+ # Failure-patterns log compact करें (समय-समय पर चलाएँ)
441
+ npx claudeos-core memory compact
442
+
443
+ # बार-बार आने वाले failure patterns को proposed rules में promote करें
444
+ npx claudeos-core memory propose-rules
445
+ ```
446
+
447
+ Memory model और lifecycle की पूरी बात [docs/hi/memory-layer.md](docs/hi/memory-layer.md) में है।
396
448
 
397
449
  ---
398
450
 
399
451
  ## FAQ
400
452
 
401
- **Q: क्या मुझे Claude API key की ज़रूरत है?**
402
- A: नहीं। ClaudeOS-Core आपके मौजूदा Claude Code installation का उपयोग करता है — यह आपकी मशीन पर `claude -p` को prompts pipe करता है। कोई अतिरिक्त खाते नहीं।
453
+ **Q: क्या Claude API key चाहिए?**
454
+ A: नहीं। ClaudeOS-Core आपके पहले से installed Claude Code को ही use करता है और आपकी machine पर `claude -p` को prompts pipe करता है। कोई extra account नहीं चाहिए।
403
455
 
404
- **Q: क्या यह मेरी मौजूदा CLAUDE.md या `.claude/rules/` को overwrite करेगा?**
405
- A: नए प्रोजेक्ट पर पहली run: यह उन्हें बनाता है। `--force` के बिना पुनः चलाने पर आपके edits सुरक्षित रहते हैं — पिछली run के pass markers का पता लगाया जाता है और passes छोड़ दिए जाते हैं। `--force` के साथ पुनः चलाने पर सब कुछ wipe और regenerate होता है (आपके edits खो जाते हैं — `--force` का यही मतलब है)। [docs/hi/safety.md](docs/hi/safety.md) देखें।
456
+ **Q: क्या यह मेरी मौजूदा CLAUDE.md या `.claude/rules/` overwrite कर देगा?**
457
+ A: नए project पर पहली run में यह इन्हें create करता है। `--force` के बिना दोबारा चलाने पर आपके edits बच जाते हैं, क्योंकि पिछली run के pass markers detect होकर वो passes skip हो जाते हैं। `--force` के साथ चलाने पर सब wipe होकर regenerate होता है, यानी edits भी चले जाते हैं — `--force` का मतलब ही यही है। ज़्यादा detail [docs/hi/safety.md](docs/hi/safety.md) में।
406
458
 
407
- **Q: मेरा stack समर्थित नहीं है। क्या मैं एक जोड़ सकता हूँ?**
408
- A: हाँ। नए stacks को ~3 prompt templates + एक domain scanner चाहिए। 8-step गाइड के लिए [CONTRIBUTING.md](CONTRIBUTING.md) देखें।
459
+ **Q: मेरा stack supported नहीं है, क्या जोड़ सकते हैं?**
460
+ A: हाँ। नए stack के लिए करीब 3 prompt templates और एक domain scanner चाहिए। 8-step guide के लिए [CONTRIBUTING.md](CONTRIBUTING.md) देखें।
409
461
 
410
- **Q: मैं Korean (या अन्य भाषा) में docs कैसे उत्पन्न करूँ?**
411
- A: `npx claudeos-core init --lang ko`. 10 भाषाएँ समर्थित: en, ko, ja, zh-CN, es, vi, hi, ru, fr, de.
462
+ **Q: कोरियाई (या किसी और भाषा) में docs कैसे generate करूँ?**
463
+ A: `npx claudeos-core init --lang ko`। 10 भाषाएँ supported हैं: en, ko, ja, zh-CN, es, vi, hi, ru, fr, de।
412
464
 
413
465
  **Q: क्या यह monorepos के साथ काम करता है?**
414
- A: हाँ — Turborepo (`turbo.json`), pnpm workspaces (`pnpm-workspace.yaml`), Lerna (`lerna.json`), और npm/yarn workspaces (`package.json#workspaces`) stack-detector द्वारा पहचाने जाते हैं। प्रत्येक app को अपना analysis मिलता है। अन्य monorepo layouts (उदा., NX) विशेष रूप से नहीं पहचाने जाते, लेकिन सामान्य `apps/*/` और `packages/*/` patterns प्रति-stack scanners द्वारा अभी भी उठाए जाते हैं।
466
+ A: हाँ। Turborepo (`turbo.json`), pnpm workspaces (`pnpm-workspace.yaml`), Lerna (`lerna.json`) और npm/yarn workspaces (`package.json#workspaces`) — इन्हें stack-detector पहचान लेता है, और हर app के लिए अलग analysis होता है। बाकी monorepo layouts (जैसे NX) explicitly detect नहीं होते, मगर generic `apps/*/` और `packages/*/` patterns per-stack scanners फिर भी pick कर लेते हैं।
467
+
468
+ **Q: अगर Claude Code ऐसे rules generate कर दे जिनसे मैं असहमत हूँ?**
469
+ A: सीधे edit कर दीजिए। उसके बाद `npx claudeos-core lint` चलाकर check कर लीजिए कि CLAUDE.md अभी भी structurally valid है या नहीं। आगे की `init` runs पर (बिना `--force` के) आपके edits बच जाते हैं, क्योंकि resume mechanism उन passes को skip करता है जिनके markers मौजूद हैं।
470
+
471
+ **Q: Bugs कहाँ report करूँ?**
472
+ A: [GitHub Issues](https://github.com/claudeos-core/claudeos-core/issues) पर। Security issues के लिए [SECURITY.md](SECURITY.md) देखें।
473
+
474
+ ---
415
475
 
416
- **Q: यदि Claude Code ऐसे rules उत्पन्न करता है जिनसे मैं असहमत हूँ?**
417
- A: उन्हें सीधे संपादित करें। फिर यह पुष्टि करने के लिए `npx claudeos-core lint` चलाएँ कि CLAUDE.md अभी भी संरचनात्मक रूप से वैध है। आपके edits बाद की `init` runs पर सुरक्षित रहते हैं (`--force` के बिना) — resume तंत्र उन passes को छोड़ देता है जिनके markers मौजूद हैं।
476
+ ## यदि इसने आपका समय बचाया
418
477
 
419
- **Q: मैं bugs कहाँ रिपोर्ट करूँ?**
420
- A: [GitHub Issues](https://github.com/claudeos-core/claudeos-core/issues)। सुरक्षा मुद्दों के लिए [SECURITY.md](SECURITY.md) देखें।
478
+ GitHub पर एक ⭐ project को visible रखता है और दूसरों को भी इसे ढूँढने में मदद करता है। Issues, PRs और stack template contributions — सबका स्वागत है। Detail के लिए [CONTRIBUTING.md](CONTRIBUTING.md) देखें।
421
479
 
422
480
  ---
423
481
 
424
- ## Documentation
482
+ ## दस्तावेज़ीकरण
425
483
 
426
484
  | विषय | यह पढ़ें |
427
485
  |---|---|
428
- | 4-pass पाइपलाइन कैसे काम करती है (diagram से अधिक गहरा) | [docs/hi/architecture.md](docs/hi/architecture.md) |
429
- | Architecture के दृश्य diagrams (Mermaid) | [docs/hi/diagrams.md](docs/hi/diagrams.md) |
430
- | Stack detection — प्रत्येक scanner क्या देखता है | [docs/hi/stacks.md](docs/hi/stacks.md) |
486
+ | 4-pass pipeline कैसे काम करती है (diagram से ज़्यादा गहराई से) | [docs/hi/architecture.md](docs/hi/architecture.md) |
487
+ | Architecture के visual diagrams (Mermaid) | [docs/hi/diagrams.md](docs/hi/diagrams.md) |
488
+ | Stack detection — हर scanner क्या देखता है | [docs/hi/stacks.md](docs/hi/stacks.md) |
431
489
  | Memory layer — decision logs और failure patterns | [docs/hi/memory-layer.md](docs/hi/memory-layer.md) |
432
- | सभी 5 validators विस्तार से | [docs/hi/verification.md](docs/hi/verification.md) |
490
+ | पाँचों validators detail में | [docs/hi/verification.md](docs/hi/verification.md) |
433
491
  | हर CLI command और option | [docs/hi/commands.md](docs/hi/commands.md) |
434
- | मैन्युअल installation (बिना `npx` के) | [docs/hi/manual-installation.md](docs/hi/manual-installation.md) |
492
+ | Manual installation (बिना `npx` के) | [docs/hi/manual-installation.md](docs/hi/manual-installation.md) |
435
493
  | Scanner overrides — `.claudeos-scan.json` | [docs/hi/advanced-config.md](docs/hi/advanced-config.md) |
436
- | सुरक्षा: re-init पर क्या सुरक्षित रहता है | [docs/hi/safety.md](docs/hi/safety.md) |
437
- | समान tools के साथ तुलना (scope, गुणवत्ता नहीं) | [docs/hi/comparison.md](docs/hi/comparison.md) |
438
- | त्रुटियाँ और रिकवरी | [docs/hi/troubleshooting.md](docs/hi/troubleshooting.md) |
494
+ | Safety: re-init पर क्या-क्या preserved रहता है | [docs/hi/safety.md](docs/hi/safety.md) |
495
+ | Similar tools के साथ तुलना (scope, quality नहीं) | [docs/hi/comparison.md](docs/hi/comparison.md) |
496
+ | Errors और recovery | [docs/hi/troubleshooting.md](docs/hi/troubleshooting.md) |
439
497
 
440
498
  ---
441
499
 
442
500
  ## योगदान
443
501
 
444
- योगदान का स्वागत है — stack समर्थन जोड़ना, prompts बेहतर बनाना, bugs ठीक करना। [CONTRIBUTING.md](CONTRIBUTING.md) देखें।
502
+ Contributions का स्वागत है — stack support जोड़ना, prompts सुधारना, bugs ठीक करना, सब कुछ। Detail के लिए [CONTRIBUTING.md](CONTRIBUTING.md) देखें।
445
503
 
446
- Code of Conduct और सुरक्षा नीति के लिए, [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) और [SECURITY.md](SECURITY.md) देखें।
504
+ Code of Conduct और security policy [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) और [SECURITY.md](SECURITY.md) में हैं।
447
505
 
448
- ## License
506
+ ## लाइसेंस
449
507
 
450
- [ISC](LICENSE) — किसी भी उपयोग के लिए मुफ़्त, व्यावसायिक सहित।
508
+ [ISC License](LICENSE)। Commercial use सहित किसी भी काम के लिए free है। © 2025–2026 ClaudeOS-Core contributors।
451
509
 
452
510
  ---
453
511
 
454
- <sub>[@claudeos-core](https://github.com/claudeos-core) द्वारा सावधानी से निर्मित। यदि इसने आपका समय बचाया है, GitHub पर एक ⭐ इसे दृश्यमान बनाए रखता है।</sub>
512
+ <sub>[claudeos-core](https://github.com/claudeos-core) team द्वारा maintained। Issues और PRs <https://github.com/claudeos-core/claudeos-core> पर भेजें।</sub>