@agent-native/core 0.100.1 → 0.101.2

package/docs/content/locales/fr-FR/pr-visual-recap.mdx

@@ -102,13 +102,13 @@ explicitement à tout moment :
 npx @agent-native/core@latest skills add visual-plan --with-github-action
 ```
 
-Cela installe la compétence `visual-plan` (qui inclut la compétence `visual-recap` exécutée par l'action) et écrit `.github/workflows/pr-visual-recap.yml` dans votre dépôt. Le flux de travail appelle **les sous-commandes CLI publiées** via `npx @agent-native/core@latest recap <subcommand>` — notamment `gate`, `collect-diff`, `block-reference`, `scan`, `build-prompt`, `publish`, `shot`, `comment`, `check` et `usage` — afin que rien ne soit copié dans votre dépôt en tant que scripts d'assistance. `setup` et `doctor` sont les assistants interactifs que vous exécutez localement ; `gate` est l'étape de sécurité que le flux de travail exécute avant chaque récapitulatif.
+Cela installe la compétence `visual-plan` (qui inclut la compétence `visual-recap` exécutée par l'action) et écrit `.github/workflows/pr-visual-recap.yml` dans votre dépôt. Le flux de travail appelle **les sous-commandes CLI publiées** via `npx @agent-native/recap-cli@latest recap <subcommand>` — notamment `gate`, `collect-diff`, `block-reference`, `scan`, `build-prompt`, `publish`, `shot`, `comment`, `check` et `usage` — afin que rien ne soit copié dans votre dépôt en tant que scripts d'assistance. `setup` et `doctor` sont les assistants interactifs que vous exécutez localement ; `gate` est l'étape de sécurité que le flux de travail exécute avant chaque récapitulatif.
 
 Ensuite, exécutez l'assistant de configuration guidée :
 
 ```bash
-npx @agent-native/core@latest recap setup
-npx @agent-native/core@latest recap doctor
+npx @agent-native/recap-cli@latest recap setup
+npx @agent-native/recap-cli@latest recap doctor
 ```
 
 `recap setup` actualise le flux de travail et utilise `gh` pour définir GitHub Actions
@@ -118,7 +118,7 @@ défini. Les valeurs secrètes sont envoyées à `gh` via stdin, et non via les
 le fichier de workflow généré et ouvrez un PR pour le voir s'exécuter.
 
 Par défaut, le workflow crée son invite d'agent à partir de la dernière version groupée
-Conseils `visual-recap` dans `@agent-native/core@latest`, y compris les frères et sœurs
+Conseils `visual-recap` dans `@agent-native/recap-cli@latest`, y compris les frères et sœurs
 fichiers de référence avec lesquels la compétence est livrée. Si votre dépôt personnalise intentionnellement et
 épingle son dossier `visual-recap` validé, définit la variable du référentiel
 `VISUAL_RECAP_SKILL_SOURCE=repo`.
@@ -135,8 +135,8 @@ Par défaut, le workflow s'exécute sur des runners `ubuntu-latest` hébergés p
 Les guillemets JSON sont obligatoires. Cette valeur sélectionne le runner du job complet `recap`. Pour le configurer pendant l'installation guidée, transmettez la même valeur JSON à `--runs-on`, puis validez le workflow et la disponibilité du runner avec `doctor` :
 
 ```bash
-npx @agent-native/core@latest recap setup --runs-on '["self-hosted","linux","x64","visual-recap"]'
-npx @agent-native/core@latest recap doctor
+npx @agent-native/recap-cli@latest recap setup --runs-on '["self-hosted","linux","x64","visual-recap"]'
+npx @agent-native/recap-cli@latest recap doctor
 ```
 
 Le gate léger utilise séparément `ubuntu-latest`. Les dépôts sans runners hébergés par GitHub peuvent définir `VISUAL_RECAP_GATE_RUNS_ON` sur une seule étiquette en texte brut, sans JSON, ou utiliser `--gate-runs-on visual-recap-gate`. L'étiquette personnalisée ne s'applique qu'aux auteurs `OWNER`, `MEMBER` ou `COLLABORATOR` du même dépôt ; les forks et autres auteurs sont forcés sur `ubuntu-latest` et peuvent rester non planifiés si les runners hébergés sont désactivés. Utilisez un runner dédié et de préférence éphémère : le gate standard n'extrait pas l'arborescence de la PR et évalue la logique du workflow ainsi que les métadonnées de la PR.
@@ -160,12 +160,30 @@ Si la variable n'est pas définie, l'action utilise `claude`.
 
 Au-delà du backend, deux variables du référentiel ajustent _comment_ l'agent s'exécute :
 
-- **`VISUAL_RECAP_MODEL`** épingle le modèle transmis au CLI (`--model`) — par exemple `gpt-5.6-sol` pour Codex, ou un identifiant de modèle Claude. Laissez-le non défini pour utiliser le modèle par défaut du CLI.
+- **`VISUAL_RECAP_MODEL`** épingle le modèle transmis au CLI (`--model`) — par exemple `gpt-5.6-luna` pour Codex, un identifiant de modèle Claude, ou `deepseek-chat` pour DeepSeek. Elle est requise pour `openai-compatible`. Pour le backend **Claude**, la laisser non définie utilise désormais par défaut `claude-sonnet-5` ; définissez la variable explicitement pour utiliser un autre modèle Claude, comme le moins cher `claude-haiku-4-5`. Pour le backend **Codex**, la laisser non définie utilise le modèle par défaut du CLI Codex lui-même.
 - **`VISUAL_RECAP_REASONING`** définit la profondeur du raisonnement : `none`, `minimal`, `low`, `medium`, `high` ou `xhigh`. Cela s'applique au backend Codex ; Le raisonnement de Claude est basé sur un modèle, cette variable y est donc ignorée.
 - **`VISUAL_RECAP_SKILL_SOURCE`** contrôle la fraîcheur des invites : `auto`/unset utilise les dernières instructions de compétences groupées, tandis que `repo` s'épingle dans le dossier de compétences `visual-recap` local du dépôt validé.
 
 Par exemple, pour exécuter le récapitulatif sur Codex avec GPT-5.6 Sol avec un raisonnement élevé, définissez les variables du référentiel `VISUAL_RECAP_AGENT=codex`, `VISUAL_RECAP_MODEL=gpt-5.6-sol` et `VISUAL_RECAP_REASONING=high`.
 
+## Coût
+
+Chaque exécution du récapitulatif est une session complète d'agent de codage agentique qui lit un véritable diff, et non un résumé calqué sur un modèle bon marché ; son coût dépend donc du modèle choisi et de la fréquence d'exécution :
+
+- **Une session complète par poussée de PR.** Le déclencheur par défaut se déclenche sur `synchronize`, donc une PR poussée dix fois exécute l'agent dix fois.
+- **La PR entière à chaque fois**, pas seulement les commits depuis la dernière exécution — le coût augmente avec la taille totale de la PR, pas avec la taille incrémentale du diff.
+- **Entrée de diff plafonnée à environ 600 Ko.** Cela borne le pire cas par exécution, mais les diffs volumineux coûtent tout de même sensiblement plus cher que les petits.
+- **Une nouvelle tentative automatique en cas d'échec**, ce qui peut à peu près doubler le coût d'une exécution qui échoue de manière transitoire.
+
+Pour réduire le coût :
+
+- **Épinglez un modèle moins cher.** Pour Claude, définissez `VISUAL_RECAP_MODEL=claude-haiku-4-5` pour les dépôts simples ou petits — c'est le niveau Claude le moins cher ; `claude-sonnet-5` (la valeur par défaut) est le niveau équilibré.
+- **Passez à Codex avec un modèle moins cher.** Définissez `VISUAL_RECAP_AGENT=codex` avec `VISUAL_RECAP_MODEL=gpt-5.6-luna` (le niveau GPT-5.6 le moins cher) ou `gpt-5.6-terra` (niveau intermédiaire), et définissez `VISUAL_RECAP_REASONING=low` pour réduire encore la dépense en jetons de raisonnement. La profondeur de raisonnement ne s'applique qu'à Codex.
+- **Pointez vers un fournisseur compatible OpenAI moins cher.** Définissez `VISUAL_RECAP_AGENT=openai-compatible` avec `VISUAL_RECAP_BASE_URL`/`VISUAL_RECAP_MODEL`/`VISUAL_RECAP_API_KEY` ciblant DeepSeek, Kimi ou tout autre point de terminaison compatible OpenAI.
+- **Récapitulez moins souvent.** Modifiez le `on.pull_request.types` du flux de travail installé de `[opened, synchronize, reopened, ready_for_review, closed]` à `[opened, ready_for_review, closed]` afin qu'il ne récapitule que lorsqu'une PR s'ouvre et lorsqu'elle est fusionnée, au lieu de le faire à chaque poussée.
+
+Chaque exécution enregistre ce qu'elle a réellement dépensé : l'étape `recap usage` du flux de travail associe l'utilisation de jetons et de coût au plan publié, afin que vous puissiez consulter la dépense réelle par exécution plutôt que de deviner.
+
 ## Secrets et variables
 
 Définissez-les dans **Paramètres → Secrets et variables → Actions** de votre référentiel.
@@ -196,11 +214,11 @@ Application Plans.
 
 **Solo : un jeton personnel fonctionne toujours.** Fabriquez-le avec `npx @agent-native/core@latest connect`
 contre votre application Plans. Pour l'application hébergée, ceci écrit également un local
-fichier de jeton de publication que `npx @agent-native/core@latest recap setup` peut lire :
+fichier de jeton de publication que `npx @agent-native/recap-cli@latest recap setup` peut lire :
 
 ```bash
 npx @agent-native/core@latest connect https://plan.agent-native.com --client codex
-npx @agent-native/core@latest recap setup
+npx @agent-native/recap-cli@latest recap setup
 ```
 
 Si vous préférez une configuration manuelle, collez le jeton dans le secret GitHub. Utilisez un
@@ -209,16 +227,16 @@ vrai jeton.
 
 ### Facultatif (uniquement si vous modifiez les valeurs par défaut)
 
-| Secret / variable        | Par défaut                         | Quand vous en avez besoin                                                                                                                                       |
-| ------------------------ | ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `OPENAI_API_KEY`         | —                                  | Secret. Configurez-le avec `VISUAL_RECAP_AGENT=codex` pour exécuter le récapitulatif avec Codex à la place.                                                     |
-| `VISUAL_RECAP_AGENT`     | `claude`                           | Variable. Sélectionne le backend de l'agent de codage (`claude` ou `codex`).                                                                                    |
-| `VISUAL_RECAP_MODEL`     | valeur par défaut de chaque CLI    | Variable. Épingle le modèle - par ex. `gpt-5.6-sol` pour Codex, ou un identifiant de modèle Claude. Unset utilise la valeur par défaut du CLI.                  |
-| `VISUAL_RECAP_REASONING` | valeur par défaut de chaque modèle | Variable. Profondeur de raisonnement : `none`, `minimal`, `low`, `medium`, `high` ou `xhigh`. S'applique au backend Codex.                                      |
-| `RECAP_CLI_VERSION`      | `latest`                           | Variable. Épingle la version `@agent-native/core` CLI installée par le flux de travail, par ex. `1.5.0`. Voir [Version pinning](#version-pinning-copy-variant). |
-| `PLAN_RECAP_APP_URL`     | `https://plan.agent-native.com`    | Secret. Uniquement lors de l'auto-hébergement de l'application Plans à une origine différente.                                                                  |
+| Secret / variable        | Par défaut                                                        | Quand vous en avez besoin                                                                                                                                                                                                                                                                                                                               |
+| ------------------------ | ----------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `OPENAI_API_KEY`         | —                                                                 | Secret. Configurez-le avec `VISUAL_RECAP_AGENT=codex` pour exécuter le récapitulatif avec Codex à la place.                                                                                                                                                                                                                                             |
+| `VISUAL_RECAP_AGENT`     | `claude`                                                          | Variable. Sélectionne le backend de l'agent de codage (`claude` ou `codex`).                                                                                                                                                                                                                                                                            |
+| `VISUAL_RECAP_MODEL`     | `claude-sonnet-5` pour Claude ; requis pour le backend compatible | Variable. Identifiant du modèle du fournisseur pour les backends compatibles OpenAI (requis dans ce cas). Pour Claude, non défini utilise désormais par défaut `claude-sonnet-5` — définissez-le pour le remplacer, par ex. `claude-haiku-4-5` pour le niveau le moins cher. Pour Codex, non défini utilise la valeur par défaut du CLI Codex lui-même. |
+| `VISUAL_RECAP_REASONING` | valeur par défaut de chaque modèle                                | Variable. Profondeur de raisonnement : `none`, `minimal`, `low`, `medium`, `high` ou `xhigh`. S'applique au backend Codex.                                                                                                                                                                                                                              |
+| `RECAP_CLI_VERSION`      | `latest`                                                          | Variable. Épingle la version `@agent-native/recap-cli` CLI installée par le flux de travail, par ex. `1.5.0`. Voir [Version pinning](#version-pinning-copy-variant).                                                                                                                                                                                    |
+| `PLAN_RECAP_APP_URL`     | `https://plan.agent-native.com`                                   | Secret. Uniquement lors de l'auto-hébergement de l'application Plans à une origine différente.                                                                                                                                                                                                                                                          |
 
-Le workflow détecte automatiquement comment appeler son assistant CLI (source locale dans ce monorepo, le `@agent-native/core` publié ailleurs), il n'y a donc aucune variable `RECAP_CLI` à définir.
+Le workflow détecte automatiquement comment appeler son assistant CLI (source locale dans ce monorepo, le `@agent-native/recap-cli` publié ailleurs), il n'y a donc aucune variable `RECAP_CLI` à définir.
 
 ## Capture d'écran en ligne dans le commentaire
 
@@ -360,9 +378,9 @@ récapitulatif sans envoyer le contenu du récapitulatif à la base de données
 même flux d'assistance localement en mode fichiers locaux :
 
 ```bash
-npx @agent-native/core@latest recap collect-diff --base main --head HEAD --out recap.diff --stat recap.stat
-npx @agent-native/core@latest recap scan --diff recap.diff
-npx @agent-native/core@latest recap build-prompt --pr 123 --diff recap.diff --stat recap.stat --local-files --local-dir plans/pr-123-visual-recap
+npx @agent-native/recap-cli@latest recap collect-diff --base main --head HEAD --out recap.diff --stat recap.stat
+npx @agent-native/recap-cli@latest recap scan --diff recap.diff
+npx @agent-native/recap-cli@latest recap build-prompt --pr 123 --diff recap.diff --stat recap.stat --local-files --local-dir plans/pr-123-visual-recap
 ```
 
 Donnez le `recap-prompt.md` généré à votre agent de codage. En mode fichiers locaux
@@ -392,7 +410,7 @@ Le récapitulatif est une aide à la révision superposée au flux normal de rel
 
 ## Épinglage de version (variante de copie) {#version-pinning-copy-variant}
 
-Par défaut, le workflow de copie de variante installe `@agent-native/core@latest` au moment de l'exécution afin que chaque exécution de récapitulation récupère automatiquement le dernier CLI. Si votre CI a besoin d'outils reproductibles, définissez la variable du référentiel **`RECAP_CLI_VERSION`** pour épingler la version installée :
+Par défaut, le workflow de copie de variante installe `@agent-native/recap-cli@latest` au moment de l'exécution afin que chaque exécution de récapitulation récupère automatiquement le dernier CLI. Si votre CI a besoin d'outils reproductibles, définissez la variable du référentiel **`RECAP_CLI_VERSION`** pour épingler la version installée :
 
 1. Accédez aux **Paramètres → Secrets et variables → Actions → Variables** de votre dépôt.
 2. Créez une variable nommée `RECAP_CLI_VERSION` avec une valeur telle que `1.5.0`.
@@ -403,7 +421,7 @@ Pour la variante d'appelant réutilisable, utilisez plutôt l'entrée `cli-versi
 
 ## Liste autorisée d'analyse secrète
 
-Avant de publier un récapitulatif, le workflow exécute `npx @agent-native/core@latest recap scan` pour détecter les secrets probables dans le diff. Tout PR dont la différence correspond à un modèle secret connu est bloqué avec un commentaire explicatif : le récapitulatif n'est pas publié et aucun contenu de différence n'est envoyé à l'agent de codage.
+Avant de publier un récapitulatif, le workflow exécute `npx @agent-native/recap-cli@latest recap scan` pour détecter les secrets probables dans le diff. Tout PR dont la différence correspond à un modèle secret connu est bloqué avec un commentaire explicatif : le récapitulatif n'est pas publié et aucun contenu de différence n'est envoyé à l'agent de codage.
 
 Dans de rares cas, un dépôt contient des appareils de test intentionnels ou des chaînes non secrètes qui ressemblent superficiellement à des modèles secrets (par exemple, une clé d'appareil dans un fichier de test). Pour supprimer un faux positif, créez `.github/recap-scan-allowlist` à la racine de votre référentiel.
 
@@ -437,7 +455,7 @@ La liste blanche n'est consultée que par la porte secrète-scan. Cela n'affecte
 
 ### Pourquoi utiliser la variante réutilisable ?
 
-Le programme d'installation par défaut copie le flux de travail complet d'environ 360 lignes YAML dans votre dépôt (l'option **copier**). C'est le bon choix pour les dépôts à air isolé ou les dépôts qui doivent auditer chaque ligne de ce qui s'exécute. L'inconvénient est que les corrections de bogues et les améliorations ne vous parviennent jamais : vous devez réexécuter `npx @agent-native/core@latest recap setup` manuellement après chaque version.
+Le programme d'installation par défaut copie le flux de travail complet d'environ 360 lignes YAML dans votre dépôt (l'option **copier**). C'est le bon choix pour les dépôts à air isolé ou les dépôts qui doivent auditer chaque ligne de ce qui s'exécute. L'inconvénient est que les corrections de bogues et les améliorations ne vous parviennent jamais : vous devez réexécuter `npx @agent-native/recap-cli@latest recap setup` manuellement après chaque version.
 
 L'option **réutilisable** écrit à la place un appelant mince d'environ 20 lignes. Il délègue à `BuilderIO/agent-native/.github/workflows/pr-visual-recap-reusable.yml` via `uses:`. Chaque appelant récupère automatiquement la dernière logique lors de l'exécution du workflow, sans qu'aucune mise à jour locale ne soit nécessaire.
 
@@ -450,7 +468,7 @@ L'option **réutilisable** écrit à la place un appelant mince d'environ 20 lig
 
 ### Extrait de l'appelant
 
-Voici ce qu'écrit `npx @agent-native/core@latest recap setup --reusable` (ou vous pouvez le coller manuellement) :
+Voici ce qu'écrit `npx @agent-native/recap-cli@latest recap setup --reusable` (ou vous pouvez le coller manuellement) :
 
 ```yaml
 name: PR Visual Recap
@@ -485,7 +503,7 @@ jobs:
       skill-source: ${{ vars.VISUAL_RECAP_SKILL_SOURCE || 'auto' }}
       runs-on: ${{ vars.VISUAL_RECAP_RUNS_ON || '"ubuntu-latest"' }}
       gate-runs-on: ${{ vars.VISUAL_RECAP_GATE_RUNS_ON || 'ubuntu-latest' }}
-      # cli-version: "latest"  # pin to a specific @agent-native/core version
+      # cli-version: "latest"  # pin to a specific @agent-native/recap-cli version
 ```
 
 Les mêmes secrets et variables décrits dans [Secrets and variables](#secrets-and-variables) s'appliquent. L'appelant réutilisable transmet `VISUAL_RECAP_RUNS_ON` via `runs-on` pour le job complet et `VISUAL_RECAP_GATE_RUNS_ON` via l'étiquette simple `gate-runs-on` pour le gate. Les deux utilisent `ubuntu-latest` par défaut.
@@ -494,15 +512,15 @@ Les mêmes secrets et variables décrits dans [Secrets and variables](#secrets-a
 
 ```bash
 # Écrivez l'appelant léger au lieu de la copie complète :
-npx @agent-native/core@latest recap setup --reusable
+npx @agent-native/recap-cli@latest recap setup --reusable
 
 # Ou avec une référence épinglée pour plus de reproductibilité :
-npx @agent-native/core@latest recap setup --reusable --ref v1.2.3
+npx @agent-native/recap-cli@latest recap setup --reusable --ref v1.2.3
 ```
 
 Les deux variantes écrivent le flux de travail dans `.github/workflows/pr-visual-recap.yml`. Si un workflow existant existe déjà et diffère, la commande refuse et vous demande de passer `--force` pour l'écraser.
 
-Après l'écriture, exécutez `npx @agent-native/core@latest recap doctor` comme d'habitude pour confirmer que les secrets sont configurés.
+Après l'écriture, exécutez `npx @agent-native/recap-cli@latest recap doctor` comme d'habitude pour confirmer que les secrets sont configurés.
 
 ### Épinglage de version
 
@@ -512,7 +530,7 @@ Par défaut, l'appelant fait référence à `@main`, qui utilise toujours la der
 uses: BuilderIO/agent-native/.github/workflows/pr-visual-recap-reusable.yml@v1.2.3
 ```
 
-L'entrée `cli-version` contrôle quelle version de `@agent-native/core` CLI s'exécute dans le flux de travail : laissez-la sur `"latest"` pour suivre la version la plus récente, ou épinglez-la à une chaîne de version (par exemple, `"1.5.0"`) pour une reproductibilité totale.
+L'entrée `cli-version` contrôle quelle version de `@agent-native/recap-cli` CLI s'exécute dans le flux de travail : laissez-la sur `"latest"` pour suivre la version la plus récente, ou épinglez-la à une chaîne de version (par exemple, `"1.5.0"`) pour une reproductibilité totale.
 
 ### Contexte de l'événement workflow_call
 

package/docs/content/locales/fr-FR/template-plan.mdx

@@ -212,6 +212,13 @@ Si le premier passage comporte encore des décisions responsables, l'agent peut
 **Formulaire de questions ouvertes** au bas du même plan. Y répondre et envoyer
 l'agent démarre un tour de révision par rapport au plan existant.
 
+## Coût et choix du modèle
+
+Générer un plan ou un récapitulatif exécute une session agentique complète contre le LLM de votre agent de codage, et non un simple remplissage de modèle léger ; le coût dépend donc de la taille du diff ou du plan et du modèle choisi.
+
+- Le modèle de chat par défaut de l'application est Sonnet 5 ; changez-le à tout moment dans les **Paramètres**. Haiku est l'option Claude moins chère, et Luna est l'option moins chère de la famille GPT-5.6.
+- Les récapitulatifs de PR automatisés depuis l'action GitHub s'exécutent séparément de l'application interactive et ont leurs propres réglages de modèle et de coût — voir [PR Visual Recap](/docs/pr-visual-recap) pour `VISUAL_RECAP_MODEL`, `VISUAL_RECAP_AGENT` et `VISUAL_RECAP_REASONING`.
+
 ## Ce que vous pouvez en faire
 
 - **Révision avant mise en œuvre.** React vers les diagrammes, les wireframes, les onglets d'options,

package/docs/content/locales/hi-IN/pr-visual-recap.mdx

@@ -102,13 +102,13 @@ description: "एक GitHub एक्शन जो प्रत्येक प
 npx @agent-native/core@latest skills add visual-plan --with-github-action
 ```
 
-यह `visual-plan` कौशल स्थापित करता है (जिसमें `visual-recap` कौशल शामिल है जो क्रिया चलाता है) और आपके रेपो में `.github/workflows/pr-visual-recap.yml` लिखता है। वर्कफ़्लो `npx @agent-native/core@latest recap <subcommand>` के माध्यम से **प्रकाशित CLI उपकमांड** को कॉल करता है - जिसमें `gate`, `collect-diff`, `block-reference`, `scan`, `build-prompt`, `publish`, `shot`, `comment`, `check`, और शामिल हैं। `usage` - इसलिए आपके रेपो में सहायक स्क्रिप्ट के रूप में कुछ भी कॉपी नहीं किया गया है। `setup` और `doctor` आपके द्वारा स्थानीय स्तर पर चलाए जाने वाले इंटरैक्टिव सहायक हैं; `gate` सुरक्षा-द्वार चरण है जो वर्कफ़्लो प्रत्येक पुनर्कथन से पहले चलता है।
+यह `visual-plan` कौशल स्थापित करता है (जिसमें `visual-recap` कौशल शामिल है जो क्रिया चलाता है) और आपके रेपो में `.github/workflows/pr-visual-recap.yml` लिखता है। वर्कफ़्लो `npx @agent-native/recap-cli@latest recap <subcommand>` के माध्यम से **प्रकाशित CLI उपकमांड** को कॉल करता है - जिसमें `gate`, `collect-diff`, `block-reference`, `scan`, `build-prompt`, `publish`, `shot`, `comment`, `check`, और शामिल हैं। `usage` - इसलिए आपके रेपो में सहायक स्क्रिप्ट के रूप में कुछ भी कॉपी नहीं किया गया है। `setup` और `doctor` आपके द्वारा स्थानीय स्तर पर चलाए जाने वाले इंटरैक्टिव सहायक हैं; `gate` सुरक्षा-द्वार चरण है जो वर्कफ़्लो प्रत्येक पुनर्कथन से पहले चलता है।
 
 फिर निर्देशित सेटअप सहायक चलाएँ:
 
 ```bash
-npx @agent-native/core@latest recap setup
-npx @agent-native/core@latest recap doctor
+npx @agent-native/recap-cli@latest recap setup
+npx @agent-native/recap-cli@latest recap doctor
 ```
 
 `recap setup` वर्कफ़्लो को ताज़ा करता है, GitHub Actions सेट करने के लिए `gh` का उपयोग करता है
@@ -118,7 +118,7 @@ npx @agent-native/core@latest recap doctor
 जनरेट की गई वर्कफ़्लो फ़ाइल और इसे चलाने के लिए एक पीआर खोलें।
 
 डिफ़ॉल्ट रूप से, वर्कफ़्लो नवीनतम बंडल से अपना एजेंट प्रॉम्प्ट बनाता है
-`@agent-native/core@latest` में `visual-recap` मार्गदर्शन, किसी भी भाई-बहन सहित
+`@agent-native/recap-cli@latest` में `visual-recap` मार्गदर्शन, किसी भी भाई-बहन सहित
 संदर्भ फ़ाइलें कौशल भेजती हैं। यदि आपका रेपो जानबूझकर अनुकूलित करता है और
 अपने प्रतिबद्ध `visual-recap` फ़ोल्डर को पिन करता है, रिपॉजिटरी वेरिएबल सेट करता है
 `VISUAL_RECAP_SKILL_SOURCE=repo`.
@@ -135,8 +135,8 @@ npx @agent-native/core@latest recap doctor
 JSON उद्धरण चिह्न आवश्यक हैं। यह मान पूरे `recap` जॉब के रनर को चुनता है। निर्देशित सेटअप के दौरान इसे कॉन्फ़िगर करने के लिए, वही JSON मान `--runs-on` को दें और फिर `doctor` से वर्कफ़्लो और रनर की उपलब्धता सत्यापित करें:
 
 ```bash
-npx @agent-native/core@latest recap setup --runs-on '["self-hosted","linux","x64","visual-recap"]'
-npx @agent-native/core@latest recap doctor
+npx @agent-native/recap-cli@latest recap setup --runs-on '["self-hosted","linux","x64","visual-recap"]'
+npx @agent-native/recap-cli@latest recap doctor
 ```
 
 हल्का गेट अलग से `ubuntu-latest` का उपयोग करता है। GitHub-होस्टेड रनर बंद करने वाली रिपॉजिटरी `VISUAL_RECAP_GATE_RUNS_ON` को JSON के बिना एक सादे लेबल पर सेट कर सकती हैं, या `--gate-runs-on visual-recap-gate` का उपयोग कर सकती हैं। कस्टम लेबल केवल उसी रिपॉजिटरी के `OWNER`, `MEMBER` या `COLLABORATOR` लेखकों के लिए उपयोग होता है; फ़ोर्क और अन्य लेखक `ubuntu-latest` पर भेजे जाते हैं और GitHub-होस्टेड रनर बंद होने पर बिना शेड्यूल रह सकते हैं। समर्पित और संभव हो तो अस्थायी रनर उपयोग करें; मानक गेट PR ट्री को चेक आउट नहीं करता और वर्कफ़्लो लॉजिक व PR मेटाडेटा का मूल्यांकन करता है।
@@ -160,12 +160,30 @@ npx @agent-native/core@latest recap doctor
 
 बैकएंड से परे, दो रिपॉजिटरी वैरिएबल एजेंट को चलाने के तरीके को ट्यून करते हैं:
 
-- **`VISUAL_RECAP_MODEL`** मॉडल को CLI (`--model`) में पिन करता है - उदाहरण के लिए Codex के लिए `gpt-5.6-sol`, या Claude मॉडल आईडी। CLI के अपने डिफ़ॉल्ट मॉडल का उपयोग करने के लिए इसे अनसेट छोड़ दें।
+- **`VISUAL_RECAP_MODEL`** मॉडल को CLI (`--model`) में पिन करता है - उदाहरण के लिए Codex के लिए `gpt-5.6-luna`, कोई Claude मॉडल आईडी, या DeepSeek के लिए `deepseek-chat`। यह `openai-compatible` के लिए आवश्यक है। **Claude** बैकएंड के लिए, इसे अनसेट छोड़ने पर अब डिफ़ॉल्ट रूप से `claude-sonnet-5` उपयोग होता है; किसी दूसरे Claude मॉडल का उपयोग करने के लिए चर को स्पष्ट रूप से सेट करें, जैसे सस्ता `claude-haiku-4-5`। **Codex** बैकएंड के लिए, इसे अनसेट छोड़ने पर Codex CLI का अपना डिफ़ॉल्ट मॉडल उपयोग होता है।
 - **`VISUAL_RECAP_REASONING`** तर्क की गहराई निर्धारित करता है: `none`, `minimal`, `low`, `medium`, `high`, या `xhigh`। यह Codex बैकएंड पर लागू होता है; Claude का तर्क मॉडल-चालित है, इसलिए इस चर को वहां नजरअंदाज कर दिया गया है।
 - **`VISUAL_RECAP_SKILL_SOURCE`** त्वरित ताजगी को नियंत्रित करता है: `auto`/unset नवीनतम बंडल कौशल मार्गदर्शन का उपयोग करता है, जबकि `repo` प्रतिबद्ध रेपो-स्थानीय `visual-recap` कौशल फ़ोल्डर में पिन करता है।
 
 उदाहरण के लिए, Codex पर GPT-5.6 Sol के साथ उच्च तर्क पर रिकैप चलाने के लिए, रिपॉजिटरी वेरिएबल `VISUAL_RECAP_AGENT=codex`, `VISUAL_RECAP_MODEL=gpt-5.6-sol`, और `VISUAL_RECAP_REASONING=high` सेट करें।
 
+## लागत
+
+प्रत्येक रिकैप रन एक पूर्ण एजेंटिक कोडिंग-एजेंट सत्र है जो एक वास्तविक diff पढ़ता है, न कि कोई सस्ता टेम्प्लेटेड सारांश, इसलिए इसकी लागत मॉडल चुनाव और यह कितनी बार चलता है, इस पर निर्भर करती है:
+
+- **प्रत्येक PR पुश पर एक पूरा सत्र।** डिफ़ॉल्ट ट्रिगर `synchronize` पर चलता है, इसलिए जिस PR को दस बार पुश किया जाता है, वह एजेंट को दस बार चलाता है।
+- **हर बार पूरा PR**, न कि केवल पिछले रन के बाद के कमिट — लागत PR के कुल आकार के अनुसार बढ़ती है, न कि वृद्धिशील diff आकार के अनुसार।
+- **Diff इनपुट लगभग 600KB तक सीमित।** यह प्रति रन सबसे खराब स्थिति को सीमित करता है, लेकिन बड़े diff अभी भी छोटे diff की तुलना में काफी अधिक लागत लेते हैं।
+- **विफलता पर एक स्वचालित पुनः प्रयास**, जो किसी अस्थायी रूप से विफल होने वाले रन की लागत को लगभग दोगुना कर सकता है।
+
+लागत कम करने के लिए:
+
+- **एक सस्ता मॉडल पिन करें।** Claude के लिए, सरल या छोटे रिपॉज़िटरी के लिए `VISUAL_RECAP_MODEL=claude-haiku-4-5` सेट करें — यह सबसे सस्ता Claude स्तर है; `claude-sonnet-5` (डिफ़ॉल्ट) संतुलित स्तर है।
+- **सस्ते मॉडल के साथ Codex पर स्विच करें।** `VISUAL_RECAP_AGENT=codex` को `VISUAL_RECAP_MODEL=gpt-5.6-luna` (सबसे सस्ता GPT-5.6 स्तर) या `gpt-5.6-terra` (मध्य-स्तर) के साथ सेट करें, और रीज़निंग-टोकन खर्च को और कम करने के लिए `VISUAL_RECAP_REASONING=low` सेट करें। रीज़निंग गहराई केवल Codex पर लागू होती है।
+- **किसी सस्ते OpenAI-संगत प्रदाता की ओर इंगित करें।** DeepSeek, Kimi, या किसी अन्य OpenAI-संगत एंडपॉइंट को लक्षित करते हुए `VISUAL_RECAP_BASE_URL`/`VISUAL_RECAP_MODEL`/`VISUAL_RECAP_API_KEY` के साथ `VISUAL_RECAP_AGENT=openai-compatible` सेट करें।
+- **रिकैप कम बार करें।** इंस्टॉल किए गए वर्कफ़्लो के `on.pull_request.types` को `[opened, synchronize, reopened, ready_for_review, closed]` से बदलकर `[opened, ready_for_review, closed]` करें ताकि यह हर पुश पर नहीं, बल्कि केवल तब रिकैप करे जब कोई PR खुले और जब वह मर्ज हो।
+
+हर रन यह रिकॉर्ड करता है कि वास्तव में कितना खर्च हुआ: वर्कफ़्लो का `recap usage` चरण टोकन और लागत उपयोग को प्रकाशित योजना से जोड़ देता है, ताकि आप अनुमान लगाने के बजाय प्रति रन वास्तविक खर्च देख सकें।
+
 ## रहस्य और चर
 
 इन्हें अपने भंडार की **सेटिंग्स → रहस्य और चर → Actions** में सेट करें।
@@ -196,11 +214,11 @@ npx @agent-native/core@latest connect https://plan.agent-native.com --service-to
 
 **सोलो: एक व्यक्तिगत टोकन अभी भी काम करता है।** इसे `npx @agent-native/core@latest connect` के साथ मिंट करें
 आपके प्लान ऐप के विरुद्ध। होस्ट किए गए ऐप के लिए, यह एक स्थानीय भी लिखता है
-प्रकाशन-टोकन फ़ाइल जिसे `npx @agent-native/core@latest recap setup` पढ़ सकता है:
+प्रकाशन-टोकन फ़ाइल जिसे `npx @agent-native/recap-cli@latest recap setup` पढ़ सकता है:
 
 ```bash
 npx @agent-native/core@latest connect https://plan.agent-native.com --client codex
-npx @agent-native/core@latest recap setup
+npx @agent-native/recap-cli@latest recap setup
 ```
 
 यदि आप मैन्युअल सेटअप पसंद करते हैं, तो टोकन को GitHub सीक्रेट में पेस्ट करें। ए
@@ -209,16 +227,16 @@ npx @agent-native/core@latest recap setup
 
 ### वैकल्पिक (केवल यदि आप डिफ़ॉल्ट बदलते हैं)
 
-| गुप्त/चर                 | डिफ़ॉल्ट                        | जब आपको इसकी आवश्यकता हो                                                                                                                                    |
-| ------------------------ | ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `OPENAI_API_KEY`         | —                               | गुप्त. इसके बजाय Codex के साथ रिकैप चलाने के लिए `VISUAL_RECAP_AGENT=codex` के साथ सेट करें।                                                                |
-| `VISUAL_RECAP_AGENT`     | `claude`                        | परिवर्तनीय. कोडिंग-एजेंट बैकएंड (`claude` या `codex`) का चयन करता है।                                                                                       |
-| `VISUAL_RECAP_MODEL`     | प्रत्येक CLI का डिफ़ॉल्ट        | चर। मॉडल को पिन करें - उदा. Codex के लिए `gpt-5.6-sol`, या Claude मॉडल आईडी। अनसेट CLI के स्वयं के डिफ़ॉल्ट का उपयोग करता है।                               |
-| `VISUAL_RECAP_REASONING` | प्रत्येक मॉडल का डिफ़ॉल्ट       | परिवर्तनीय. तर्क की गहराई: `none`, `minimal`, `low`, `medium`, `high`, या `xhigh`। Codex बैकएंड पर लागू होता है।                                            |
-| `RECAP_CLI_VERSION`      | `latest`                        | चर। वर्कफ़्लो इंस्टॉल होने पर `@agent-native/core` CLI संस्करण को पिन करें - उदाहरण के लिए `1.5.0`. [Version pinning](#version-pinning-copy-variant) देखें. |
-| `PLAN_RECAP_APP_URL`     | `https://plan.agent-native.com` | गुप्त. केवल तभी जब प्लान्स ऐप को किसी भिन्न मूल पर स्वयं-होस्ट किया जाए।                                                                                    |
+| गुप्त/चर                 | डिफ़ॉल्ट                                                   | जब आपको इसकी आवश्यकता हो                                                                                                                                                                                                                                                                    |
+| ------------------------ | ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `OPENAI_API_KEY`         | —                                                          | गुप्त. इसके बजाय Codex के साथ रिकैप चलाने के लिए `VISUAL_RECAP_AGENT=codex` के साथ सेट करें।                                                                                                                                                                                                |
+| `VISUAL_RECAP_AGENT`     | `claude`                                                   | परिवर्तनीय. कोडिंग-एजेंट बैकएंड (`claude` या `codex`) का चयन करता है।                                                                                                                                                                                                                       |
+| `VISUAL_RECAP_MODEL`     | Claude के लिए `claude-sonnet-5`; संगत बैकएंड के लिए आवश्यक | चर। OpenAI-संगत बैकएंड के लिए प्रदाता मॉडल आईडी (वहां आवश्यक)। Claude के लिए, अनसेट अब डिफ़ॉल्ट रूप से `claude-sonnet-5` उपयोग करता है — इसे ओवरराइड करने के लिए सेट करें, जैसे सबसे सस्ते स्तर के लिए `claude-haiku-4-5`। Codex के लिए, अनसेट Codex CLI के अपने डिफ़ॉल्ट का उपयोग करता है। |
+| `VISUAL_RECAP_REASONING` | प्रत्येक मॉडल का डिफ़ॉल्ट                                  | परिवर्तनीय. तर्क की गहराई: `none`, `minimal`, `low`, `medium`, `high`, या `xhigh`। Codex बैकएंड पर लागू होता है।                                                                                                                                                                            |
+| `RECAP_CLI_VERSION`      | `latest`                                                   | चर। वर्कफ़्लो इंस्टॉल होने पर `@agent-native/recap-cli` CLI संस्करण को पिन करें - उदाहरण के लिए `1.5.0`. [Version pinning](#version-pinning-copy-variant) देखें.                                                                                                                            |
+| `PLAN_RECAP_APP_URL`     | `https://plan.agent-native.com`                            | गुप्त. केवल तभी जब प्लान्स ऐप को किसी भिन्न मूल पर स्वयं-होस्ट किया जाए।                                                                                                                                                                                                                    |
 
-वर्कफ़्लो स्वचालित रूप से पता लगाता है कि इसके सहायक CLI (इस मोनोरेपो के अंदर स्थानीय स्रोत, कहीं और प्रकाशित `@agent-native/core`) को कैसे लागू किया जाए, इसलिए सेट करने के लिए कोई `RECAP_CLI` वेरिएबल नहीं है।
+वर्कफ़्लो स्वचालित रूप से पता लगाता है कि इसके सहायक CLI (इस मोनोरेपो के अंदर स्थानीय स्रोत, कहीं और प्रकाशित `@agent-native/recap-cli`) को कैसे लागू किया जाए, इसलिए सेट करने के लिए कोई `RECAP_CLI` वेरिएबल नहीं है।
 
 ## टिप्पणी में इनलाइन स्क्रीनशॉट
 
@@ -360,9 +378,9 @@ Agent-Native योजना डेटाबेस में पुनर्क
 इसके बजाय स्थानीय-फ़ाइल मोड में समान सहायक प्रवाह स्थानीय रूप से होता है:
 
 ```bash
-npx @agent-native/core@latest recap collect-diff --base main --head HEAD --out recap.diff --stat recap.stat
-npx @agent-native/core@latest recap scan --diff recap.diff
-npx @agent-native/core@latest recap build-prompt --pr 123 --diff recap.diff --stat recap.stat --local-files --local-dir plans/pr-123-visual-recap
+npx @agent-native/recap-cli@latest recap collect-diff --base main --head HEAD --out recap.diff --stat recap.stat
+npx @agent-native/recap-cli@latest recap scan --diff recap.diff
+npx @agent-native/recap-cli@latest recap build-prompt --pr 123 --diff recap.diff --stat recap.stat --local-files --local-dir plans/pr-123-visual-recap
 ```
 
 जनरेट किए गए `recap-prompt.md` को अपने कोडिंग एजेंट को दें। स्थानीय-फ़ाइलें मोड
@@ -392,7 +410,7 @@ npx @agent-native/core@latest plan local serve --dir plans/pr-123-visual-recap -
 
 ## संस्करण पिनिंग (कॉपी संस्करण) {#version-pinning-copy-variant}
 
-डिफ़ॉल्ट रूप से कॉपी-वेरिएंट वर्कफ़्लो रन टाइम पर `@agent-native/core@latest` इंस्टॉल करता है इसलिए प्रत्येक रीकैप रन स्वचालित रूप से नवीनतम CLI चुनता है। यदि आपके CI को प्रतिलिपि प्रस्तुत करने योग्य टूलींग की आवश्यकता है, तो स्थापित संस्करण को पिन करने के लिए **`RECAP_CLI_VERSION`** रिपोजिटरी वेरिएबल सेट करें:
+डिफ़ॉल्ट रूप से कॉपी-वेरिएंट वर्कफ़्लो रन टाइम पर `@agent-native/recap-cli@latest` इंस्टॉल करता है इसलिए प्रत्येक रीकैप रन स्वचालित रूप से नवीनतम CLI चुनता है। यदि आपके CI को प्रतिलिपि प्रस्तुत करने योग्य टूलींग की आवश्यकता है, तो स्थापित संस्करण को पिन करने के लिए **`RECAP_CLI_VERSION`** रिपोजिटरी वेरिएबल सेट करें:
 
 1. अपने रेपो की **सेटिंग्स → रहस्य और वेरिएबल्स → Actions → वेरिएबल्स** पर जाएं।
 2. `1.5.0` जैसे मान के साथ `RECAP_CLI_VERSION` नाम का एक वेरिएबल बनाएं।
@@ -403,7 +421,7 @@ npx @agent-native/core@latest plan local serve --dir plans/pr-123-visual-recap -
 
 ## गुप्त-स्कैन अनुमति सूची
 
-रिकैप प्रकाशित करने से पहले वर्कफ़्लो अंतर में संभावित रहस्यों का पता लगाने के लिए `npx @agent-native/core@latest recap scan` चलाता है। कोई भी पीआर जिसका अंतर ज्ञात-गुप्त पैटर्न से मेल खाता है, उसे एक व्याख्यात्मक टिप्पणी के साथ अवरुद्ध कर दिया जाता है - पुनर्कथन प्रकाशित नहीं किया जाता है, और कोडिंग एजेंट को कोई भिन्न सामग्री नहीं भेजी जाती है।
+रिकैप प्रकाशित करने से पहले वर्कफ़्लो अंतर में संभावित रहस्यों का पता लगाने के लिए `npx @agent-native/recap-cli@latest recap scan` चलाता है। कोई भी पीआर जिसका अंतर ज्ञात-गुप्त पैटर्न से मेल खाता है, उसे एक व्याख्यात्मक टिप्पणी के साथ अवरुद्ध कर दिया जाता है - पुनर्कथन प्रकाशित नहीं किया जाता है, और कोडिंग एजेंट को कोई भिन्न सामग्री नहीं भेजी जाती है।
 
 दुर्लभ मामलों में किसी रेपो में जानबूझकर परीक्षण फिक्स्चर या गैर-गुप्त स्ट्रिंग्स होती हैं जो सतही तौर पर गुप्त पैटर्न से मिलती जुलती होती हैं (उदाहरण के लिए, परीक्षण फ़ाइल में एक फिक्स्चर कुंजी)। झूठी सकारात्मकता को दबाने के लिए, अपने रिपॉजिटरी के रूट में `.github/recap-scan-allowlist` बनाएं।
 
@@ -437,7 +455,7 @@ EXAMPLE_API_KEY=placeholder-value
 
 ### पुनः प्रयोज्य संस्करण का उपयोग क्यों करें?
 
-डिफ़ॉल्ट इंस्टॉलर पूर्ण ~360-लाइन वर्कफ़्लो YAML को आपके रेपो (**कॉपी** विकल्प) में कॉपी करता है। यह एयर-गैप्ड रिपोज़ या रिपोज़ के लिए सही विकल्प है, जिन्हें चलने वाली प्रत्येक पंक्ति का ऑडिट करने की आवश्यकता होती है। नकारात्मक पक्ष यह है कि बग फिक्स और सुधार कभी भी आप तक नहीं पहुंचते हैं - आपको प्रत्येक रिलीज़ के बाद `npx @agent-native/core@latest recap setup` को मैन्युअल रूप से फिर से चलाने की आवश्यकता होती है।
+डिफ़ॉल्ट इंस्टॉलर पूर्ण ~360-लाइन वर्कफ़्लो YAML को आपके रेपो (**कॉपी** विकल्प) में कॉपी करता है। यह एयर-गैप्ड रिपोज़ या रिपोज़ के लिए सही विकल्प है, जिन्हें चलने वाली प्रत्येक पंक्ति का ऑडिट करने की आवश्यकता होती है। नकारात्मक पक्ष यह है कि बग फिक्स और सुधार कभी भी आप तक नहीं पहुंचते हैं - आपको प्रत्येक रिलीज़ के बाद `npx @agent-native/recap-cli@latest recap setup` को मैन्युअल रूप से फिर से चलाने की आवश्यकता होती है।
 
 **पुन: प्रयोज्य** विकल्प इसके बजाय एक पतली ~20-लाइन कॉलर लिखता है। यह `uses:` के माध्यम से `BuilderIO/agent-native/.github/workflows/pr-visual-recap-reusable.yml` को सौंपता है। जब वर्कफ़्लो चलता है तो प्रत्येक कॉलर स्वचालित रूप से नवीनतम तर्क उठाता है, बिना किसी स्थानीय अपडेट की आवश्यकता के।
 
@@ -450,7 +468,7 @@ EXAMPLE_API_KEY=placeholder-value
 
 ### कॉलर स्निपेट
 
-`npx @agent-native/core@latest recap setup --reusable` यही लिखता है (या आप इसे मैन्युअल रूप से पेस्ट कर सकते हैं):
+`npx @agent-native/recap-cli@latest recap setup --reusable` यही लिखता है (या आप इसे मैन्युअल रूप से पेस्ट कर सकते हैं):
 
 ```yaml
 name: PR Visual Recap
@@ -485,7 +503,7 @@ jobs:
       skill-source: ${{ vars.VISUAL_RECAP_SKILL_SOURCE || 'auto' }}
       runs-on: ${{ vars.VISUAL_RECAP_RUNS_ON || '"ubuntu-latest"' }}
       gate-runs-on: ${{ vars.VISUAL_RECAP_GATE_RUNS_ON || 'ubuntu-latest' }}
-      # cli-version: "latest"  # pin to a specific @agent-native/core version
+      # cli-version: "latest"  # pin to a specific @agent-native/recap-cli version
 ```
 
 [Secrets and variables](#secrets-and-variables) में वर्णित समान रहस्य और चर लागू होते हैं। पुन: प्रयोज्य कॉलर पूरे जॉब के लिए `VISUAL_RECAP_RUNS_ON` को `runs-on` और गेट के लिए `VISUAL_RECAP_GATE_RUNS_ON` को एकल-लेबल `gate-runs-on` के रूप में भेजता है। दोनों छोड़ने पर `ubuntu-latest` उपयोग करते हैं।
@@ -494,15 +512,15 @@ jobs:
 
 ```bash
 # पूरी कॉपी के बजाय पतला कॉलर लिखें:
-npx @agent-native/core@latest recap setup --reusable
+npx @agent-native/recap-cli@latest recap setup --reusable
 
 # या प्रतिलिपि प्रस्तुत करने योग्यता के लिए पिन किए गए रेफरी के साथ:
-npx @agent-native/core@latest recap setup --reusable --ref v1.2.3
+npx @agent-native/recap-cli@latest recap setup --reusable --ref v1.2.3
 ```
 
 दोनों वेरिएंट वर्कफ़्लो को `.github/workflows/pr-visual-recap.yml` पर लिखते हैं। यदि कोई मौजूदा वर्कफ़्लो पहले से मौजूद है और भिन्न है, तो कमांड अस्वीकार कर देता है और आपको ओवरराइट करने के लिए `--force` पास करने के लिए कहता है।
 
-लिखने के बाद, रहस्य कॉन्फ़िगर किए जाने की पुष्टि करने के लिए हमेशा की तरह `npx @agent-native/core@latest recap doctor` चलाएं।
+लिखने के बाद, रहस्य कॉन्फ़िगर किए जाने की पुष्टि करने के लिए हमेशा की तरह `npx @agent-native/recap-cli@latest recap doctor` चलाएं।
 
 ### संस्करण पिन करना
 
@@ -512,7 +530,7 @@ npx @agent-native/core@latest recap setup --reusable --ref v1.2.3
 uses: BuilderIO/agent-native/.github/workflows/pr-visual-recap-reusable.yml@v1.2.3
 ```
 
-`cli-version` इनपुट नियंत्रित करता है कि वर्कफ़्लो के अंदर कौन सा `@agent-native/core` CLI संस्करण चलता है - नवीनतम रिलीज़ को ट्रैक करने के लिए इसे `"latest"` पर छोड़ दें, या पूर्ण प्रतिलिपि प्रस्तुत करने योग्यता के लिए इसे संस्करण स्ट्रिंग (जैसे `"1.5.0"`) पर पिन करें।
+`cli-version` इनपुट नियंत्रित करता है कि वर्कफ़्लो के अंदर कौन सा `@agent-native/recap-cli` CLI संस्करण चलता है - नवीनतम रिलीज़ को ट्रैक करने के लिए इसे `"latest"` पर छोड़ दें, या पूर्ण प्रतिलिपि प्रस्तुत करने योग्यता के लिए इसे संस्करण स्ट्रिंग (जैसे `"1.5.0"`) पर पिन करें।
 
 ### वर्कफ़्लो_कॉल ईवेंट संदर्भ
 

package/docs/content/locales/hi-IN/template-plan.mdx

@@ -212,6 +212,13 @@ vscode://builder.agent-native/open?url=<encoded-plan-url>
 **खुले प्रश्न** उसी योजना के निचले भाग में बनते हैं। इसका उत्तर देकर भेज रहा हूं
 यह एजेंट के लिए मौजूदा योजना के विरुद्ध एक संशोधन मोड़ शुरू करता है।
 
+## लागत और मॉडल चुनाव
+
+कोई योजना या रिकैप बनाना आपके कोडिंग एजेंट के LLM पर एक पूर्ण एजेंटिक सत्र चलाता है, न कि कोई हल्का टेम्प्लेट फिल, इसलिए लागत diff या योजना के आकार और आपके द्वारा चुने गए मॉडल के अनुसार बढ़ती है।
+
+- ऐप का अपना डिफ़ॉल्ट चैट मॉडल Sonnet 5 है; इसे किसी भी समय **सेटिंग्स** में बदलें। Haiku सस्ता Claude विकल्प है, और Luna GPT-5.6 परिवार में सस्ता विकल्प है।
+- GitHub Action से स्वचालित PR रिकैप इंटरैक्टिव ऐप से अलग चलते हैं और इनके अपने मॉडल और लागत नियंत्रण होते हैं — `VISUAL_RECAP_MODEL`, `VISUAL_RECAP_AGENT`, और `VISUAL_RECAP_REASONING` के लिए [PR Visual Recap](/docs/pr-visual-recap) देखें।
+
 ## आप इसके साथ क्या कर सकते हैं
 
 - **कार्यान्वयन से पहले समीक्षा करें।** आरेख, वायरफ्रेम, विकल्प टैब के लिए React,