# 🗜️ Prompt Compression Guide — OmniRoute (ଓଡ଼ିଆ)

🌐 **Languages:** 🇺🇸 [English](../../../../compression/COMPRESSION_GUIDE.md) · 🇪🇹 [am](../../../am/docs/compression/COMPRESSION_GUIDE.md) · 🇸🇦 [ar](../../../ar/docs/compression/COMPRESSION_GUIDE.md) · 🇦🇿 [az](../../../az/docs/compression/COMPRESSION_GUIDE.md) · 🇧🇬 [bg](../../../bg/docs/compression/COMPRESSION_GUIDE.md) · 🇧🇩 [bn](../../../bn/docs/compression/COMPRESSION_GUIDE.md) · 🇧🇦 [bs](../../../bs/docs/compression/COMPRESSION_GUIDE.md) · 🇨🇿 [cs](../../../cs/docs/compression/COMPRESSION_GUIDE.md) · 🇩🇰 [da](../../../da/docs/compression/COMPRESSION_GUIDE.md) · 🇩🇪 [de](../../../de/docs/compression/COMPRESSION_GUIDE.md) · 🇬🇷 [el](../../../el/docs/compression/COMPRESSION_GUIDE.md) · 🇪🇸 [es](../../../es/docs/compression/COMPRESSION_GUIDE.md) · 🇪🇪 [et](../../../et/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇷 [fa](../../../fa/docs/compression/COMPRESSION_GUIDE.md) · 🇫🇮 [fi](../../../fi/docs/compression/COMPRESSION_GUIDE.md) · 🇫🇷 [fr](../../../fr/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇪 [ga](../../../ga/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇳 [gu](../../../gu/docs/compression/COMPRESSION_GUIDE.md) · 🇳🇬 [ha](../../../ha/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇱 [he](../../../he/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇳 [hi](../../../hi/docs/compression/COMPRESSION_GUIDE.md) · 🇭🇷 [hr](../../../hr/docs/compression/COMPRESSION_GUIDE.md) · 🇭🇺 [hu](../../../hu/docs/compression/COMPRESSION_GUIDE.md) · 🇦🇲 [hy](../../../hy/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇩 [id](../../../id/docs/compression/COMPRESSION_GUIDE.md) · 🇳🇬 [ig](../../../ig/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇹 [it](../../../it/docs/compression/COMPRESSION_GUIDE.md) · 🇯🇵 [ja](../../../ja/docs/compression/COMPRESSION_GUIDE.md) · 🇬🇪 [ka](../../../ka/docs/compression/COMPRESSION_GUIDE.md) · 🇰🇭 [km](../../../km/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇳 [kn](../../../kn/docs/compression/COMPRESSION_GUIDE.md) · 🇰🇷 [ko](../../../ko/docs/compression/COMPRESSION_GUIDE.md) · 🇱🇹 [lt](../../../lt/docs/compression/COMPRESSION_GUIDE.md) · 🇱🇻 [lv](../../../lv/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇳 [ml](../../../ml/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇳 [mr](../../../mr/docs/compression/COMPRESSION_GUIDE.md) · 🇲🇾 [ms](../../../ms/docs/compression/COMPRESSION_GUIDE.md) · 🇲🇹 [mt](../../../mt/docs/compression/COMPRESSION_GUIDE.md) · 🇲🇲 [my](../../../my/docs/compression/COMPRESSION_GUIDE.md) · 🇳🇵 [ne](../../../ne/docs/compression/COMPRESSION_GUIDE.md) · 🇳🇱 [nl](../../../nl/docs/compression/COMPRESSION_GUIDE.md) · 🇳🇴 [no](../../../no/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇳 [pa](../../../pa/docs/compression/COMPRESSION_GUIDE.md) · 🇵🇭 [phi](../../../phi/docs/compression/COMPRESSION_GUIDE.md) · 🇵🇱 [pl](../../../pl/docs/compression/COMPRESSION_GUIDE.md) · 🇵🇹 [pt](../../../pt/docs/compression/COMPRESSION_GUIDE.md) · 🇧🇷 [pt-BR](../../../pt-BR/docs/compression/COMPRESSION_GUIDE.md) · 🇷🇴 [ro](../../../ro/docs/compression/COMPRESSION_GUIDE.md) · 🇷🇺 [ru](../../../ru/docs/compression/COMPRESSION_GUIDE.md) · 🇱🇰 [si](../../../si/docs/compression/COMPRESSION_GUIDE.md) · 🇸🇰 [sk](../../../sk/docs/compression/COMPRESSION_GUIDE.md) · 🇸🇮 [sl](../../../sl/docs/compression/COMPRESSION_GUIDE.md) · 🇷🇸 [sr](../../../sr/docs/compression/COMPRESSION_GUIDE.md) · 🇸🇪 [sv](../../../sv/docs/compression/COMPRESSION_GUIDE.md) · 🇰🇪 [sw](../../../sw/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇳 [ta](../../../ta/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇳 [te](../../../te/docs/compression/COMPRESSION_GUIDE.md) · 🇹🇭 [th](../../../th/docs/compression/COMPRESSION_GUIDE.md) · 🇹🇷 [tr](../../../tr/docs/compression/COMPRESSION_GUIDE.md) · 🇺🇦 [uk-UA](../../../uk-UA/docs/compression/COMPRESSION_GUIDE.md) · 🇵🇰 [ur](../../../ur/docs/compression/COMPRESSION_GUIDE.md) · 🇺🇿 [uz](../../../uz/docs/compression/COMPRESSION_GUIDE.md) · 🇻🇳 [vi](../../../vi/docs/compression/COMPRESSION_GUIDE.md) · 🇳🇬 [yo](../../../yo/docs/compression/COMPRESSION_GUIDE.md) · 🇨🇳 [zh-CN](../../../zh-CN/docs/compression/COMPRESSION_GUIDE.md) · 🇹🇼 [zh-TW](../../../zh-TW/docs/compression/COMPRESSION_GUIDE.md)

---

> ଯୋଗ୍ୟ କଣ୍ଟେକ୍ସ୍ଟରେ ସ୍ୱୟଂଚାଳିତ ଭାବେ 15-95% ସଞ୍ଚୟ କରନ୍ତୁ। ଏକ ଦ୍ରୁତ ସାରାଂଶ ପାଇଁ [README କମ୍ପ୍ରେସନ୍ ବିଭାଗ](../README.md#%EF%B8%8F-prompt-compression--save-15-95-eligible-tokens-automatically) ଦେଖନ୍ତୁ।

## ସାରାଂଶ

OmniRoute ଏକ ମଡ୍ୟୁଲାର୍ ପ୍ରମ୍ପ୍ଟ କମ୍ପ୍ରେସନ୍ ପାଇପ୍ଲାଇନ୍ କାର୍ଯ୍ୟକାରୀ କରେ, ଯାହା ଅନୁରୋଧଗୁଡ଼ିକ ଅପ୍ଷ୍ଟ୍ରିମ୍ ପ୍ରଦାନକାରୀଙ୍କ ପାଖରେ ପହଞ୍ଚିବା ପୂର୍ବରୁ **ସକ୍ରିୟ ଭାବେ** ଚାଲେ। ଏହାର ଅର୍ଥ ଆପଣଙ୍କ ଟୋକନ୍ ସଞ୍ଚୟ ସ୍ୱଚ୍ଛ ଭାବେ ହୁଏ — ଆପଣଙ୍କ କାର୍ଯ୍ୟପ୍ରବାହରେ କୌଣସି ପରିବର୍ତ୍ତନ ଆବଶ୍ୟକ ନାହିଁ।

```
କ୍ଲାଏଣ୍ଟ ଅନୁରୋଧ
  → କମ୍ପ୍ରେସନ୍ କୌଶଳ ଚୟନକର୍ତ୍ତା
    → Combo ଓଭର୍ରାଇଡ୍? → Combo ସେଟିଂ ବ୍ୟବହାର କରନ୍ତୁ
    → ସ୍ୱୟଂଚାଳିତ-ଟ୍ରିଗର୍ ଥ୍ରେସ୍ହୋଲ୍ଡ? → ସ୍ୱୟଂଚାଳିତ ମୋଡ୍ ବ୍ୟବହାର କରନ୍ତୁ
    → ଡିଫଲ୍ଟ ମୋଡ୍? → ଗ୍ଲୋବାଲ୍ ସେଟିଂ ବ୍ୟବହାର କରନ୍ତୁ
    → ବନ୍ଦ? → କମ୍ପ୍ରେସନ୍ ଛାଡ଼ିଦିଅନ୍ତୁ
  → ଚୟନିତ କମ୍ପ୍ରେସନ୍ ମୋଡ୍
    → ବନ୍ଦ: କୌଣସି କମ୍ପ୍ରେସନ୍ ନାହିଁ
    → ଲାଇଟ୍: ସୁରକ୍ଷିତ ହ୍ୱାଇଟ୍ସ୍ପେସ୍/ଫର୍ମାଟିଂ ସଫେଇ (~15%)
    → ଷ୍ଟାଣ୍ଡାର୍ଡ: Caveman-ଶୈଳୀର ଅନାବଶ୍ୟକ ଶବ୍ଦ ଅପସାରଣ (~30%)
    → ଆଗ୍ରେସିଭ୍: ଇତିହାସ ଏଜିଂ + ସାରାଂଶକରଣ (~50%)
    → ଅଲ୍ଟ୍ରା: ହ୍ୟୁରିଷ୍ଟିକ୍ ପ୍ରୁନିଂ + କୋଡ୍-ବ୍ଲକ୍ ଥିନିଂ (~75%)
    → RTK: କମାଣ୍ଡ-ସଚେତନ ଟର୍ମିନାଲ୍/ଟୁଲ୍-ଆଉଟ୍ପୁଟ୍ ଫିଲ୍ଟରିଂ (60-90% ଅପ୍ଷ୍ଟ୍ରିମ୍ ପରିସର)
    → ଷ୍ଟାକ୍ଡ୍: କ୍ରମବଦ୍ଧ ମଲ୍ଟି-ଇଞ୍ଜିନ୍ ପାଇପ୍ଲାଇନ୍, ସାଧାରଣତଃ ପ୍ରଥମେ RTK ଓ ପରେ Caveman (78-95% ଯୋଗ୍ୟ ପରିସର)
  → କମ୍ପ୍ରେସ୍ ହୋଇଥିବା ଅନୁରୋଧ → ପ୍ରଦାନକାରୀ
```

---

## କମ୍ପ୍ରେସନ୍ ମୋଡ୍ଗୁଡ଼ିକ

### ବନ୍ଦ

କୌଣସି କମ୍ପ୍ରେସନ୍ ପ୍ରୟୋଗ କରାଯାଏ ନାହିଁ। ସମସ୍ତ ସନ୍ଦେଶ ଅପରିବର୍ତ୍ତିତ ଭାବେ ପଠାଯାଏ।

### ଲାଇଟ୍ ମୋଡ୍ (~15% ସଞ୍ଚୟ, <1ms ବିଳମ୍ବ)

ସବୁଠାରୁ ସୁରକ୍ଷିତ ମୋଡ୍ — ଶୂନ୍ୟ ଅର୍ଥଗତ ପରିବର୍ତ୍ତନ, କେବଳ ଫର୍ମାଟିଂ ସଫେଇ:

| ପ୍ରକ୍ରିୟା                | ବର୍ଣ୍ଣନା                                        |
| ------------------------ | ----------------------------------------------- |
| `collapseWhitespace`     | କ୍ରମାଗତ ଖାଲି ଧାଡ଼ି ଏବଂ ଶେଷର ସ୍ପେସ୍ଗୁଡ଼ିକୁ ମିଶାଏ |
| `dedupSystemPrompt`      | ନକଲ ସିଷ୍ଟମ୍ ସନ୍ଦେଶଗୁଡ଼ିକୁ ଅପସାରଣ କରେ            |
| `compressToolResults`    | ବିସ୍ତୃତ ଟୁଲ୍/ଫଙ୍କସନ୍ ଆଉଟ୍ପୁଟ୍କୁ କମ୍ପ୍ରେସ୍ କରେ   |
| `removeRedundantContent` | ପୁନରାବୃତ୍ତ ନିର୍ଦ୍ଦେଶଗୁଡ଼ିକୁ ଅପସାରଣ କରେ          |
| `replaceImageUrls`       | base64 ଇମେଜ୍ ଡାଟା URIଗୁଡ଼ିକୁ ସଂକ୍ଷିପ୍ତ କରେ      |

**ଏହା ପାଇଁ ସର୍ବୋତ୍ତମ:** ସର୍ବଦା-ସକ୍ରିୟ ବ୍ୟବହାର, ସୁରକ୍ଷା-ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ କାର୍ଯ୍ୟପ୍ରବାହ।

### ଷ୍ଟାଣ୍ଡାର୍ଡ ମୋଡ୍ (~30% ସଞ୍ଚୟ)

[Caveman](https://github.com/JuliusBrussee/caveman) ଦ୍ୱାରା ଅନୁପ୍ରାଣିତ — ଅର୍ଥକୁ ସଂରକ୍ଷିତ ରଖି ଅନାବଶ୍ୟକ ଶବ୍ଦ ଏବଂ ଅତ୍ୟଧିକ ବିସ୍ତୃତ ବାକ୍ୟାଂଶଗୁଡ଼ିକୁ ଅପସାରଣ କରେ:

- ଅନାବଶ୍ୟକ ଶବ୍ଦ ("ଦୟାକରି", "ମୋ ମତରେ", "ମୂଳତଃ", "ବାସ୍ତବରେ") ଅପସାରଣ କରେ
- ଅତ୍ୟଧିକ ବିସ୍ତୃତ ବାକ୍ୟାଂଶଗୁଡ଼ିକୁ ସଂକ୍ଷିପ୍ତ କରେ ("କରିବା ଉଦ୍ଦେଶ୍ୟରେ" → "କରିବାକୁ", "ଏହାର ପରିଣାମସ୍ୱରୂପ" → "କାରଣ")
- ବିନମ୍ର ଦ୍ୱିଧାସୂଚକ ବାକ୍ୟାଂଶକୁ ଅପସାରଣ କରେ ("ଆପଣ କ’ଣ ଦୟାକରି...", "ଯଦି ଆପଣ ସମ୍ଭବତଃ କରିପାରିବେ...")
- କୋଡିଂ ପ୍ରମ୍ପ୍ଟ ପାଇଁ ସଜାଯାଇଥିବା 30+ regex ନିୟମ

**ଏହା ପାଇଁ ସର୍ବୋତ୍ତମ:** ଦୈନିକ କୋଡିଂ କାର୍ଯ୍ୟପ୍ରବାହ, ଖର୍ଚ୍ଚ-ସଚେତନ ଟିମ୍।

### ଆଗ୍ରେସିଭ୍ ମୋଡ୍ (~50% ସଞ୍ଚୟ)

ଦୀର୍ଘ ସେସନ୍ ପାଇଁ ସ୍ମାର୍ଟ ଇତିହାସ ପରିଚାଳନା:

- **ସନ୍ଦେଶ ଏଜିଂ** — ପୁରୁଣା ସନ୍ଦେଶଗୁଡ଼ିକ କ୍ରମଶଃ ଅଧିକ କମ୍ପ୍ରେସ୍ ହୁଏ
- **ଟୁଲ୍ ଫଳାଫଳ କମ୍ପ୍ରେସନ୍** — ଦୀର୍ଘ ଟୁଲ୍ ଆଉଟ୍ପୁଟ୍ଗୁଡ଼ିକୁ କାଟି ଦିଆଯାଏ କିମ୍ବା ବାଦ୍ ଦିଆଯାଏ (ପ୍ରଥମ/ଶେଷ ଧାଡ଼ି,
  ମେଳ ଖାଉଥିବା ଧାଡ଼ିର ଫିଲ୍ଟରିଂ, JSON କୀ ସଂକ୍ଷିପ୍ତକରଣ)
- **ଗଠନାତ୍ମକ ଅଖଣ୍ଡତା ସୁରକ୍ଷା** — `tool_use` + `tool_result` ଯୁଗଳଗୁଡ଼ିକ ସୁସଙ୍ଗତ ରହିବା ସୁନିଶ୍ଚିତ କରେ
- **କଣ୍ଟେକ୍ସ୍ଟ ୱିଣ୍ଡୋ ସଚେତନତା** — ପ୍ରତ୍ୟେକ ମଡେଲ୍ର ଟୋକନ୍ ସୀମାକୁ ସମ୍ମାନ କରେ

**ଏହା ପାଇଁ ସର୍ବୋତ୍ତମ:** ଦୀର୍ଘ ଡିବଗିଂ ସେସନ୍, ବଡ଼ କୋଡ୍ବେସ୍।

### ଅଲ୍ଟ୍ରା ମୋଡ୍ (~75% ସଞ୍ଚୟ)

ଟୋକନ୍-ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ ପରିସ୍ଥିତି ପାଇଁ ସର୍ବାଧିକ କମ୍ପ୍ରେସନ୍:

- **ହ୍ୟୁରିଷ୍ଟିକ୍ ପ୍ରୁନିଂ** — ଗଦ୍ୟର ସ୍କୋର୍-ଆଧାରିତ ଟୋକନ୍ ପ୍ରୁନିଂ
- **ଗଠନ ସଂରକ୍ଷଣ** — ଫେନ୍ସ୍ଡ୍ କୋଡ୍ ବ୍ଲକ୍, ଇନ୍ଲାଇନ୍ କୋଡ୍, URL ଏବଂ ଆଇଡେଣ୍ଟିଫାୟର୍ଗୁଡ଼ିକୁ
  ଟୁମ୍ଷ୍ଟୋନ୍ କରି ଅବିକଳ ଭାବେ ପୁନଃ ସଂଯୋଜନ କରାଯାଏ, କେବେବି ପ୍ରୁନ୍ କରାଯାଏ ନାହିଁ
- **ଇଚ୍ଛାଧୀନ SLM ସ୍ତର** — କନ୍ଫିଗର୍ କରାଯାଇଥିଲେ ଏକ ଛୋଟ ଲୋକାଲ୍ ମଡେଲ୍ ପ୍ରୁନିଂକୁ ଅଧିକ ସୁଦୃଢ଼ କରିପାରେ
- ଆଗ୍ରେସିଭ୍ ମୋଡ୍ରୁ ସ୍ୱାଧୀନ: ଏହା ସନ୍ଦେଶ ଏଜିଂ, ଟୁଲ୍-ଫଳାଫଳ କମ୍ପ୍ରେସନ୍
  କିମ୍ବା ଫଲ୍ବ୍ୟାକ୍ ସାରାଂଶକର୍ତ୍ତାକୁ ଚଲାଏ ନାହିଁ (କେବଳ SLM-ସ୍ତରର ବିଫଳତା ଏକ ଫଲ୍ବ୍ୟାକ୍ ପାସ୍କୁ
  ଆଗ୍ରେସିଭ୍ ମାଧ୍ୟମରେ ରୁଟ୍ କରିପାରେ)

**ଏହା ପାଇଁ ସର୍ବୋତ୍ତମ:** ଯେତେବେଳେ ଆପଣ ବାରମ୍ବାର କଣ୍ଟେକ୍ସ୍ଟ ସୀମାରେ ପହଞ୍ଚୁଛନ୍ତି।

### RTK ମୋଡ୍ (60-90% ଅପ୍ଷ୍ଟ୍ରିମ୍ ପରିସର)

RTK ମୋଡ୍ କୋଡିଂ-ଏଜେଣ୍ଟ ସେସନ୍ରେ ଦେଖାଯାଉଥିବା ବିସ୍ତୃତ ଟୁଲ୍ ଆଉଟ୍ପୁଟ୍ ପାଇଁ ଅପ୍ଟିମାଇଜ୍ କରାଯାଇଛି:

- `git status`, `git diff`, `git log`, ଟେଷ୍ଟ ରନର୍,
  TypeScript/Vite/Webpack ବିଲ୍ଡ୍, ESLint/Biome/Prettier, npm ଅଡିଟ୍/ଇନ୍ଷ୍ଟଲ୍, Docker ଲଗ୍, ଇନ୍ଫ୍ରା
  ଆଉଟ୍ପୁଟ୍ ଏବଂ ସାଧାରଣ shell ଆଉଟ୍ପୁଟ୍ ପରି କମାଣ୍ଡ/ଆଉଟ୍ପୁଟ୍ ଶ୍ରେଣୀଗୁଡ଼ିକୁ ଚିହ୍ନଟ କରେ
- `open-sse/services/compression/engines/rtk/filters/` ରୁ JSON ଫିଲ୍ଟର୍ ପ୍ୟାକ୍ ପ୍ରୟୋଗ କରେ
- ପ୍ରୋଜେକ୍ଟ କିମ୍ବା ଗ୍ଲୋବାଲ୍ `filters.toml` ଫାଇଲ୍ଗୁଡ଼ିକରୁ RTK TOML ସ୍କିମା v1 ଫିଲ୍ଟର୍ ଇମ୍ପୋର୍ଟ କରେ, ଇନ୍ଲାଇନ୍-ଟେଷ୍ଟ
  ଭ୍ୟାଲିଡେସନ୍ ଏବଂ ପ୍ରୋଜେକ୍ଟ ଫାଇଲ୍ ପାଇଁ ଟ୍ରଷ୍ଟ-ଗେଟିଂ ସହିତ
- ଇନ୍ଲାଇନ୍ ଯାଞ୍ଚ ନମୁନା ସହିତ 55ଟି ବିଲ୍ଟ-ଇନ୍ ଫିଲ୍ଟର୍ ପ୍ରଦାନ କରେ
- ANSI କଣ୍ଟ୍ରୋଲ୍ ସିକ୍ୱେନ୍ସ, ପ୍ରଗତି ବାର୍, ପୁନରାବୃତ୍ତ ଧାଡ଼ି ଏବଂ କାର୍ଯ୍ୟାନୁଷ୍ଠାନ-ଅଯୋଗ୍ୟ ଅନାବଶ୍ୟକ ତଥ୍ୟକୁ ଅପସାରଣ କରେ
- ବିଫଳତା, ତ୍ରୁଟି, ଚେତାବନୀ, ପରିବର୍ତ୍ତିତ ଫାଇଲ୍, ସାରାଂଶ ଏବଂ ଦୀର୍ଘ ଆଉଟ୍ପୁଟ୍ର ଶେଷ ଭାଗକୁ ସଂରକ୍ଷଣ କରେ
- ଟ୍ରଷ୍ଟ-ଗେଟେଡ୍ ପ୍ରୋଜେକ୍ଟ ଫିଲ୍ଟର୍, ଗ୍ଲୋବାଲ୍ ଫିଲ୍ଟର୍ ଏବଂ ଇଚ୍ଛାଧୀନ ରିଡାକ୍ଟ ହୋଇଥିବା ର' ଆଉଟ୍ପୁଟ୍ ପୁନରୁଦ୍ଧାରକୁ ସମର୍ଥନ କରେ

**ଏହା ପାଇଁ ସର୍ବୋତ୍ତମ:** shell, ବିଲ୍ଡ୍, ଟେଷ୍ଟ, git, grep ଏବଂ ଫାଇଲ୍-ଆଉଟ୍ପୁଟ୍ ଟ୍ରାନ୍ସକ୍ରିପ୍ଟ ସହିତ ଏଜେଣ୍ଟ ସେସନ୍।

### ଷ୍ଟାକ୍ଡ୍ ମୋଡ୍ (78-95% ଯୋଗ୍ୟ ପରିସର)

ଷ୍ଟାକ୍ଡ୍ ମୋଡ୍ ଏକ ନିର୍ଦ୍ଧାରିତ କ୍ରମରେ ଏକାଧିକ କମ୍ପ୍ରେସନ୍ ଇଞ୍ଜିନ୍ ଚଲାଏ। ଡିଫଲ୍ଟ ପାଇପ୍ଲାଇନ୍ ହେଉଛି:

```txt
RTK -> Caveman
```

ଏହି କ୍ରମ ପ୍ରଥମେ ଟର୍ମିନାଲ୍/ଟୁଲ୍ ଆଉଟ୍ପୁଟ୍କୁ ସଂକ୍ଷିପ୍ତ ରଖେ, ତା’ପରେ ଅବଶିଷ୍ଟ ପ୍ରାକୃତିକ-ଭାଷା ପ୍ରମ୍ପ୍ଟରେ
Caveman ଅର୍ଥଗତ ସଂକ୍ଷିପ୍ତକରଣ ପ୍ରୟୋଗ କରେ। ଷ୍ଟାକ୍ଡ୍ ପାଇପ୍ଲାଇନ୍ଗୁଡ଼ିକୁ ଗ୍ଲୋବାଲ୍ ଭାବେ କିମ୍ବା ରାଉଟିଂ
କମ୍ବୋଗୁଡ଼ିକୁ ଆବଣ୍ଟିତ କମ୍ପ୍ରେସନ୍ କମ୍ବୋ ମାଧ୍ୟମରେ କନ୍ଫିଗର୍ କରାଯାଇପାରେ।

**ଏହା ପାଇଁ ସର୍ବୋତ୍ତମ:** ବଡ଼ ଟୁଲ୍ ଲଗ୍ ସହିତ ମାନବୀୟ ନିର୍ଦ୍ଦେଶ କିମ୍ବା ଆସିଷ୍ଟାଣ୍ଟ ସାରାଂଶ ଥିବା ମିଶ୍ରିତ କଣ୍ଟେକ୍ସ୍ଟ।

---

## ଅପ୍ଷ୍ଟ୍ରିମ୍ ସଞ୍ଚୟ ଗଣନା

OmniRoute ଦୁଇଟି ଉତ୍ସରୁ ମିଳୁଥିବା କମ୍ପ୍ରେସନ୍ ସଞ୍ଚୟକୁ ଡକ୍ୟୁମେଣ୍ଟ କରେ: ଅପ୍ଷ୍ଟ୍ରିମ୍ ପ୍ରୋଜେକ୍ଟ ବେଞ୍ଚମାର୍କ ଏବଂ
OmniRoute-ର ନିଜସ୍ୱ ଇଞ୍ଜିନ୍ ସଂଯୋଜନ।

| ଉତ୍ସ    | ଏଠାରେ ବ୍ୟବହୃତ ଅପ୍ଷ୍ଟ୍ରିମ୍ README ସଂଖ୍ୟା                                                                              |
| ------- | -------------------------------------------------------------------------------------------------------------------- |
| Caveman | `~75%` କମ୍ ଆଉଟପୁଟ୍ ଟୋକନ୍, `65%` ବେଞ୍ଚମାର୍କ ହାରାହାରି ଆଉଟପୁଟ୍ ସଞ୍ଚୟ, `22-87%` ପରିସର, ଏବଂ `~46%` ଇନପୁଟ୍ କମ୍ପ୍ରେସନ୍ ଟୁଲ୍ |
| RTK     | କମାଣ୍ଡ-ଆଉଟପୁଟ୍ରେ `60-90%` ସଞ୍ଚୟ; ନମୁନା ସେସନ୍ରେ `~118,000 -> ~23,900` ଟୋକନ୍, କିମ୍ବା `79.7%` ସଞ୍ଚୟ (`~80%`)            |

ପରସ୍ପରକୁ ଆବୃତ କରୁଥିବା ଟୁଲ୍/କଣ୍ଟେକ୍ସ୍ଟ ପେଲୋଡ୍ଗୁଡ଼ିକ ପାଇଁ, ଡିଫଲ୍ଟ OmniRoute କମ୍ବୋ ଇଞ୍ଜିନ୍ଗୁଡ଼ିକୁ କ୍ରମବଦ୍ଧ ଭାବେ ଯୋଡ଼େ:

```txt
RTK -> Caveman
```

ମିଳିତ ସଞ୍ଚୟ ଗୁଣାତ୍ମକ, ଯୋଗାତ୍ମକ ନୁହେଁ:

```txt
combined = 1 - (1 - RTK savings) * (1 - Caveman input savings)
average  = 1 - (1 - 0.80) * (1 - 0.46) = 89.2%
range    = 1 - (1 - 0.60..0.90) * (1 - 0.46) = 78.4-94.6%
```

ଯେତେବେଳେ RTK ଏବଂ Caveman ଉଭୟ ସମାନ ଇନପୁଟ୍/କଣ୍ଟେକ୍ସ୍ଟ ପେଲୋଡ୍କୁ ହ୍ରାସ କରିପାରନ୍ତି, ସେତେବେଳେ ସେହି `78-95%` ସଂଖ୍ୟା ପ୍ରଯୁଜ୍ୟ।
Caveman ରେସ୍ପନ୍ସ ଆଉଟପୁଟ୍ ମୋଡ୍ ପୃଥକ: ସକ୍ଷମ କରାଯାଇଥିଲେ, Caveman-ର ନିଜସ୍ୱ ଆଉଟପୁଟ୍ ସଞ୍ଚୟ (`65%`
ହାରାହାରି, `~75%` ମୁଖ୍ୟ ଆକଳନ, `22-87%` ପରିସର) ବ୍ୟବହାର କରନ୍ତୁ। ମୋଟ ବିଲିଂ ସଞ୍ଚୟ ଆପଣଙ୍କ ପ୍ରମ୍ପ୍ଟ/ଆଉଟପୁଟ୍ ମିଶ୍ରଣ ଉପରେ ନିର୍ଭର କରେ।

### "ଯୋଗ୍ୟ"ର ପ୍ରକୃତ ଅର୍ଥ କ’ଣ

15-95% ମୁଖ୍ୟ ପରିସରଟି ବାସ୍ତବ, କିନ୍ତୁ ଏହା କେବଳ **ଅନାବଶ୍ୟକ କିମ୍ବା ଅତ୍ୟଧିକ ବିସ୍ତୃତ** ବିଷୟବସ୍ତୁ ପାଇଁ ପ୍ରଯୁଜ୍ୟ — ପୁନରାବୃତ୍ତ
ତ୍ରୁଟି ଲାଇନ୍, ସମାନ ଚେତାବନୀକୁ ବାରମ୍ବାର ଦେଖାଉଥିବା ଏକ ବିଲ୍ଡ ଲଗ୍, ଏକ ଅତ୍ୟଧିକ ବଡ଼ `grep`/ଫାଇଲ୍-ରିଡ୍ ଡମ୍ପ୍। ଏହାର ଅର୍ଥ
**ଏହା ନୁହେଁ** ଯେ ପ୍ରତ୍ୟେକ ଅନୁରୋଧରେ ଏତେ ସଞ୍ଚୟ ହୁଏ।

ପ୍ରୟୋଗମୂଳକ ଭାବେ ଯାଞ୍ଚ କରାଯାଇଛି (`tests/unit/compression/stacked-compression-tool-result-savings.test.ts`): 300ଟି ସମାନ
ତ୍ରୁଟି ଲାଇନ୍ ଥିବା ଏକ Anthropic-ଆକୃତିର `tool_result` ବ୍ଲକ୍ରେ ଚାଲିଥିବା ଏକ `stacked` (RTK + Caveman)
ରନ୍ରେ **95.93% ଟୋକନ୍ ସଞ୍ଚୟ / 96.26% ଅକ୍ଷର ସଞ୍ଚୟ** ହୋଇଥିଲା — ଯାହା ବିଜ୍ଞାପିତ
ପରିସର ମଧ୍ୟରେ ସଠିକ୍ ଭାବେ ରହିଛି। କିନ୍ତୁ ସାଧାରଣ, ଅନାବଶ୍ୟକ ପୁନରାବୃତ୍ତି ନଥିବା ଟୁଲ୍ ଆଉଟପୁଟ୍ରେ (ଏକ ସ୍ୱଚ୍ଛ `grep` ମ୍ୟାଚ୍ ତାଲିକା,
ଏକ ଛୋଟ ଫାଇଲ୍ ରିଡ୍, ସାଧାରଣ କଥୋପକଥନମୂଳକ ପାଠ୍ୟ) ସମାନ ପାଇପ୍ଲାଇନ୍ ଚଲାଇଲେ ଯଥାର୍ଥ ଭାବେ **ପ୍ରାୟ-ଶୂନ୍ୟ ସଞ୍ଚୟ** ହୁଏ, କାରଣ
ଅପସାରଣ କରିବା ପାଇଁ କୌଣସି ପୁନରାବୃତ୍ତି ନାହିଁ ଏବଂ `validateCompression()` (`validation.ts`) କୋଡ୍ ବ୍ଲକ୍, URL, ଶୀର୍ଷକ, ସଂସ୍କରଣ କିମ୍ବା ALL-CAPS ସ୍ଥିରାଙ୍କ ପରିଚୟକଗୁଡ଼ିକୁ ଛାଡ଼ିଦେବା କିମ୍ବା ପରିବର୍ତ୍ତନ କରିଦେବା ଭଳି
କୌଣସି ପୁନର୍ଲିଖନ ପଠାଇବାକୁ ମନା କରେ।

ଏହା ଆଶାକରାଯାଉଥିବା, ସୁରକ୍ଷିତ ଆଚରଣ, କୌଣସି ବଗ୍ ନୁହେଁ: ମୁଖ୍ୟତଃ ସ୍ୱଚ୍ଛ ଫାଇଲ୍ଗୁଡ଼ିକୁ ପଢ଼ୁଥିବା/grep କରୁଥିବା ଏକ କୋଡିଂ ସେସନ୍ରେ
କମ୍ପ୍ରେସନ୍ ସମ୍ପୂର୍ଣ୍ଣ ଭାବେ ସକ୍ଷମ ଥିଲେ ମଧ୍ୟ ସାମାନ୍ୟ ମୋଟ ସଞ୍ଚୟ ଦେଖାଯିବ, ଯେତେବେଳେ ବିଫଳ ହେଉଥିବା ଏକ
ଲୁପ୍ କିମ୍ବା ଅତ୍ୟଧିକ ଆଉଟପୁଟ୍ ଦେଉଥିବା ଏକ ଲିଣ୍ଟର୍ର ସମ୍ମୁଖୀନ ହେଉଥିବା ସେସନ୍ରେ ସେହି ଟ୍ରାଫିକ୍ରେ ସମ୍ପୂର୍ଣ୍ଣ 78-95% ପରିସର ଦେଖାଯିବ। କମ୍ପ୍ରେସନ୍ ଭୁଲ ଭାବେ ବିନ୍ୟାସ ହୋଇଛି ବୋଲି ପ୍ରମାଣ ଭାବେ ଗୋଟିଏ ସେସନ୍ର
କମ୍ ସମଗ୍ର ସଞ୍ଚୟ ପ୍ରତିଶତକୁ ବ୍ୟବହାର କରନ୍ତୁ ନାହିଁ — ପ୍ରଥମେ ମୂଳ ଟୁଲ୍ ଆଉଟପୁଟ୍ ପ୍ରକୃତରେ ଅନାବଶ୍ୟକ ଭାବେ ପୁନରାବୃତ୍ତ ଥିଲା କି ନାହିଁ ଯାଞ୍ଚ କରନ୍ତୁ।

---

## ଟୋକନ୍ ସଞ୍ଚୟ ଭିଜୁଆଲାଇଜେସନ୍

```
କମ୍ପ୍ରେସନ୍ ବିନା:       LLMକୁ 47K ଟୋକନ୍ ପଠାଯାଇଛି
Lite ସହିତ:              40K ଟୋକନ୍ ପଠାଯାଇଛି          (15% ସଞ୍ଚୟ — ସୁରକ୍ଷିତ, ସର୍ବଦା-ସକ୍ରିୟ)
Standard ସହିତ:          33K ଟୋକନ୍ ପଠାଯାଇଛି          (30% ସଞ୍ଚୟ — caveman-speak ନିୟମ)
Aggressive ସହିତ:        24K ଟୋକନ୍ ପଠାଯାଇଛି          (50% ସଞ୍ଚୟ — ବୟସ୍କୀକରଣ + ସାରାଂଶୀକରଣ)
Ultra ସହିତ:             12K ଟୋକନ୍ ପଠାଯାଇଛି          (75% ସଞ୍ଚୟ — ହ୍ୟୁରିଷ୍ଟିକ୍ ଛଟେଇ)
RTK ସହିତ:               19K-5K ଟୋକନ୍ ପଠାଯାଇଛି       (କମାଣ୍ଡ/ଟୁଲ୍ ଆଉଟପୁଟ୍ରେ 60-90% ସଞ୍ଚୟ)
Stacked ସହିତ:           10K-2.5K ଟୋକନ୍ ପଠାଯାଇଛି     (ଯୋଗ୍ୟ RTK+Caveman ପରିସରରେ 78-95%)
```

---

## ବିନ୍ୟାସ

### ଡ୍ୟାସ୍ବୋର୍ଡ

`ଡ୍ୟାସ୍ବୋର୍ଡ → ପ୍ରସଙ୍ଗ ଏବଂ କ୍ୟାଶ୍`କୁ ଯାଆନ୍ତୁ:

- **Caveman** — ମୋଡ୍ ଚୟନ, ଭାଷା ପ୍ୟାକ୍, ପୂର୍ବାବଲୋକନ ଏବଂ ଗ୍ଲୋବାଲ୍ ଡିଫଲ୍ଟଗୁଡ଼ିକ
- **RTK** — କମାଣ୍ଡ-ଫିଲ୍ଟର୍ ପୂର୍ବାବଲୋକନ, RTK ସୁରକ୍ଷା ସେଟିଂସ୍ ଏବଂ ଫିଲ୍ଟର୍ କ୍ୟାଟାଲଗ୍
- **କମ୍ପ୍ରେସନ୍ କମ୍ବୋଗୁଡ଼ିକ** — ରାଉଟିଂ କମ୍ବୋଗୁଡ଼ିକୁ ନ୍ୟସ୍ତ କରାଯାଇଥିବା ନାମିତ ଇଞ୍ଜିନ୍ ପାଇପ୍ଲାଇନ୍ଗୁଡ଼ିକ
- **ସ୍ୱୟଂଚାଳିତ-ଟ୍ରିଗର୍ ଥ୍ରେଶହୋଲ୍ଡ** — ଟୋକନ୍ ସଂଖ୍ୟା ଥ୍ରେଶହୋଲ୍ଡ ଅତିକ୍ରମ କଲେ ସ୍ୱୟଂଚାଳିତ ଭାବେ କମ୍ପ୍ରେସନ୍ ସକ୍ରିୟ କରେ

### ପ୍ରତି-କମ୍ବୋ ଓଭର୍ରାଇଡ୍

`ଡ୍ୟାସ୍ବୋର୍ଡ → ପ୍ରସଙ୍ଗ ଏବଂ କ୍ୟାଶ୍ → କମ୍ପ୍ରେସନ୍ କମ୍ବୋଗୁଡ଼ିକ`ରେ, ଏକ ରାଉଟିଂ
କମ୍ବୋକୁ ଏକ କମ୍ପ୍ରେସନ୍ କମ୍ବୋ ନ୍ୟସ୍ତ କରନ୍ତୁ:

```txt
କମ୍ବୋ: "free-tier-fallback"
  କମ୍ପ୍ରେସନ୍ କମ୍ବୋ: "coding-agent-stack"
  ପାଇପ୍ଲାଇନ୍: RTK -> Caveman
  ଲକ୍ଷ୍ୟଗୁଡ଼ିକ:
    1. if/kimi-k2.7-code
    2. if/qwen3.8-max-preview
```

ଏହା ଆପଣଙ୍କୁ ପେଡ୍ ସବ୍ସ୍କ୍ରିପ୍ସନ୍ଗୁଡ଼ିକରେ ଲାଇଟ୍ ମୋଡ୍ ରଖିବା ସହିତ ମାଗଣା/କୋଡିଂ
ପ୍ରଦାନକାରୀମାନଙ୍କରେ ସ୍ତରୀକୃତ କମ୍ପ୍ରେସନ୍ ବ୍ୟବହାର କରିବାକୁ ଦିଏ।

ଏହି "ପ୍ରତି-କମ୍ବୋ ଓଭର୍ରାଇଡ୍" ନ୍ୟସ୍ତକରଣଟି **ରାଉଟିଂ-କମ୍ବୋ କମ୍ପ୍ରେସନ୍
ମୋଡ୍** ଓଭର୍ରାଇଡ୍ଠାରୁ ଭିନ୍ନ ଏକ ନିୟନ୍ତ୍ରଣ (ଡିଫଲ୍ଟ/ବନ୍ଦ/ଲାଇଟ୍/ଷ୍ଟାଣ୍ଡାର୍ଡ/ଆଗ୍ରେସିଭ୍/ଅଲ୍ଟ୍ରା/Codex Responses — ଏହି ଫିଲ୍ଡର
ସ୍କିମା `rtk`, `stacked` ଏବଂ `omniglyph`କୁ ମଧ୍ୟ ଗ୍ରହଣ କରେ) — ସେହି ଓଭର୍ରାଇଡ୍ କୌଣସି ନାମିତ
କମ୍ପ୍ରେସନ୍-କମ୍ବୋ ପାଇପ୍ଲାଇନ୍ ବାଛେ ନାହିଁ; ଏହା କେବଳ `resolveCompressionPlan` ଦ୍ୱାରା ପରାମର୍ଶ କରାଯାଉଥିବା
`compressionMode` ଫିଲ୍ଡକୁ ସେଟ୍ କରେ। ଏହାକୁ କମ୍ବୋ କାର୍ଡରେ (`ଡ୍ୟାସ୍ବୋର୍ଡ → କମ୍ବୋଗୁଡ଼ିକ`) କିମ୍ବା, #6760ଠାରୁ,
`ଡ୍ୟାସ୍ବୋର୍ଡ → ପ୍ରସଙ୍ଗ ଏବଂ କ୍ୟାଶ୍ → କମ୍ପ୍ରେସନ୍ କମ୍ବୋଗୁଡ଼ିକ`ର "ରାଉଟିଂକୁ ନ୍ୟସ୍ତ କରନ୍ତୁ" ତାଲିକାରେ ପ୍ରତ୍ୟେକ ରାଉଟିଂ କମ୍ବୋ ପାଇଁ, ଉପରେ
ଦଲିଲଭୁକ୍ତ ପାଇପ୍ଲାଇନ୍-ନ୍ୟସ୍ତକରଣ ଚେକ୍ବକ୍ସର ଠିକ୍ ପାଖରେ ସେଟ୍ କରାଯାଇପାରିବ।
ଉଭୟ ଇଣ୍ଟରଫେସ୍ ସମାନ `PUT /api/combos/{id}` ଏଣ୍ଡପଏଣ୍ଟ ମାଧ୍ୟମରେ ସ୍ଥାୟୀ ହୋଇ ରହେ।

### ପ୍ରତି-ଅନୁରୋଧ ଓଭର୍ରାଇଡ୍

ଗୋଟିଏ ଅନୁରୋଧ ପାଇଁ କମ୍ପ୍ରେସନ୍ ପ୍ଲାନ୍କୁ ଓଭର୍ରାଇଡ୍ କରିବାକୁ `x-omniroute-compression` ଅନୁରୋଧ ହେଡର୍
ପଠାନ୍ତୁ। ଏହାର ପ୍ରାଧାନ୍ୟ ସର୍ବାଧିକ — ଏହା ରାଉଟିଂ-କମ୍ବୋ ଓଭର୍ରାଇଡ୍, ସକ୍ରିୟ ପ୍ରୋଫାଇଲ୍,
ସ୍ୱୟଂଚାଳିତ-ଟ୍ରିଗର୍ ଏବଂ ପ୍ୟାନେଲ୍ ଡିଫଲ୍ଟକୁ ଅତିକ୍ରମ କରେ। ଅଜଣା ମୂଲ୍ୟଗୁଡ଼ିକୁ ଅଣଦେଖା କରାଯାଏ (ଅନୁରୋଧ କେବେବି ପ୍ରତ୍ୟାଖ୍ୟାନ ହୁଏ ନାହିଁ) ଏବଂ
ଗ୍ଲୋବାଲ୍ ମାଷ୍ଟର୍ ସ୍ୱିଚ୍ ତଥାପି ସବୁକିଛିକୁ ନିୟନ୍ତ୍ରଣ କରେ: ଯେତେବେଳେ କମ୍ପ୍ରେସନ୍ ଗ୍ଲୋବାଲ୍ ଭାବେ ବନ୍ଦ ଥାଏ, ହେଡର୍ ଏହାକୁ
ସକ୍ରିୟ କରିପାରିବ ନାହିଁ। ମୂଲ୍ୟଗୁଡ଼ିକ:

| ମୂଲ୍ୟ         | ପ୍ରଭାବ                                                                                           |
| ------------- | ------------------------------------------------------------------------------------------------ |
| `off`         | ଏହି ଅନୁରୋଧ ପାଇଁ କୌଣସି କମ୍ପ୍ରେସନ୍ ନାହିଁ।                                                          |
| `default`     | ପ୍ୟାନେଲ୍ରୁ ପ୍ରାପ୍ତ ଡିଫଲ୍ଟ ପ୍ରୋଫାଇଲ୍ (ସକ୍ରିୟ ପ୍ରୋଫାଇଲ୍କୁ ଅଣଦେଖା କରେ)। ଲସି ଇଞ୍ଜିନ୍ଗୁଡ଼ିକ ବନ୍ଦ ରହେ। |
| `safe`        | ହେଡର୍ ବାଦ୍ ଦେବା ସହିତ ସମାନ: କେବଳ ଡିଡୁପ୍ ଏବଂ ହ୍ୱାଇଟ୍ସ୍ପେସ୍ ଫୋଲ୍ଡିଂ।                                |
| `allow-lossy` | ସାରାଂଶ, ପ୍ରାସଙ୍ଗିକତା ଫିଲ୍ଟର୍ ଏବଂ ଶୈଳୀ ପୁନର୍ଲିଖନ ସହିତ ଏହି ଅନୁରୋଧର ଅପରେଟର୍ ପ୍ଲାନ୍କୁ ରଖେ।           |
| `engine:<id>` | ସକ୍ରିୟ ଥିଲେ ଗୋଟିଏ ଇଞ୍ଜିନ୍, ଯଥା `engine:rtk`। ସେହି ଇଞ୍ଜିନ୍ ପାଇଁ ଏହା ପ୍ରତି-ଅନୁରୋଧ ଅପ୍ଟ-ଇନ୍।        |
| `<combo>`     | ଏକ ନାମିତ କମ୍ବୋ, ପ୍ରଥମେ ନାମ ଅନୁଯାୟୀ (କେସ୍-ଅସମ୍ବେଦନଶୀଳ), ତା'ପରେ id ଅନୁଯାୟୀ ମେଳ କରାଯାଏ।             |

`allow-lossy`, `engine:<id>` କିମ୍ବା ଏକ ନାମିତ କମ୍ବୋ ବିନା, ଲସି ଇଞ୍ଜିନ୍ଗୁଡ଼ିକ ପ୍ରୟୋଗ କରାଯାଏ ନାହିଁ।
କମ୍ପ୍ରେସନ୍ ସକ୍ରିୟ ଥିଲେ ଅନୁରୋଧଟି ତଥାପି ସେସନ୍ ଡିଡୁପ୍ ଏବଂ ହ୍ୱାଇଟ୍ସ୍ପେସ୍ ଫୋଲ୍ଡିଂ ପାଏ।

ପ୍ରୟୋଗ କରାଯାଇଥିବା ପ୍ଲାନ୍କୁ `X-OmniRoute-Compression: <mode>; source=<source>` ପ୍ରତିକ୍ରିୟା
ହେଡର୍ରେ ପୁନଃ ପଠାଯାଏ, ଯେଉଁଠାରେ `<source>` ହେଉଛି `request-header`, `routing-override`, `active-profile`,
`auto-trigger`, `default`, କିମ୍ବା `off` ମଧ୍ୟରୁ ଗୋଟିଏ।

### API

```bash
# କମ୍ପ୍ରେସନ୍ ସେଟିଂସ୍ ପ୍ରାପ୍ତ କରନ୍ତୁ
curl http://localhost:20128/api/settings/compression

# କମ୍ପ୍ରେସନ୍ ସେଟିଂସ୍ ଅଦ୍ୟତନ କରନ୍ତୁ
curl -X PUT http://localhost:20128/api/settings/compression \
  -H "Content-Type: application/json" \
  -d '{"defaultMode":"stacked","autoTriggerMode":"stacked","autoTriggerTokens":32000}'

# ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ RTK/stacked ପେଲୋଡ୍ର ପୂର୍ବାବଲୋକନ କରନ୍ତୁ
curl -X POST http://localhost:20128/api/compression/preview \
  -H "Content-Type: application/json" \
  -d '{"mode":"rtk","messages":[{"role":"tool","content":"npm test output here"}]}'

# RTK ଫିଲ୍ଟର୍ ପ୍ୟାକ୍ଗୁଡ଼ିକର ତାଲିକା ଦେଖନ୍ତୁ
curl http://localhost:20128/api/context/rtk/filters

# ଇଚ୍ଛାଧୀନ କମାଣ୍ଡ ମେଟାଡାଟା ସହିତ RTKକୁ ସିଧାସଳଖ ପରୀକ୍ଷା କରନ୍ତୁ
curl -X POST http://localhost:20128/api/context/rtk/test \
  -H "Content-Type: application/json" \
  -d '{"command":"npm test","text":"FAIL tests/example.test.ts\nError: boom"}'
```

---

## କ’ଣ ସୁରକ୍ଷିତ ରହେ

କମ୍ପ୍ରେସନ୍ ଇଞ୍ଜିନ୍ **ସର୍ବଦା ଏଗୁଡ଼ିକୁ ସଂରକ୍ଷିତ ରଖେ:**

- ✅ କୋଡ୍ ବ୍ଲକ୍ଗୁଡ଼ିକ (ଫେନ୍ସ୍ଡ ଏବଂ ଇନ୍ଲାଇନ୍)
- ✅ URL ଏବଂ ଫାଇଲ୍ ପାଥ୍ଗୁଡ଼ିକ
- ✅ JSON ସଂରଚନା ଏବଂ ସଂରଚିତ ଡାଟା
- ✅ ଆଇଡେଣ୍ଟିଫାୟର୍ ଏବଂ ସୁରକ୍ଷିତ ପ୍ରାୟୋଗିକ ଟୋକେନ୍ଗୁଡ଼ିକ
- ✅ ଗାଣିତିକ ଅଭିବ୍ୟକ୍ତିଗୁଡ଼ିକ
- ✅ ଟୁଲ୍/ଫଙ୍କସନ୍ କଲ୍ ସଂଜ୍ଞାଗୁଡ଼ିକ
- ✅ ସିଷ୍ଟମ୍ ପ୍ରମ୍ପ୍ଟଗୁଡ଼ିକ (ଲାଇଟ୍ ମୋଡ୍ରେ)

କୌଣସି ତଥ୍ୟ ସ୍ଥାୟୀ ଭାବେ ସଞ୍ଚିତ ହେବା ପୂର୍ବରୁ, RTK ର’ ଆଉଟପୁଟ୍ ପୁନରୁଦ୍ଧାର ସାଧାରଣ API କି, ବିଅରର୍ ଟୋକେନ୍, Slack ଟୋକେନ୍, AWS ଆକ୍ସେସ୍ କି,
ପାସ୍ୱାର୍ଡ, ଟୋକେନ୍ ଏବଂ ସିକ୍ରେଟ୍ଗୁଡ଼ିକୁ ଲୁଚାଇ ଦିଏ।

---

## କମ୍ପ୍ରେସନ୍ ପରିସଂଖ୍ୟାନ

ପ୍ରତ୍ୟେକ କମ୍ପ୍ରେସ୍ କରାଯାଇଥିବା ଅନୁରୋଧ ସର୍ଭର୍ ଲଗ୍ରେ ପରିସଂଖ୍ୟାନ ସାମିଲ କରେ:

```json
{
  "originalTokens": 47200,
  "compressedTokens": 40120,
  "savingsPercent": 15.0,
  "techniquesUsed": ["collapseWhitespace", "dedupSystemPrompt"],
  "mode": "lite",
  "engine": "caveman",
  "compressionComboId": "coding-agent-stack",
  "durationMs": 0.8,
  "rtkRawOutputPointers": []
}
```

---

## ପର୍ଯ୍ୟାୟ ରୋଡ୍ମ୍ୟାପ୍

| ପର୍ଯ୍ୟାୟ    | ମୋଡ୍ଗୁଡ଼ିକ                                                                                                                                            | ସ୍ଥିତି          |
| ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | --------------- |
| ପର୍ଯ୍ୟାୟ 1  | ବନ୍ଦ, ଲାଇଟ୍                                                                                                                                           | ✅ ରିଲିଜ୍ ହୋଇଛି |
| ପର୍ଯ୍ୟାୟ 2  | ଷ୍ଟାଣ୍ଡାର୍ଡ, ଆଗ୍ରେସିଭ୍, ଅଲ୍ଟ୍ରା                                                                                                                       | ✅ ରିଲିଜ୍ ହୋଇଛି |
| ପର୍ଯ୍ୟାୟ 3  | RTK, ଷ୍ଟାକ୍ଡ, କମ୍ପ୍ରେସନ୍ କମ୍ବୋଗୁଡ଼ିକ                                                                                                                  | ✅ ରିଲିଜ୍ ହୋଇଛି |
| ପର୍ଯ୍ୟାୟ 4  | ଆଉଟପୁଟ୍ ଶୈଳୀ, SLM-ସ୍ତରୀୟ ଅଲ୍ଟ୍ରା, ମୂଲ୍ୟାୟନ ହାର୍ନେସ୍                                                                                                   | ✅ ରିଲିଜ୍ ହୋଇଛି |
| ପର୍ଯ୍ୟାୟ 4C | ଆଡାପ୍ଟିଭ୍ କଣ୍ଟେକ୍ସ୍ଟ-ବଜେଟ୍ ("ଡାଏଲ୍") — କମ୍ପ୍ୟୁଟ୍ ଇଞ୍ଜିନ୍ + API (`PUT /api/settings/compression`ରେ `contextBudget`) + ଡ୍ୟାସ୍ବୋର୍ଡ ମୋଡ୍/ପଲିସି ନିୟନ୍ତ୍ରଣ | ✅ ରିଲିଜ୍ ହୋଇଛି |

---

## ସ୍ୱୀକୃତି

ଷ୍ଟାଣ୍ଡାର୍ଡ ମୋଡ୍ କମ୍ପ୍ରେସନ୍ ନିୟମଗୁଡ଼ିକ **[JuliusBrussee](https://github.com/JuliusBrussee)**ଙ୍କ **[Caveman](https://github.com/JuliusBrussee/caveman)** (⭐ 51K+) ଦ୍ୱାରା ଅନୁପ୍ରାଣିତ — ଭାଇରାଲ୍ "କମ୍ ଟୋକେନ୍ରେ କାମ ହେଉଥିବା ବେଳେ ଅଧିକ ଟୋକେନ୍ କାହିଁକି ବ୍ୟବହାର କରିବେ" ପ୍ରକଳ୍ପ। Caveman `~75%` କମ୍ ଆଉଟପୁଟ୍ ଟୋକେନ୍, ବେଞ୍ଚମାର୍କରେ ହାରାହାରି `65%` ଆଉଟପୁଟ୍ ସଞ୍ଚୟ, `22-87%` ଆଉଟପୁଟ୍ ପରିସର ଏବଂ ଏକ `~46%` ଇନ୍ପୁଟ୍-କମ୍ପ୍ରେସନ୍ ଟୁଲ୍ ରିପୋର୍ଟ କରେ।

RTK ମୋଡ୍ **[RTK AI](https://github.com/rtk-ai)**ର **[RTK - Rust Token Killer](https://github.com/rtk-ai/rtk)** ଦ୍ୱାରା ଅନୁପ୍ରାଣିତ — ଟର୍ମିନାଲ୍, ବିଲ୍ଡ, ଟେଷ୍ଟ, git ଏବଂ ଟୁଲ୍-ଆଉଟପୁଟ୍ ଫିଲ୍ଟରିଂ ପାଇଁ ଉଚ୍ଚ-କାର୍ଯ୍ୟକ୍ଷମତାସମ୍ପନ୍ନ କମାଣ୍ଡ-ଆଉଟପୁଟ୍ କମ୍ପ୍ରେସନ୍ ପ୍ରକଳ୍ପ। RTK `60-90%` ସଞ୍ଚୟ ରିପୋର୍ଟ କରେ, ଏବଂ ଏହାର README ନମୁନା ସେସନ୍ରେ `~80%` ସଞ୍ଚୟ ଦେଖାଯାଇଛି।

---

## ଉନ୍ନତ ସଂକୋଚନ ପ୍ରଣାଳୀଗୁଡ଼ିକ

ଉପରେ ବର୍ଣ୍ଣିତ 7ଟି ମୋଡ୍ ବ୍ୟତୀତ (ଉତ୍ସଟି `codex-responses` ଏବଂ
`omniglyph` ମୋଡ୍ଗୁଡ଼ିକୁ ମଧ୍ୟ ଗ୍ରହଣ କରେ, ଯାହାକୁ ଏହି ମାର୍ଗଦର୍ଶିକାରେ ଅନ୍ତର୍ଭୁକ୍ତ କରାଯାଇନାହିଁ), ନିମ୍ନର ବିଭାଗଗୁଡ଼ିକ ସେହି ମୋଡ୍ଗୁଡ଼ିକ ଭିତରେ କିମ୍ବା ସେଗୁଡ଼ିକ ସହିତ କାମ କରୁଥିବା ବୈଶିଷ୍ଟ୍ୟଗୁଡ଼ିକୁ
ବର୍ଣ୍ଣନା କରେ: Tool Result Compression ଏବଂ Progressive Aging ହେଉଛି aggressive ଇଞ୍ଜିନ୍ର ପଦକ୍ଷେପ 1 ଏବଂ 2 (Aggressive ମୋଡ୍ ଓ ଏକ
stacked pipelineର `aggressive` ପଦକ୍ଷେପ), Stacked Pipeline ହେଉଛି Stacked ମୋଡ୍ ଚାଲିବାର ପ୍ରକ୍ରିୟା, Cache-Aware Compression
କ୍ୟାସିଂ ପ୍ରଦାନକାରୀଙ୍କ ପାଇଁ ସଂକୋଚନ ସକ୍ରିୟ ଥିବାବେଳେ `aggressive` ଏବଂ `ultra`କୁ `standard`କୁ ଅବନମିତ କରେ,
ଏବଂ Caveman Output Mode ଓ Output Styles ହେଉଛି ଇଚ୍ଛାଧୀନ system-prompt ନିର୍ଦ୍ଦେଶାବଳୀ,
ଯାହା ଡିଫଲ୍ଟ ଭାବେ ବନ୍ଦ ରହେ ଏବଂ ଅନୁରୋଧକୁ ସଂକୋଚନ କରିବା ପରିବର୍ତ୍ତେ ମଡେଲ୍ର ଆଉଟ୍ପୁଟ୍କୁ ଆକାର ଦିଏ।

### କ୍ୟାସ୍-ସଚେତନ ସଂକୋଚନ

କିଛି ପ୍ରଦାନକାରୀ (ଯେପରିକି prompt caching ସହିତ Anthropic) **prompt caching**କୁ ସମର୍ଥନ କରନ୍ତି,
ଯାହା ସେମାନଙ୍କୁ ଖର୍ଚ୍ଚ ଏବଂ ବିଳମ୍ବ କମାଇବା ପାଇଁ promptର କିଛି ଅଂଶ କ୍ୟାସ୍ କରିବାକୁ ଦିଏ। ଯେତେବେଳେ
କ୍ୟାସିଂ ସକ୍ରିୟ ଥାଏ, aggressive ସଂକୋଚନ ବାସ୍ତବରେ କାର୍ଯ୍ୟଦକ୍ଷତାକୁ **କ୍ଷତିଗ୍ରସ୍ତ** କରିପାରେ,
କାରଣ ଏହା କ୍ୟାସ୍ ହୋଇଥିବା tokenଗୁଡ଼ିକୁ ପରିବର୍ତ୍ତନ କରି କ୍ୟାସ୍କୁ ଅବୈଧ କରିଦିଏ।

`cachingAware.ts` ମଡ୍ୟୁଲ୍ **କ୍ୟାସିଂ ପ୍ରସଙ୍ଗ ଚିହ୍ନଟ କରି** ଏବଂ
ସେହି ଅନୁସାରେ **ସଂକୋଚନ କୌଶଳ ସମନ୍ୱୟ କରି** ଏହାର ସମାଧାନ କରେ।

#### ଏହା କିପରି କାମ କରେ

1. **କ୍ୟାସିଂ ପ୍ରସଙ୍ଗ ଚିହ୍ନଟ କରେ** — `cache_control` ଚିହ୍ନଗୁଡ଼ିକ ପାଇଁ request body ସ୍କାନ୍ କରେ
2. **କ୍ୟାସିଂ ପ୍ରଦାନକାରୀଙ୍କୁ ଚିହ୍ନଟ କରେ** — ଲକ୍ଷ୍ୟ ପ୍ରଦାନକାରୀ କ୍ୟାସିଂ ସମର୍ଥନ କରନ୍ତି କି ନାହିଁ ଯାଞ୍ଚ କରେ
3. **କୌଶଳ ସମନ୍ୱୟ କରେ** — କ୍ୟାସିଂ ପ୍ରଦାନକାରୀଙ୍କ ପାଇଁ `aggressive`/`ultra`କୁ `standard`କୁ ଅବନମିତ କରେ
4. **system prompt ଏଡ଼ାଇଯାଏ** — System promptଗୁଡ଼ିକ ସାଧାରଣତଃ କ୍ୟାସ୍ ହୋଇଥାଏ, ତେଣୁ ସେଗୁଡ଼ିକୁ ସଂକୋଚନ କରନ୍ତୁ ନାହିଁ

କୌଶଳ helperଟି ଏକ `deterministicOnly` flag ମଧ୍ୟ ଫେରାଏ, କିନ୍ତୁ plan builder
କେବଳ କୌଶଳକୁ ବ୍ୟବହାର କରେ — ବର୍ତ୍ତମାନ downstreamରେ କୌଣସି ଅଂଶ ଏହି flagକୁ ପଢ଼େ ନାହିଁ।

#### କୋଡ୍ ଉଦାହରଣ

```ts
import {
  detectCachingContext,
  getCacheAwareStrategy,
} from "@omniroute/open-sse/services/compression/cachingAware";

const body = {
  model: "anthropic/claude-sonnet-4.5",
  messages: [{ role: "user", content: "Hello" }],
  cache_control: { type: "ephemeral" }, // ← କ୍ୟାସ୍ ଚିହ୍ନ
};

const ctx = detectCachingContext(body, { provider: "anthropic" });
// → { hasCacheControl: true, provider: "anthropic", targetFormat: null, isCachingProvider: true }

const strategy = getCacheAwareStrategy("aggressive", ctx);
// → { strategy: "standard", skipSystemPrompt: true, deterministicOnly: true }
```

#### କେତେବେଳେ ବ୍ୟବହାର କରିବେ

କ୍ୟାସ୍-ସଚେତନ ସଂକୋଚନ **ସର୍ବଦା ସକ୍ରିୟ** — କୌଣସି configuration ଆବଶ୍ୟକ ନାହିଁ। ସଂକୋଚନ
ସକ୍ରିୟ ଥିବାବେଳେ ଏବଂ ଲକ୍ଷ୍ୟ ପ୍ରଦାନକାରୀ prompt cachingକୁ ସମର୍ଥନ କଲେ (Anthropic, OpenAI,
ଇତ୍ୟାଦି) ଏହା କାର୍ଯ୍ୟକାରୀ ହୁଏ; ସ୍ପଷ୍ଟ `cache_control` ଚିହ୍ନ ଆବଶ୍ୟକ ନୁହେଁ — କେବଳ ଏକ caching provider
ମଧ୍ୟ ଅବନମନକୁ ସକ୍ରିୟ କରେ, ଏବଂ କେବଳ ଚିହ୍ନଗୁଡ଼ିକ କେବେ ମଧ୍ୟ ଏହା କରେ ନାହିଁ (ଚିହ୍ନ ଚିହ୍ନଟ ପ୍ରକ୍ରିୟା cache
telemetryକୁ ତଥ୍ୟ ଯୋଗାଏ, କୌଶଳଗତ ନିଷ୍ପତ୍ତିକୁ ନୁହେଁ)।

### କ୍ରମାଗତ ପୁରୁଣାକରଣ

ଦୀର୍ଘ କଥୋପକଥନରେ ଅନେକ message turn ସଞ୍ଚିତ ହୁଏ, କିନ୍ତୁ ପୁରୁଣା turnଗୁଡ଼ିକ କ୍ରମେ କମ୍
ପ୍ରାସଙ୍ଗିକ ହୋଇଯାଏ। `progressiveAging.ts` ମଡ୍ୟୁଲ୍ **turn ଦୂରତା ଅନୁସାରେ messageଗୁଡ଼ିକୁ ସରଳ କରେ**
(ଦୂରତା କଥୋପକଥନର ଶେଷରୁ ମାପାଯାଏ)। ଯୋଗାଇ ଦିଆଯାଇଥିବା ଡିଫଲ୍ଟ
(`verbatim: 2, light: 2, moderate: 3`) ସହିତ:

- **ଶେଷ 2ଟି turn (ଦୂରତା ≤ 2)**: ଅବିକଳ ରଖାଯାଏ
- **ଦୂରତା 3**: Caveman ସଂକୋଚନ (ଅନାବଶ୍ୟକ ଶବ୍ଦ ଅପସାରଣ)
- **ଦୂରତା 4+**: Assistant messageଗୁଡ଼ିକୁ ସାରାଂଶିତ କରାଯାଏ; user messageଗୁଡ଼ିକୁ ସେମାନଙ୍କ ପ୍ରଥମ
  ଧାଡ଼ି ପର୍ଯ୍ୟନ୍ତ କମାଇ, 120ଟି ଅକ୍ଷରରେ ସୀମିତ କରାଯାଏ; ଅନ୍ୟ roleଗୁଡ଼ିକୁ ଅପରିବର୍ତ୍ତିତ ରଖାଯାଏ। ଦୂରତା ଯାହା ହେଉନା କାହିଁକି, System prompt, ପୂର୍ବରୁ aged ହୋଇଥିବା
  message ଏବଂ ସର୍ବଶେଷ user messageକୁ ସର୍ବଦା ଅବିକଳ ରଖାଯାଏ।
  କୌଣସି ବିଷୟ ସମ୍ପୂର୍ଣ୍ଣ ଭାବେ ବାଦ ଦିଆଯାଏ ନାହିଁ, ଏବଂ ଯୋଗାଇ ଦିଆଯାଇଥିବା ଡିଫଲ୍ଟରେ `light`
  band ପହଞ୍ଚଯୋଗ୍ୟ ନୁହେଁ (`light`ର ମୂଲ୍ୟ `verbatim` ସହିତ ସମାନ)।

#### କୋଡ୍ ଉଦାହରଣ

```ts
import { applyAging } from "@omniroute/open-sse/services/compression/progressiveAging";

const messages = [
  { role: "system", content: "You are a helpful assistant" },
  { role: "user", content: "What is 2+2?" },
  { role: "assistant", content: "4" },
  // ... ଆହୁରି 50ଟି turn ...
];

const { messages: aged, saved } = applyAging(messages, {
  verbatim: 3, // ଶେଷ 3ଟି turn: ଅବିକଳ
  light: 8, // ଦୂରତା <= 8: lite ସଂକୋଚନ
  moderate: 20, // ଦୂରତା <= 20: caveman ସଂକୋଚନ
  fullSummary: 5, // type ପାଇଁ ଆବଶ୍ୟକ, banding code ଦ୍ୱାରା ପଢ଼ାଯାଏ ନାହିଁ
  // ଦୂରତା > 20: ସାରାଂଶିତ (assistant) / ପ୍ରଥମ ଧାଡ଼ି ରଖାଯାଏ (user)
});

// saved = ସଞ୍ଚିତ token ସଂଖ୍ୟା
```

#### କେତେବେଳେ ବ୍ୟବହାର କରିବେ

Progressive aging `aggressive` ମୋଡ୍ ପାଇଁ **ସର୍ବଦା ସକ୍ରିୟ** — ଏହା
`compressAggressive()`ର ପଦକ୍ଷେପ 2। Ultra ମୋଡ୍ ଏହାକୁ ଚଳାଏ ନାହିଁ। ଏହା
ବିଶେଷତଃ ନିମ୍ନଲିଖିତ ପାଇଁ ପ୍ରଭାବଶାଳୀ:

- ଦୀର୍ଘକାଳୀନ coding session
- ଏକାଧିକ ଦିନ ଧରି ଚାଲୁଥିବା କଥୋପକଥନ
- ଅନେକ tool call ସହିତ agentic workflow

### Caveman ଆଉଟ୍ପୁଟ୍ ମୋଡ୍

Caveman output mode ଏପରି **system prompt ନିର୍ଦ୍ଦେଶାବଳୀ** ଯୋଡ଼େ, ଯାହା ମଡେଲ୍କୁ ସଂକ୍ଷିପ୍ତ
ଆଉଟ୍ପୁଟ୍ ଦେବାକୁ କହେ — `lite` ସ୍ତରଟି ସମ୍ପୂର୍ଣ୍ଣ ବାକ୍ୟ ବଜାୟ ରଖି ସଂକ୍ଷିପ୍ତ ଉତ୍ତର ଦେବାକୁ କହେ, `full`
ଏହାକୁ "ବୁଦ୍ଧିମାନ ଗୁହାମାନବ ପରି ସଂକ୍ଷିପ୍ତ ଉତ୍ତର ଦିଅ" ବୋଲି କହେ, ଏବଂ `ultra` ଟେଲିଗ୍ରାଫିକ୍ ଆଉଟ୍ପୁଟ୍ ମାଗେ;
ନିର୍ଦ୍ଦେଶାବଳୀ କେବଳ ଅନୁରୋଧ କରେ, ସେଗୁଡ଼ିକ ଏହାକୁ ସୁନିଶ୍ଚିତ କରିପାରେ ନାହିଁ। ଅନୁରୋଧଗୁଡ଼ିକ
`applyOutputStyles()` (`open-sse/services/compression/outputStyles/apply.ts`) ମାଧ୍ୟମରେ ସେଗୁଡ଼ିକୁ ପ୍ରାପ୍ତ କରେ:
`open-sse/handlers/chatCore.ts` ପ୍ରଥମେ back-compat shim
(`open-sse/services/compression/outputStyles/backCompat.ts`ରେ ଥିବା `resolveOutputStyleSelection()`) ମାଧ୍ୟମରେ ଚୟନକୁ ନିର୍ଦ୍ଧାରଣ କରେ, ଯାହା `outputStyles`
ଖାଲି ଥିବାବେଳେ, ଏକ ସକ୍ରିୟ `cavemanOutputMode`କୁ
`cavemanOutputMode.intensity`ରେ `terse-prose` output style ସହିତ ମ୍ୟାପ୍ କରେ (ନିମ୍ନର Back-compat ଦେଖନ୍ତୁ); ଏକ ଖାଲି ନଥିବା `outputStyles`
ଚୟନକୁ ଯଥାବତ୍ ବ୍ୟବହାର କରାଯାଏ, ଏବଂ ତା’ପରେ `cavemanOutputMode.enabled` ଓ `intensity`ର କୌଣସି
ପ୍ରଭାବ ରହେ ନାହିଁ, ଯେତେବେଳେ ଏହାର `autoClarity` toggle ତଥାପି ପ୍ରୟୋଗ ହୁଏ। `outputMode.ts`ରେ
ନିର୍ଦ୍ଦେଶ ପାଠ୍ୟଗୁଡ଼ିକ (`CAVEMAN_INSTRUCTION_BY_LANGUAGE`), content bypass ଏବଂ
injection ବ୍ୟବହାର କରୁଥିବା placement helper ରହିଛି; ଏହାର ନିଜସ୍ୱ `applyCavemanOutputMode()` injectorର କୌଣସି
production caller ନାହିଁ।

#### ଏହା କିପରି କାମ କରେ

ଏହି ମୋଡ୍ ଇନପୁଟ୍କୁ ସଂକୁଚିତ କରେ ନାହିଁ। ଏହା ସିଷ୍ଟମ୍ ପ୍ରମ୍ପ୍ଟରେ ଏକ ନିର୍ଦ୍ଦେଶ ବ୍ଲକ୍ ଯୋଡ଼େ
(ନିମ୍ନରେ ଇଞ୍ଜେକ୍ସନ୍ କିପରି କାମ କରେ ଦେଖନ୍ତୁ), ଏବଂ ଅନୁରୋଧ ପାଇଁ ଚୟନ କରାଯାଇଥିବା ଯେକୌଣସି ଇନପୁଟ୍ ସଂକୋଚନ ମୋଡ୍
ତା’ପରେ ମଧ୍ୟ ଚାଲେ, ବର୍ତ୍ତମାନ ବ୍ଲକ୍ଟି ଥିବା ବଡି ଉପରେ। ପ୍ରତ୍ୟେକ ସ୍ତର ଶେଷରେ ଥିବା ସାଧାରଣ
ସୀମା ଧାରା ପୂର୍ବରୁ, ଇଂରାଜୀ `full` ସ୍ତରରେ ଏହା ଲେଖାଯାଇଛି:

> "ଚତୁର ଗୁହାମାନବ ପରି ସଂକ୍ଷିପ୍ତ ଉତ୍ତର ଦିଅ। articles (a/an/the), ଅନାବଶ୍ୟକ ଶବ୍ଦ (just/really/basically/actually/simply), ଶିଷ୍ଟାଚାରମୂଳକ କଥା, ଓ ଅନିଶ୍ଚିତତାସୂଚକ ଭାଷା ଛାଡ଼। ବାକ୍ୟଖଣ୍ଡ ଚଳିବ। ଛୋଟ ସମାନାର୍ଥକ ଶବ୍ଦ ବ୍ୟବହାର କର (extensive ନୁହେଁ big, implement ନୁହେଁ fix)। ସମସ୍ତ ପ୍ରାଯୁକ୍ତିକ ବିଷୟବସ୍ତୁ, code, errors, URLs, identifiers ଅବିକଳ ରଖ।"

ଏହା ବିଶେଷ ଭାବରେ ଏଗୁଡ଼ିକ ପାଇଁ ଭଲ କାମ କରେ:

- କୋଡ୍ ସୃଷ୍ଟି (ଅଧିକ ସଂକ୍ଷିପ୍ତ ଆଉଟପୁଟ୍ = କମ୍ ଟୋକେନ୍)
- ଦ୍ରୁତ ପ୍ରଶ୍ନୋତ୍ତର (ବିସ୍ତୃତ ବ୍ୟାଖ୍ୟା ଦରକାର ନାହିଁ)
- ବ୍ୟାଚ୍ ପ୍ରକ୍ରିୟାକରଣ (ଥ୍ରୁପୁଟ୍ ସର୍ବାଧିକ କରେ)

#### କେବେ ବ୍ୟବହାର କରିବେ

Caveman ଆଉଟପୁଟ୍ ମୋଡ୍ **ଇଚ୍ଛାଧୀନ**। ସଂକୋଚନ ଚାଲୁ ଥିବାବେଳେ (`enabled: true`, Compression Settings ପୃଷ୍ଠାରେ ମୁଖ୍ୟ ଟଗଲ୍
ଚାଲୁ), ଏହାକୁ `cavemanOutputMode.enabled` ଦ୍ୱାରା ଚାଲୁ କରନ୍ତୁ; `intensity`
ଦ୍ୱାରା `lite`, `full` କିମ୍ବା `ultra` ବଛାଯାଏ:

```json
{
  "enabled": true,
  "cavemanOutputMode": {
    "enabled": true,
    "intensity": "full"
  }
}
```

ଏକ ସଂକୋଚନ କମ୍ବୋର **Output Mode** ଟଗଲ୍ (`outputMode`, ସ୍ତର `outputModeIntensity`ରେ)
ସେହି କମ୍ବୋ ଲାଗୁ ହେଉଥିବା ଅନୁରୋଧଗୁଡ଼ିକ ପାଇଁ ସମାନ ସ୍ୱିଚ୍ ସେଟ୍ କରେ, ଏବଂ
`omniroute_set_compression_engine` MCP ଟୁଲ୍ ଏହାକୁ ନିଜ boolean `outputMode`
argument ମାଧ୍ୟମରେ ଲେଖେ। ଖାଲି ନଥିବା `outputStyles` ଚୟନ ଏହି ସ୍ୱିଚ୍ଠାରୁ ଅଗ୍ରାଧିକାର ପାଏ। ଡ୍ୟାସବୋର୍ଡରେ, **Terse prose** ଆଉଟପୁଟ୍ ଶୈଳୀ ଚାଲୁ କଲେ ସମାନ ବ୍ଲକ୍ ଇଞ୍ଜେକ୍ଟ ହୁଏ (ନିମ୍ନରେ Output
Styles ଦେଖନ୍ତୁ)।

### ଆଉଟପୁଟ୍ ଶୈଳୀଗୁଡ଼ିକ (କ୍ୟାଟାଲଗ୍)

ଉପରୋକ୍ତ Caveman ଆଉଟପୁଟ୍ ମୋଡ୍ ହେଉଛି **ପୁରୁଣା ଏକକ-ଶୈଳୀ ପଥ**। Phase 4 ଏହାକୁ
ସଂଯୋଜନଯୋଗ୍ୟ ଆଉଟପୁଟ୍ ଶୈଳୀର ଏକ କ୍ୟାଟାଲଗ୍ରେ ସାଧାରଣୀକୃତ କରିଛି: `open-sse/services/compression/outputStyles/catalog.ts`ରେ
`OUTPUT_STYLE_CATALOG`। ପ୍ରତ୍ୟେକ ଶୈଳୀ ହେଉଛି ଏକ ସିଷ୍ଟମ୍-ପ୍ରମ୍ପ୍ଟ
ନିର୍ଦ୍ଦେଶ, ଯାହା ମଡେଲ୍କୁ ନିଜେ କମ୍ ବ୍ୟୟବହୁଳ ଆଉଟପୁଟ୍ ଦେବାକୁ କହେ; ଶୈଳୀଗୁଡ଼ିକୁ ଏକସଙ୍ଗେ
ଚାଲୁ କରାଯାଇପାରେ ଏବଂ ସେଗୁଡ଼ିକ କ୍ୟାଟାଲଗ୍ କ୍ରମରେ ଇଞ୍ଜେକ୍ଟ ହୁଏ।

| ଶୈଳୀ                            | `id`            | ଏହା କ’ଣ କରେ                                                                                                                                                                                                                                                                | ନିର୍ଦ୍ଦେଶର ଭାଷାଗୁଡ଼ିକ                         |
| ------------------------------- | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------- |
| ସଂକ୍ଷିପ୍ତ ଗଦ୍ୟ                  | `terse-prose`   | ଅନାବଶ୍ୟକ ଶବ୍ଦ/articles/ଅନିଶ୍ଚିତତାସୂଚକ ଭାଷା ଛାଡ଼େ; ପ୍ରାଯୁକ୍ତିକ ବିଷୟବସ୍ତୁ ଅବିକଳ ରଖେ। ପୁରୁଣା caveman ଆଉଟପୁଟ୍ ମୋଡ୍ର ସମାନ ପାଠ୍ୟ (ପୁନଃ ଲେଖାଯାଇନାହିଁ, ସନ୍ଦର୍ଭିତ)।                                                                                                                 | en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi |
| କମ୍ କୋଡ୍                        | `less-code`     | YAGNI କ୍ରମ: ସବୁଠାରୁ ଛୋଟ କାର୍ଯ୍ୟକ୍ଷମ ପରିବର୍ତ୍ତନ, ଅନୁରୋଧ କରାଯାଇନଥିବା abstraction ନୁହେଁ।                                                                                                                                                                                      | en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi |
| ପୋନିଟେଲ୍ (ଆଳସୀ ବରିଷ୍ଠ ଡେଭେଲପର୍) | `ponytail`      | "ସର୍ବୋତ୍ତମ କୋଡ୍ ହେଉଛି କେବେ ଲେଖାଯାଇନଥିବା କୋଡ୍": ପୁନଃବ୍ୟବହାର > ପୁନର୍ଲିଖନ, ମୂଳ କାରଣ > ଲକ୍ଷଣ, ସବୁଠାରୁ ଛୋଟ କାର୍ଯ୍ୟକ୍ଷମ diff।                                                                                                                                                    | en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi |
| ମୋର ADHD ଅଛି (କାର୍ଯ୍ୟ-ପ୍ରଥମ)    | `i-have-adhd`   | ପ୍ରଥମେ କାର୍ଯ୍ୟ (ଗଦ୍ୟ ପୂର୍ବରୁ command/path/snippet), ସଂଖ୍ୟାଯୁକ୍ତ ଓ ସୀମିତ ପଦକ୍ଷେପ, ଗୋଟିଏ ନିର୍ଦ୍ଦିଷ୍ଟ ପରବର୍ତ୍ତୀ ପଦକ୍ଷେପ, କୌଣସି ପ୍ରସ୍ତାବନା/ପୁନରାବୃତ୍ତି/ସମାପନୀ ନାହିଁ। [ayghri/i-have-adhd](https://github.com/ayghri/i-have-adhd) (MIT)ରୁ ଅନୁକୂଳିତ।                             | en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi |
| Antislop UI ଫିଲ୍ଟର୍             | `antislop-ui`   | ପ୍ରତ୍ୟେକ ଭିଜୁଆଲ୍ କୌଶଳକୁ ଏକ ଉଦ୍ଦେଶ୍ୟ ପରୀକ୍ଷାରେ ଉତ୍ତୀର୍ଣ୍ଣ ହେବାକୁ ପଡ଼ିବ (କ୍ରମବିନ୍ୟାସ, ପରିଚୟ, ପଠନୀୟତା); କୌଣସି ଡିଫଲ୍ଟ gradients/glass/glow ନୁହେଁ, ସୀମିତ palette, କୌଣସି template layout ନୁହେଁ। ଉଭୟ antislop ଶୈଳୀ କାମ ନକରୁଥିବା control ନ ରଖିବା / ମନଗଢ଼ା ଦାବି ନ କରିବା ସୀମା ଯୋଡ଼େ। | en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi |
| Antislop କପି ଏବଂ ମାନବ ଫିଲ୍ଟର୍   | `antislop-copy` | ନିର୍ଦ୍ଦିଷ୍ଟ କପି (କୌଣସି em dash, ସାଧାରଣ CTA, buzzword, chatbot ସମାପନୀ, ମନଗଢ଼ା ତଥ୍ୟ ନୁହେଁ) ସହ ଲୋକମାନଙ୍କ ପାଇଁ ନିୟମ: WCAG AA contrast, ଦୃଶ୍ୟମାନ focus, keyboard ପହଞ୍ଚ, empty/loading/error ଅବସ୍ଥା, mobile reflow।                                                              | en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi |
| ସଂକ୍ଷିପ୍ତ CJK (文言)            | `terse-cjk`     | Classical Chinese (文言)ରେ `full`/`ultra` ଉତ୍ତର; `lite` କେବଳ function word, ଶିଷ୍ଟାଚାରମୂଳକ କଥା କିମ୍ବା ଅଳଙ୍କରଣ ବିନା ସଂକ୍ଷିପ୍ତ ଉତ୍ତର ଚାହେଁ।                                                                                                                                   | zh (locale-gated, ନିମ୍ନରେ ଦେଖନ୍ତୁ)            |

ପ୍ରତ୍ୟେକ ଶୈଳୀର ତିନୋଟି intensity ସ୍ତର ରହିଛି — `lite`, `full`, `ultra` — ଏବଂ ପ୍ରତ୍ୟେକ ସ୍ତର
ସାଧାରଣ ସୀମା ଧାରା (`outputMode.ts`ରେ `SHARED_BOUNDARIES`) ସହ ଶେଷ ହୁଏ, ଯାହା
କୋଡ୍ ବ୍ଲକ୍, ଫାଇଲ୍ ପଥ, କମାଣ୍ଡ, ତ୍ରୁଟି ଏବଂ URLsକୁ ଅବିକଳ ରଖେ। `terse-prose` ଏବଂ
`terse-cjk` ସ୍ତରର ପାଠ୍ୟ ସେହି ତାଲିକାରେ identifiers ଯୋଡ଼େ।

`terse-cjk`କୁ ଦୁଇଟି ସ୍ଥାନରେ `zh` ପାଇଁ locale-gated କରାଯାଇଛି। Compression Settings ପୃଷ୍ଠା
କେବଳ ଡ୍ୟାସବୋର୍ଡ UI ଭାଷା Chinese (`zh-CN` କିମ୍ବା `zh-TW`) ଥିବାବେଳେ
ଏହାର ଧାଡ଼ି ଦେଖାଏ, ଏବଂ ଅନୁରୋଧର resolved language (ନିମ୍ନରେ Language
selection ଦେଖନ୍ତୁ) `zh` ହେଲେ ମାତ୍ର `applyOutputStyles()` ଏହାକୁ ଇଞ୍ଜେକ୍ଟ କରେ। ଧାଡ଼ି ଲୁଚାଇଲେ ସଞ୍ଚିତ `terse-cjk` ଚୟନ
ସଫା ହୁଏ ନାହିଁ: settings API ଯେକୌଣସି style id ଗ୍ରହଣ କରେ, ଏବଂ ପୃଷ୍ଠାରେ ଅନ୍ୟ ଶୈଳୀଗୁଡ଼ିକୁ ସେଭ୍ କଲେ ଏହାକୁ ରଖେ। ଅନୁରୋଧ ସମୟରେ, `applyOutputStyles()` ଭାଷା ଯାଞ୍ଚ ହିଁ ଏକମାତ୍ର locale gate।

#### ଇଞ୍ଜେକ୍ସନ୍ କିପରି କାମ କରେ

`applyOutputStyles()` (`open-sse/services/compression/outputStyles/apply.ts`) ଚୟନକୁ
କ୍ୟାଟାଲଗ୍ ସହିତ ସମାଧାନ କରେ (ଅଜଣା ids ଏବଂ locale ସହିତ ମେଳ ନଥିବା styles ବାଦ ଦିଆଯାଏ,
କେବେ ମଧ୍ୟ ତ୍ରୁଟି ହୁଏ ନାହିଁ; କୌଣସି style କୁ ସମାଧାନ ନହେଉଥିବା ଚୟନ body କୁ
ଅପରିବର୍ତ୍ତିତ ରଖେ, `no_styles` ଭାବେ ଏଡ଼ାଇ ଦିଆଯାଏ), ଚୟନିତ ନିର୍ଦ୍ଦେଶଗୁଡ଼ିକୁ କ୍ୟାଟାଲଗ୍
କ୍ରମରେ ସଂଯୋଜନ କରେ,
boundaries clause କୁ **ଥରେ ମାତ୍ର** ଶେଷରେ ଯୋଡ଼େ (ଏଥିସହ safety clause,
`SAFETY_BOUNDARIES` କିମ୍ବା ଏହାର ଅନୁବାଦ, ଯେତେବେଳେ `less-code` କିମ୍ବା `ponytail`
ଚୟନ କରାଯାଇଥାଏ), ଏବଂ block କୁ ଗୋଟିଏ idempotency marker
(`[OmniRoute Output Styles]`) ସହିତ ଆରମ୍ଭ କରେ, ତେଣୁ ପୁନଃ ପ୍ରୟୋଗ କଲେ କୌଣସି ପରିବର୍ତ୍ତନ
ହୁଏ ନାହିଁ। ସମାଧାନ ହୋଇଥିବା ଭାଷାର (ନିମ୍ନରେ Language selection ଦେଖନ୍ତୁ) ଅନୁବାଦ
ଉପଲବ୍ଧ ଥିଲେ, ଇଂରାଜୀ ପରିବର୍ତ୍ତେ ସ୍ଥାନୀୟକୃତ ନିର୍ଦ୍ଦେଶ ପ୍ରବେଶ କରାଯାଏ।

ଏକ ଖାଲି ନଥିବା `messages` array ଥିବା body ରେ, idempotency ଯାଞ୍ଚ content bypass
ପୂର୍ବରୁ ଚାଲେ: ଯେତେବେଳେ `[OmniRoute Output Styles]` marker ପୂର୍ବରୁ top-level
`system` field ରେ (ଏକ string କିମ୍ବା content-block array) କିମ୍ବା string content ଥିବା
ଏକ system message ରେ ରହିଥାଏ, body କୁ `already_applied` ଭାବେ ଅପରିବର୍ତ୍ତିତ ରଖାଯାଏ
ଏବଂ କୌଣସି keyword ଯାଞ୍ଚ ଚାଲେ ନାହିଁ।
ଅନ୍ୟଥା, ଏକ content bypass (`shouldBypassCavemanOutputMode()` in
`open-sse/services/compression/outputMode.ts`) ଶେଷ ତିନୋଟି messages ର text କୁ,
ସେଗୁଡ଼ିକର role ଯାହା ହେଉନା କାହିଁକି, ଯାଞ୍ଚ କରେ ଏବଂ ସେହି text ଏହାର security,
irreversible-action କିମ୍ବା clarification keywords ସହିତ ମେଳ ଖାଇଲେ, ଅଥବା ଏକ
କ୍ରମ-ସମ୍ବେଦନଶୀଳ sequence ସହିତ ମେଳ ଖାଇଲେ ସମଗ୍ର turn ପାଇଁ styles କୁ ଏଡ଼ାଇ ଦିଏ:
`first`, `then`, `after that`, `before`, `rollback` କିମ୍ବା `backup`, ଯାହାର 240
characters ମଧ୍ୟରେ `delete`, `drop`, `migrate`, `deploy` କିମ୍ବା `release` ଆସିଥାଏ।
**Auto-Clarity Bypass** toggle (`cavemanOutputMode.autoClarity`, default ଭାବେ on)
on ଥିବାବେଳେ bypass ଚାଲେ; toggle କୁ off କଲେ keyword ଯାଞ୍ଚ ଏଡ଼ାଇ ଦିଆଯାଏ।

ଯେତେବେଳେ bypass turn କୁ ଆଗକୁ ଯିବାକୁ ଦିଏ, `placeSystemInstruction()` (ସେହି file),
ଯାହା କେବେ ମଧ୍ୟ ନୂଆ `messages[0]` ସୃଷ୍ଟି କରେ ନାହିଁ, ନିମ୍ନଲିଖିତ ମଧ୍ୟରୁ ପ୍ରଥମେ
ମିଳୁଥିବା ସ୍ଥାନରେ block କୁ ରଖେ:

1. string content ଥିବା ଏକ ପ୍ରାରମ୍ଭିକ system message: ଏହାର text ପରେ block କୁ
   ଯୋଡ଼ାଯାଏ।
2. top-level `system` field: ଏକ string ର text ପରେ block କୁ ଯୋଡ଼ାଯାଏ, କିମ୍ବା
   content-block array ରେ ଏକ ନୂଆ text block ଭାବେ ଯୋଡ଼ାଯାଏ।
3. ପରେ ଆସୁଥିବା string content ସହିତ ପ୍ରଥମ system message: ଏହାର text ପରେ block କୁ
   ଯୋଡ଼ାଯାଏ।
4. ଉପରୋକ୍ତ ମଧ୍ୟରୁ କୌଣସିଟି ନୁହେଁ: block କୁ `messages` ର ଶେଷରେ ଏକ ନୂଆ system
   message ମଧ୍ୟରେ ରଖାଯାଏ।

`messages` array ନଥିବା (କିମ୍ବା ଏକ ଖାଲି array ଥିବା) body ରେ କୌଣସି content bypass
ଚାଲେ ନାହିଁ ଏବଂ top-level `system` field କୁ ଦେଖାଯାଏ ନାହିଁ। block କୁ ଏକ string
`instructions` field ର text ପରେ ଯୋଡ଼ାଯାଏ, ଯଦି ସେହି field ରେ ପୂର୍ବରୁ
`[OmniRoute Output Styles]` marker ନଥାଏ; marker ଥିଲେ body କୁ
`already_applied` ଭାବେ ଅପରିବର୍ତ୍ତିତ ରଖାଯାଏ। body ରେ string `instructions`
field ନଥିଲେ କିନ୍ତୁ `input` (ଏକ string କିମ୍ବା array) ଥିଲେ, block ଟି
`instructions` ହୋଇଯାଏ ଏବଂ ସେହି field ରେ ଥିବା ଯେକୌଣସି non-string value କୁ
ପ୍ରତିସ୍ଥାପନ କରେ। string `instructions` field କିମ୍ବା string ବା array `input`
ମଧ୍ୟରୁ କୌଣସିଟି ନଥିବା body କୁ ଅପରିବର୍ତ୍ତିତ ରଖାଯାଏ ଏବଂ `no_messages` ଭାବେ
ଏଡ଼ାଇ ଦିଆଯାଏ।

#### କିପରି ସକ୍ଷମ କରିବେ

dashboard ରେ: **Compression Context → Compression Settings**
(`/dashboard/context/settings`), Output styles section: ପ୍ରତ୍ୟେକ style ପାଇଁ
on/off toggle ଏବଂ level selector ସହିତ ଗୋଟିଏ row। compression ନିଜେ on ଥିବାବେଳେ
(page ର master toggle, `enabled`) styles ପ୍ରବେଶ କରାଯାଏ। **Auto-Clarity Bypass**
toggle ଟି **Caveman** page (`/dashboard/context/caveman`) ର **Output Mode** card ରେ
ରହିଛି। Programmatically, compression config ଚୟନକୁ ଏହିପରି ସଂରକ୍ଷଣ କରେ:

```json
{
  "outputStyles": [
    { "id": "i-have-adhd", "level": "full" },
    { "id": "less-code", "level": "lite" }
  ]
}
```

Back-compat: `outputStyles` ଖାଲି ଥିବା ପର୍ଯ୍ୟନ୍ତ, legacy
`cavemanOutputMode.enabled` setting `cavemanOutputMode.intensity` ରେ `terse-prose`
ସହିତ map ହୁଏ। ତା’ପରେ block ଟି `[OmniRoute Output Styles]` marker ସହିତ ଆରମ୍ଭ
ହୁଏ, ଯେଉଁଠାରେ legacy `applyCavemanOutputMode()` injector
`[OmniRoute Caveman Output Mode]` ଲେଖୁଥିଲା। marker ତଳେ, text ଟି en, pt-BR, es,
de, fr, it, ru, id ଏବଂ vi ରେ legacy injection ସହିତ ମେଳ ଖାଏ; ja ଏବଂ zh ରେ
boundaries clause ପୂର୍ବରୁ ଏହା ଗୋଟିଏ ଅତିରିକ୍ତ space ଧାରଣ କରେ। `terse-prose`
pt-BR, es, de, fr, it, ru, zh, ja, id ଏବଂ vi କୁ ଅନୁବାଦ ହୁଏ, ତେଣୁ ସମାଧାନ
ହୋଇଥିବା ଭାଷା `hu` ଥିବା request କୁ ଇଂରାଜୀ text ମିଳେ, ଯେଉଁଠାରେ legacy
injector ଏହାର Hungarian text ବ୍ୟବହାର କରୁଥିଲା।

Output-style ଭାଷା ଚୟନ (`resolveOutputStyleLanguage()` in
`outputStyles/apply.ts`): `languageConfig.enabled` on ଥିଲେ, `autoDetect` request ର
`messages` array ରୁ text ଥିବା ସର୍ବଶେଷ user message କୁ sample କରେ (string content,
କିମ୍ବା ଏହାର content parts ର `text`) ଏବଂ ତାହା ଉପରେ Caveman engine ର detector
(`detectCompressionLanguage()`) ଚଲାଏ। Han characters ଥିବା ଏବଂ kana ନଥିବା text
ପାଇଁ detector `zh` ଫେରାଏ; ଅନ୍ୟଥା `it`, `pt-BR`, `es`, `de`, `fr`, `ru`, `ja`,
`hu` ଏବଂ `id` ମଧ୍ୟରୁ ଯେଉଁଟିର ସର୍ବାଧିକ hint matches ଥାଏ ତାହାକୁ ଫେରାଏ, ଏବଂ
କୌଣସି match ନଥିଲେ `en` ଫେରାଏ — ଏହା ଯେଉଁ text କୁ classify କରିପାରେ ନାହିଁ,
ସେଥିପାଇଁ `defaultLanguage` ନୁହେଁ, ସର୍ବଦା ଇଂରାଜୀ ମିଳେ, ଏବଂ styles ରେ `vi`
text ଥିଲେ ମଧ୍ୟ `vi` କେବେ ଚିହ୍ନଟ ହୁଏ ନାହିଁ। Responses API body ନିଜର turns କୁ
`input` ରେ ରଖେ, ଯାହା sample କରାଯାଏ ନାହିଁ, ତେଣୁ ଏହା ପ୍ରଥମେ
`defaultLanguage`, ତା’ପରେ ଇଂରାଜୀ ପାଏ। `messages` ର କୌଣସି user message ରେ text
ନଥିଲେ, କିମ୍ବା `autoDetect` off ଥିଲେ, `defaultLanguage` ପ୍ରୟୋଗ ହୁଏ, ତା’ପରେ
ଇଂରାଜୀ। `languageConfig.enabled` off ଥିଲେ, ଭାଷା ଇଂରାଜୀ ହୁଏ — ଯଦି request ପାଇଁ
ଏକ compression combo ପ୍ରୟୋଗ ନହୁଏ (request ର routing combo କୁ ନ୍ୟସ୍ତ ଏକ combo,
କିମ୍ବା built-in stacked pipeline ପାଇଁ chatCore fallback କରୁଥିବା default
compression combo): ଏକ combo ପ୍ରୟୋଗ କରିବା ସେହି request ପାଇଁ
`languageConfig.enabled` କୁ on କରେ ଏବଂ combo ର language packs ରୁ
`defaultLanguage` ସେଟ୍ କରେ (saved value ଟି combo ର packs ମଧ୍ୟରୁ ଗୋଟିଏ ହୋଇଥିଲେ
ସେହି value, ଅନ୍ୟଥା combo ର ପ୍ରଥମ pack, ଯାହାର default `en`), ଯେତେବେଳେ saved
`autoDetect` (default ଭାବେ on) ତଥାପି ପ୍ରୟୋଗ ହୁଏ। Caveman input engine ନିଜର
rule-pack ଭାଷାକୁ ଭିନ୍ନ ଭାବରେ ବାଛେ — ପ୍ରତ୍ୟେକ text part ଅନୁସାରେ ଏବଂ,
auto-detect off ଥିଲେ, `enabledPacks` ଉପରେ ନିର୍ଭରଶୀଳ ଭାବେ।

ଶୈଳୀ × ଭାଷା ମ୍ୟାଟ୍ରିକ୍ସକୁ
`tests/unit/compression/output-styles-i18n-matrix.test.ts` ଦ୍ୱାରା ପିନ୍ କରାଯାଇଛି: ପ୍ରତ୍ୟେକ କ୍ୟାଟାଲଗ୍ ଶୈଳୀ ପାଇଁ ପରୀକ୍ଷଣର `BASELINE_LANGUAGES`ରେ ଗୋଟିଏ
ଏଣ୍ଟ୍ରି ଆବଶ୍ୟକ; locale-gated ନଥିବା ଏକ ଶୈଳୀ ସହିତ
pt-BR ଅନୁବାଦ ଦିଆଯିବା ଆବଶ୍ୟକ (locale-gated `terse-cjk` ଏହି ନିୟମରୁ ମୁକ୍ତ), ଯଦି ତାହା
`KNOWN_ENGLISH_ONLY`ରେ ତାଲିକାଭୁକ୍ତ ହୋଇନଥାଏ, ଯେଉଁଥିରେ କେବଳ ଆଦୌ କୌଣସି ଅନୁବାଦ ନଥିବା ଶୈଳୀ ରହିପାରିବ —
ତାଲିକାଭୁକ୍ତ କୌଣସି ଶୈଳୀର ଯେକୌଣସି ଅନୁବାଦ ଥିଲେ ପରୀକ୍ଷଣ ବିଫଳ ହୁଏ; ଏବଂ ଏକ ଶୈଳୀ ତାହାର `BASELINE_LANGUAGES` ଏଣ୍ଟ୍ରିରେ ତାଲିକାଭୁକ୍ତ ଭାଷା ହରାଇଲେ ପରୀକ୍ଷଣରେ ବିଫଳ ହୁଏ। ଏକ ଶୈଳୀ ଯୋଡ଼ିବା ପାଇଁ,
[EXTENDING_COMPRESSION.md](./EXTENDING_COMPRESSION.md#adding-an-output-style) ଦେଖନ୍ତୁ।

### ଟୁଲ୍ ଫଳାଫଳ ସଙ୍କୋଚନ

`open-sse/services/compression/toolResultCompressor.ts`ରେ ଥିବା `compressToolResult()`
**5ଟି କୌଶଳ** ବ୍ୟବହାର କରି ଟୁଲ୍-ଫଳାଫଳ ପାଠ୍ୟକୁ ସଙ୍କୋଚିତ କରେ। ଏହା ନିମ୍ନ କ୍ରମରେ ସେଗୁଡ଼ିକୁ ଚେଷ୍ଟା କରେ, ଏବଂ
ଯାହାର ଯାଞ୍ଚ ବିଷୟବସ୍ତୁ ସହିତ ମେଳ ଖାଏ, ସେହି ପ୍ରଥମ ସକ୍ଷମ କୌଶଳ ଫଳାଫଳ ନିର୍ଦ୍ଧାରଣ କରେ:

1. **`fileContent`**: 3 କିମ୍ବା ଅଧିକ ଧାଡ଼ିର ବିଷୟବସ୍ତୁ, ଯେଉଁଥିରେ ଅତି କମରେ ଗୋଟିଏ ଧାଡ଼ି, ପ୍ରାରମ୍ଭିକ
   ଇଣ୍ଡେଣ୍ଟେସନ୍କୁ ଅଣଦେଖା କରି, `import `, `export `, `function `, `class `,
   `const `, `let `, `var ` କିମ୍ବା `return ` (କୀୱାର୍ଡ ସହିତ ଗୋଟିଏ ସ୍ପେସ୍)ରୁ ଆରମ୍ଭ ହୁଏ, ଅଥବା `if`,
   `for` କିମ୍ବା `while` ପରେ `(` କିମ୍ବା ` (` ଥାଏ; ଏହା ପ୍ରଥମ 20ଟି ଏବଂ ଶେଷ 5ଟି ଧାଡ଼ି ରଖେ ଏବଂ
   ବାଦ ଦିଆଯାଇଥିବା ମଧ୍ୟଭାଗକୁ ଚିହ୍ନିତ କରେ।
2. **`grepSearch`**: `<path>:<digits>:` ଫର୍ମର ଅତି କମରେ ଗୋଟିଏ ଧାଡ଼ି ଥିବା ବିଷୟବସ୍ତୁ,
   ଯେଉଁଠାରେ ପ୍ରଥମ କୋଲନ୍ ପୂର୍ବର ପାଠ୍ୟରେ କୌଣସି ହ୍ୱାଇଟ୍ସ୍ପେସ୍ ନଥାଏ; ଏହା କେବଳ ସେହି ଧାଡ଼ିଗୁଡ଼ିକୁ ରଖେ,
   ସର୍ବାଧିକ 30ଟି ପର୍ଯ୍ୟନ୍ତ, ଏବଂ ତାହାପରେ ଅନ୍ୟ ମେଳଗୁଡ଼ିକର ଗଣନା ଓ ମେଳ ହୋଇଥିବା ଫାଇଲ୍ଗୁଡ଼ିକର ତାଲିକା ଦିଏ;
   ଅନ୍ୟ ସମସ୍ତ ଧାଡ଼ି ବାଦ ଦିଆଯାଏ। କୌଶଳଟିକୁ ଟ୍ରିଗର୍ କରିବା ପାଇଁ ଏଭଳି ଗୋଟିଏ ଧାଡ଼ି ଯଥେଷ୍ଟ, ତେଣୁ
   `12:30:45` ପରି ଟାଇମ୍ଷ୍ଟାମ୍ପରୁ ଆରମ୍ଭ ହେଉଥିବା ଲଗ୍ ଧାଡ଼ିକୁ ମଧ୍ୟ ଗଣାଯାଏ।
3. **`shellOutput`**: ANSI CSI କ୍ରମ (`ESC[` ପରେ ଅଙ୍କ କିମ୍ବା
   ସେମିକୋଲନ୍, ତାହାପରେ ଗୋଟିଏ ଅକ୍ଷର, ଯେପରି ରଙ୍ଗ କୋଡ୍ରେ ଥାଏ) କିମ୍ବା ପାଠ୍ୟର ଯେକୌଣସି ସ୍ଥାନରେ ହ୍ୱାଇଟ୍ସ୍ପେସ୍ ପରେ ଥିବା `$` ଧାରଣ କରୁଥିବା ଆଉଟପୁଟ୍
   ସେହି କ୍ରମଗୁଡ଼ିକୁ ହରାଏ (ଅନ୍ୟ ଏସ୍କେପ୍, ଯେପରି `ESC[?25l` କିମ୍ବା
   OSC ୱିଣ୍ଡୋ-ଶୀର୍ଷକ କ୍ରମ, ରଖାଯାଏ) ଏବଂ ଏହାର ଶେଷ 50ଟି ଧାଡ଼ି ରଖେ, ଯେଉଁଥିରେ କ୍ରମାଗତ
   ପୁନରାବୃତ୍ତ ଧାଡ଼ିଗୁଡ଼ିକୁ ଏକତ୍ର କରାଯାଏ। ଏହି ଯାଞ୍ଚଟି `json` ଏବଂ `errorMessage` ପୂର୍ବରୁ ଚାଲୁଥିବାରୁ,
   ଏଭଳି `$` ଥିବା JSON କିମ୍ବା ତ୍ରୁଟି ଆଉଟପୁଟ୍ `shellOutput` ଚାଲୁ ଥିବାବେଳେ
   କେବେ ସେଗୁଡ଼ିକ ପର୍ଯ୍ୟନ୍ତ ପହଞ୍ଚେ ନାହିଁ।
4. **`json`**: 2,000 ଅକ୍ଷରରୁ ଅଧିକ ଏକ JSON ପେଲୋଡ୍, ଯାହା `{` କିମ୍ବା `[`ରୁ ଆରମ୍ଭ ହୁଏ (ଇଚ୍ଛାଧୀନ
   ହ୍ୱାଇଟ୍ସ୍ପେସ୍ ପରେ) ଏବଂ ପାର୍ସ ହୁଏ, ତାହାକୁ ସାରାଂଶିତ କରାଯାଏ: 7ଟିରୁ ଅଧିକ ଆଇଟମ୍ର ଏକ ଆରେ
   ତାହାର ପ୍ରଥମ 5ଟି ଓ ଶେଷ 2ଟି ଆଇଟମ୍ ଏବଂ ମୋଟ ଗଣନା ରଖେ, ଏବଂ ଗୋଟିଏ ଅବଜେକ୍ଟ ତାହାର ପ୍ରଥମ 20ଟି
   କୀ ରଖେ; ପ୍ରତ୍ୟେକ ନେଷ୍ଟେଡ୍ ଅବଜେକ୍ଟ କିମ୍ବା ଆରେ ମୂଲ୍ୟକୁ `{…N keys}` ପ୍ଲେସ୍ହୋଲ୍ଡର୍ରେ
   ବଦଳାଯାଏ (ଆରେ ପାଇଁ N ହେଉଛି ତାହାର ଦୈର୍ଘ୍ୟ) ଏବଂ `_remaining_<N>_keys` ମାର୍କର୍ ପ୍ରଥମ 20ଟି ପରେ
   ବାଦ ଦିଆଯାଇଥିବା କୀଗୁଡ଼ିକୁ ଗଣନା କରେ। ସ୍କେଲାର୍ ମୂଲ୍ୟଗୁଡ଼ିକ ସମ୍ପୂର୍ଣ୍ଣ ଭାବେ କପି ହୁଏ, ତେଣୁ
   କୌଣସି ନେଷ୍ଟେଡ୍ ମୂଲ୍ୟ ନଥିବା 20 କିମ୍ବା ତାଠାରୁ କମ୍ କୀର ଏକ ଅବଜେକ୍ଟକୁ କେବଳ ପୁନଃ-ଇଣ୍ଡେଣ୍ଟ କରାଯାଏ —
   ଏକ ମିନିଫାଇଡ୍ ଅବଜେକ୍ଟରେ ଅକ୍ଷର ବଢ଼ିଯାଏ ଏବଂ ତାହା ଅପରିବର୍ତ୍ତିତ ରହେ।
5. **`errorMessage`**: ଯେକୌଣସି ସ୍ଥାନରେ ଏବଂ ଅକ୍ଷରର ଯେକୌଣସି କେସ୍ରେ `error:`,
   `error ` (ଶବ୍ଦ ପରେ ଗୋଟିଏ ସ୍ପେସ୍, ଯେପରି `no error found`), `[error]`,
   `exception:`, `exception `, `[exception]` କିମ୍ବା `traceback` ଧାରଣ କରୁଥିବା ଆଉଟପୁଟ୍ ତାହାର ପ୍ରଥମ ଧାଡ଼ି,
   ପରବର୍ତ୍ତୀ 10ଟି ଧାଡ଼ି ଏବଂ ଶେଷ 3ଟି ଧାଡ଼ି ରଖେ, ଏବଂ ସେଗୁଡ଼ିକ ମଧ୍ୟର ଧାଡ଼ି ସ୍ଥାନରେ
   `… [N frames elided] …` ମାର୍କର୍ ରଖେ। ପ୍ରଥମ ଧାଡ଼ି ପରେ 13ଟିରୁ ଅଧିକ ଧାଡ଼ି ଥିଲେ ହିଁ ମାର୍କର୍ ଦେଖାଯାଏ,
   ତେଣୁ 14ଟି କିମ୍ବା ତାଠାରୁ କମ୍ ଧାଡ଼ିର ତ୍ରୁଟି ଆଉଟପୁଟ୍ ସଂକ୍ଷିପ୍ତ ହୁଏ ନାହିଁ (12 କିମ୍ବା 13ଟି ଧାଡ଼ିରେ
   ଶେଷ 3ଟି ଧାଡ଼ି ପୂର୍ବରୁ ରଖାଯାଇଥିବା ଧାଡ଼ିକୁ ପୁନରାବୃତ୍ତ କରେ)।

ଗୋଟିଏ କୌଶଳ ମେଳ ହେବା ପରେ, ତାହା କିଛି ସଞ୍ଚୟ ନ କଲେ ମଧ୍ୟ, ପରବର୍ତ୍ତୀ କୌଶଳଗୁଡ଼ିକୁ
ଚେଷ୍ଟା କରାଯାଏ ନାହିଁ। ଯେତେବେଳେ ମେଳ ହୋଇଥିବା କୌଶଳ କୌଣସି ଆନୁମାନିକ ଟୋକେନ୍ ସଞ୍ଚୟ କରେ ନାହିଁ (ଦୈର୍ଘ୍ୟ ÷ 4, ଉପରକୁ ପୂର୍ଣ୍ଣାଙ୍କିତ) —
ଉଦାହରଣ ସ୍ୱରୂପ 25 କିମ୍ବା ତାଠାରୁ କମ୍ ଧାଡ଼ିର ଏକ କୋଡ୍-ସଦୃଶ ଫାଇଲ୍, କିମ୍ବା 7 କିମ୍ବା ତାଠାରୁ କମ୍ ଆଇଟମ୍ ଥିବା 2,000
ଅକ୍ଷରରୁ ଅଧିକ ଏକ JSON ଆରେ — ତେବେ aggressive ଇଞ୍ଜିନ୍ ମୂଳ ଟୁଲ୍
ଫଳାଫଳକୁ ରଖେ: ଉଭୟ କଲର୍ (`compressAggressive()` ଏବଂ `compressAnthropicToolResultBlock()`)
`saved` 0 କିମ୍ବା ତାଠାରୁ କମ୍ ହେଲେ ମୂଳଟିକୁ ରଖନ୍ତି, ଯେତେବେଳେ `compressToolResult()` ନିଜେ ତଥାପି
ସେହି କୌଶଳର ଆଉଟପୁଟ୍ ଫେରାଏ। ଟୁଲ୍-ଫଳାଫଳ ପଦକ୍ଷେପଟି ଅନ୍ତିମ ନୁହେଁ:
ଇଞ୍ଜିନ୍ର ଫଲ୍ବ୍ୟାକ୍ ସାରାଂଶକାରୀ ତଥାପି 8,192 ଅକ୍ଷରରୁ ଅଧିକ ଏକ `tool` କିମ୍ବା `function` ସନ୍ଦେଶକୁ
ସଂକ୍ଷିପ୍ତ କରିପାରେ (`maxTokensPerMessage`, 2,048, ଗୁଣିତ 4)।

#### କେବେ ବ୍ୟବହାର କରିବେ

ଟୁଲ୍ ଫଳାଫଳ ସଙ୍କୋଚନ aggressive ଇଞ୍ଜିନ୍ର ପଦକ୍ଷେପ 1 (`open-sse/services/compression/aggressive.ts`ରେ ଥିବା `compressAggressive()`),
ତେଣୁ ଏହା Aggressive ମୋଡ୍ରେ ଏବଂ ଏକ ଷ୍ଟାକ୍ଡ ପାଇପ୍ଲାଇନ୍ର `aggressive` ପଦକ୍ଷେପରେ ଚାଲେ। ଏହା OpenAI-ଆକୃତିର `tool` ଏବଂ `function`
ସନ୍ଦେଶଗୁଡ଼ିକୁ ଏବଂ Anthropic `tool_result` ବ୍ଲକ୍ଗୁଡ଼ିକ ଭିତରର ପାଠ୍ୟକୁ ସଙ୍କୋଚିତ କରେ। ପ୍ରତ୍ୟେକ କୌଶଳ ପାଇଁ
`aggressive.toolStrategies` ଅଧୀନରେ ନିଜସ୍ୱ ସ୍ୱିଚ୍ ଅଛି, ଯାହା ଡିଫଲ୍ଟ ଭାବରେ ସବୁ ଚାଲୁ ଥାଏ। ଡ୍ୟାସ୍ବୋର୍ଡରେ,
ସଙ୍କୋଚନ ଚାଲୁ ଥିବାବେଳେ ଏବଂ ଡିଫଲ୍ଟ ମୋଡ୍ Aggressive ଥିବାବେଳେ ସ୍ୱିଚ୍ଗୁଡ଼ିକ Caveman ପୃଷ୍ଠାର **Advanced** ଭ୍ୟୁରେ ଥାଏ।

### ଷ୍ଟାକ୍ଡ ପାଇପ୍ଲାଇନ୍

ଷ୍ଟାକ୍ଡ ମୋଡ୍ **ଏକାଧିକ ଇଞ୍ଜିନ୍କୁ କ୍ରମାନୁସାରେ** ଚଲାଏ — ସାଧାରଣତଃ ପ୍ରଥମେ RTK
(ଟୁଲ୍ ଆଉଟପୁଟ୍ରେ 60-90% ସଞ୍ଚୟ), ତାହାପରେ ଅବଶିଷ୍ଟ ପାଠ୍ୟରେ Caveman (~46% ଇନ୍ପୁଟ୍
ସଞ୍ଚୟ)। ମିଳିତ ଭାବେ, ତାହା ହେଉଛି **78-95% ଯୋଗ୍ୟ ପରିସର** (ଉପରେ ଥିବା Upstream Savings Math ଦେଖନ୍ତୁ):
`1 - (1 - 0.60..0.90) × (1 - 0.46)`ର ହାରାହାରି ≈89%।

#### ଏହା କିପରି କାମ କରେ

```
ଇନ୍ପୁଟ୍ (1000 ଟୋକେନ୍)
  → RTK (କମାଣ୍ଡ-ସଚେତନ ଫିଲ୍ଟର୍) → 200 ଟୋକେନ୍
    → Caveman (ଅନାବଶ୍ୟକ ପାଠ୍ୟ ଅପସାରଣ) → 108 ଟୋକେନ୍
  → ଆଉଟପୁଟ୍ (108 ଟୋକେନ୍, ~89% ସଞ୍ଚୟ)
```

#### କେବେ ବ୍ୟବହାର କରିବେ

ନିମ୍ନଲିଖିତ ପାଇଁ ଷ୍ଟାକ୍ଡ ମୋଡ୍ ବ୍ୟବହାର କରନ୍ତୁ:

- ଟୁଲ୍-ପ୍ରଧାନ ୱର୍କଫ୍ଲୋ (ଏଜେଣ୍ଟିକ୍ କୋଡିଂ, ଗବେଷଣା)
- ବ୍ୟୟ-ସମ୍ବେଦନଶୀଳ ବ୍ୟାଚ୍ ପ୍ରକ୍ରିୟାକରଣ
- ଯେତେବେଳେ ଆପଣଙ୍କୁ ସର୍ବାଧିକ ଟୋକେନ୍ ସଞ୍ଚୟ ଆବଶ୍ୟକ

ଷ୍ଟାକ୍ଡ ପାଇପ୍ଲାଇନ୍ଗୁଡ଼ିକୁ ଗ୍ଲୋବାଲ୍ `stackedPipeline` ସଙ୍କୋଚନ
ସେଟିଂ ମାଧ୍ୟମରେ, କିମ୍ବା ଏକ ରାଉଟିଂ କମ୍ବୋକୁ ନ୍ୟସ୍ତ ନାମିତ ସଙ୍କୋଚନ କମ୍ବୋ ମାଧ୍ୟମରେ ବିନ୍ୟାସ କରାଯାଏ (ଉପରେ ଥିବା
Per-Combo Override ଦେଖନ୍ତୁ) — କୌଣସି auto-combo `modePack` ମାଧ୍ୟମରେ ନୁହେଁ (ସେହି ଫିଲ୍ଡ କେବଳ
auto-combo ମଡେଲ୍ ଚୟନର ଓଜନକୁ ପୁନଃନିର୍ଦ୍ଧାରଣ କରେ, ଏବଂ `stacked` ଏକ ବୈଧ ପ୍ୟାକ୍ ନାମ ନୁହେଁ)।

---

## କମ୍ପ୍ରେସନ୍ କମ୍ବୋ ଓଭରରାଇଡ୍

ବିଭିନ୍ନ ବ୍ୟବହାର ପରିସ୍ଥିତି ପାଇଁ ଆଚରଣକୁ ସୂକ୍ଷ୍ମ ଭାବରେ ସମନ୍ୱୟ କରିବାକୁ ଆପଣ **ପ୍ରତ୍ୟେକ କମ୍ବୋ ପାଇଁ** ଗ୍ଲୋବାଲ୍ କମ୍ପ୍ରେସନ୍ ମୋଡ୍କୁ ଓଭରରାଇଡ୍ କରିପାରିବେ:

```json
{
  "id": "coding-combo",
  "strategy": "priority",
  "config": {
    "weights": { "taskFit": 0.5 },
    "modePack": "quality-first"
  },
  "compressionOverride": "aggressive"
}
```

ଏହା ନିମ୍ନଲିଖିତ କ୍ଷେତ୍ରରେ ଉପଯୋଗୀ:

- **କୋଡିଂ କମ୍ବୋ**: ଦୀର୍ଘ ସେସନ୍ ପାଇଁ `aggressive` ମୋଡ୍ ବ୍ୟବହାର କରନ୍ତୁ
- **ଦ୍ରୁତ ପ୍ରଶ୍ନୋତ୍ତର କମ୍ବୋ**: ଦ୍ରୁତ ପ୍ରତିକ୍ରିୟା ପାଇଁ `lite` ମୋଡ୍ ବ୍ୟବହାର କରନ୍ତୁ
- **ଅଧିକ ଟୁଲ୍-ଆଧାରିତ କମ୍ବୋ**: ସର୍ବାଧିକ ସଞ୍ଚୟ ପାଇଁ `stacked` ମୋଡ୍ ବ୍ୟବହାର କରନ୍ତୁ
- **ପ୍ରୋଡକ୍ସନ୍ କମ୍ବୋ**: କ୍ୟାସିଂ ପ୍ରଦାନକାରୀଙ୍କ ପାଇଁ ଓଭରରାଇଡ୍ ବନ୍ଦ ରଖନ୍ତୁ — ସର୍ବଦା ସକ୍ରିୟ
  କ୍ୟାସ୍-ସଚେତନ ସମନ୍ୱୟ `aggressive`/`ultra`କୁ ସ୍ୱୟଂଚାଳିତ ଭାବରେ `standard`କୁ ଡାଉନ୍ଗ୍ରେଡ୍ କରେ
  (ଚୟନଯୋଗ୍ୟ `cache-aware` ମୋଡ୍ ନାହିଁ)

---

## ଏହା ମଧ୍ୟ ଦେଖନ୍ତୁ

- [ପରିବେଶ କନଫିଗ୍](../reference/ENVIRONMENT.md) — କମ୍ପ୍ରେସନ୍ ପରିବେଶ ଭେରିଏବଲ୍ଗୁଡ଼ିକ
- [ଆର୍କିଟେକ୍ଚର୍ ଗାଇଡ୍](../architecture/ARCHITECTURE.md) — କମ୍ପ୍ରେସନ୍ ପାଇପ୍ଲାଇନ୍ର ଆଭ୍ୟନ୍ତରୀଣ ବିବରଣୀ
- [ବ୍ୟବହାରକାରୀ ଗାଇଡ୍](../guides/USER_GUIDE.md) — କମ୍ପ୍ରେସନ୍ ସହିତ ଆରମ୍ଭ କରିବା
- [RTK କମ୍ପ୍ରେସନ୍](./RTK_COMPRESSION.md) — RTK ଫିଲ୍ଟର୍, ବିଶ୍ୱାସ ମଡେଲ୍, ଯାଞ୍ଚ ଗେଟ୍, କଞ୍ଚା-ଆଉଟ୍ପୁଟ୍ ପୁନରୁଦ୍ଧାର
- [କମ୍ପ୍ରେସନ୍ ଇଞ୍ଜିନ୍](./COMPRESSION_ENGINES.md) — Caveman, RTK, stacked, APIs, MCP, ଡ୍ୟାସ୍ବୋର୍ଡ
- [କମ୍ପ୍ରେସନ୍ ନିୟମ ଫର୍ମାଟ୍](./COMPRESSION_RULES_FORMAT.md) — JSON ରୁଲ୍-ପ୍ୟାକ୍ ଫର୍ମାଟ୍
- [କମ୍ପ୍ରେସନ୍ ଭାଷା ପ୍ୟାକ୍](./COMPRESSION_LANGUAGE_PACKS.md) — ଭାଷା-ନିର୍ଦ୍ଦିଷ୍ଟ Caveman ନିୟମଗୁଡ଼ିକ