cc-viewer 1.6.232 → 1.6.233

package/concepts/es/UltraPlan.md

@@ -53,3 +53,104 @@ Un flujo de trabajo de colaboración multi-agente diseñado para tareas de inves
 4. Sintetizar todos los hallazgos en un plan de implementación integral
 5. Desplegar múltiples agentes de revisión para examinar el plan desde diferentes roles y perspectivas
 6. Ejecutar el plan una vez aprobado
+
+---
+
+## Raw Templates
+
+Below are the two raw prompt templates UltraPlan actually sends to Claude Code (see `src/utils/ultraplanTemplates.js`):
+
+### Code Expert (codeExpert)
+
+<textarea readonly><system-reminder>
+[SCOPED INSTRUCTION] The following instructions apply only to the next 1–3 interactions. Once the task is complete, these instructions should gradually decrease in priority and no longer affect subsequent interactions.
+
+Pre-requisite: Use `AskUserQuestion` to clarify user intent whenever the request is ambiguous (target element, interaction style, scope of platforms, etc.). Skip only if the intent is unambiguous.
+
+Leverage a multi-agent exploration mechanism to formulate a highly detailed implementation plan.
+
+Instructions:
+1. Use the `Agent` tool to spawn parallel agents that simultaneously explore different aspects of the codebase:
+- If necessary, assign a preliminary researcher to use the `webSearch` tool to first investigate cutting-edge solutions in the relevant industry domain;
+- One agent responsible for understanding the relevant existing code and architecture;
+- One agent responsible for identifying all files that need to be modified;
+- One agent responsible for identifying potential risks, edge cases, and dependencies;
+- You may add other roles or deploy additional agents beyond the three listed above; the maximum number of concurrently dispatched agents is 5.
+
+2. Synthesize the findings from all agents into a detailed, step-by-step implementation plan.
+
+3. Use the `Agent` tool to spawn 2-3 review agents that examine the plan from different perspectives, checking for missing steps, potential risks, or corresponding mitigation strategies.
+
+4. Integrate the feedback gathered during the review process, then call `ExitPlanMode` to submit your final plan.
+
+5. Once `ExitPlanMode` returns a result:
+- If approved: proceed to execute the plan within this session.
+- If rejected: revise the plan based on the feedback provided and call `ExitPlanMode` again.
+- If an error occurs (including receiving a "Not in Plan Mode" message): do **not** follow the suggestions provided in the error message; instead, prompt the user for further instructions.
+
+Your final plan must include the following elements:
+- A clear summary of the implementation strategy;
+- An ordered list of files to be created or modified, with precise details of the required changes for each file;
+- A step-by-step execution sequence;
+- Testing and validation procedures;
+- Potential risks and their corresponding mitigation strategies;
+
+6. After the final plan has been successfully executed:
+First run `git diff --quiet && git diff --cached --quiet` (or equivalent) to detect whether the working tree actually has non-trivial changes; if there are no real changes (or only whitespace/comment-only edits), skip the UltraReview step.
+Otherwise, if the project is managed with Git:
+Initiate a team (`TeamCreate`), dynamically allocating the number of teammates based on task complexity (5 is recommended);
+Task: Conduct a Code Review of the current git changes from multiple perspectives;
+Pre-requisites:
+- The git repository may be located in a subdirectory of the current directory; prefer `git rev-parse --show-toplevel` (fall back to recursive lookup) before proceeding;
+- In the case of multiple repositories, tasks may be executed separately;
+The team's goal is to analyze the current Git change log and validate each modification from different perspectives, specifically including:
+- Whether requirements/objectives have been met and functionality is complete;
+- Whether newly added code introduces side effects, breaks existing functionality, or poses potential risks;
+- Code quality: naming, readability, complexity, technical debt, maintainability;
+- Testing and documentation: whether there is adequate test coverage, and whether critical logic has necessary comments or documentation;
+- Dependencies and compatibility: whether new dependencies or version compatibility issues have been introduced;
+Workflow:
+- Each teammate, according to their own role, covers the review dimensions one by one and independently outputs a report;
+- After consolidating the reports, perform a cross-review to identify conflicts or shared concerns;
+- Distill specific, actionable modification suggestions and annotate them with priority levels (P0/P1/P2/P3);
+- Upon completion, adopt P0 items, and selectively adopt P1 items when they are concrete and low-risk; defer P2/P3 to backlog;
+- After execution is complete, close the team (`TeamDelete`);
+</system-reminder></textarea>
+
+### Research Expert (researchExpert)
+
+<textarea readonly><system-reminder>
+[SCOPED INSTRUCTION] The following instructions are intended for the next 1–3 interactions. Once the task is complete, these instructions should be gradually deprioritized and no longer influence subsequent interactions.
+
+Pre-requisite: Use `AskUserQuestion` to clarify the research scope, target audience, and deliverable format whenever the user's intent is ambiguous. Skip only if the intent is unambiguous.
+
+Leverage a multi-agent exploration mechanism to formulate an exceptionally detailed implementation plan.
+
+Instructions:
+1. Utilize the Agent tool to spawn parallel agents that simultaneously explore various facets of the requirements:
+- If necessary, deploy a preliminary investigator to conduct an initial survey of industry-specific solutions using `webSearch`;
+- If necessary, deploy a specialized investigator to research authoritative sources—such as academic papers, news articles, and research reports—using `webSearch`;
+- Assign an agent to synthesize the target solution, while simultaneously verifying the rigor and credibility of the gathered papers, news, and research reports;
+- If necessary, assign an agent to analyze competitor data to provide supplementary analytical perspectives;
+- If necessary, assign an agent to handle the implementation of a product demo (generating outputs such as HTML, Markdown, etc.);
+- If the task is sufficiently complex, you may assign additional teammates to the roles defined above, or introduce other specialized roles; you are permitted to schedule up to 5 teammates concurrently.
+
+2. Synthesize the findings from the aforementioned agents into a comprehensive, step-by-step implementation plan.
+
+3. Utilize the Agent tool to spawn a set of parallel review agents; these agents shall scrutinize the plan from multiple roles and perspectives to identify any omitted steps and to propose reasonable additions or optimizations.
+
+4. Consolidate the feedback received from the review agents, then invoke `ExitPlanMode` to submit your final plan.
+
+5. Upon receiving the result from `ExitPlanMode`:
+- If Approved: Proceed to execute the plan within this current session.
+- If Rejected: Revise the plan based on the provided feedback, and then invoke `ExitPlanMode` once again.
+- If an Error Occurs (including the message "Not in Plan Mode"): Do *not* follow the suggestions provided by the error message; instead, prompt the user for further instructions.
+
+Your final plan must include the following elements:
+- A clear summary of the proposed implementation strategy;
+- An ordered list of files to be created or modified, specifying the exact changes required for each;
+- A step-by-step sequence for executing the implementation;
+- Identification of potential risks and corresponding mitigation strategies;
+- Creative ideation and suggestions for advanced enhancements;
+- If a product demo was generated, place the corresponding demo output in an appropriate location and notify the user.
+</system-reminder></textarea>

package/concepts/fr/CustomUltraplanExpert.md

@@ -0,0 +1,165 @@
+# Expert UltraPlan personnalisé — Guide de création
+
+## Ce que font les deux champs de saisie
+
+- **Nom de l'expert** : l'étiquette affichée sur le bouton de rôle dans la rangée des variantes UltraPlan (30 caractères max.). Ce n'est qu'un nom d'affichage et il n'est **jamais** envoyé à Claude Code.
+- **Corps du prompt** : votre instruction de rôle. Au moment de l'envoi, cc-viewer l'enveloppe **automatiquement** dans des balises `<system-reminder>...</system-reminder>` avec un en-tête de portée `[SCOPED INSTRUCTION]`. Donc **n'écrivez que le corps** — n'ajoutez pas vous-même de balises `<system-reminder>`.
+
+---
+
+## À quoi ressemble le modèle d'expert ?
+
+Chaque expert intégré (Code Expert / Research Expert) est essentiellement un bloc `<system-reminder>` injecté dans le contexte de Claude Code. Votre expert personnalisé passe par exactement le même pipeline. Voici le modèle **Research Expert** décomposé :
+
+```xml
+<system-reminder>
+[SCOPED INSTRUCTION] The following instructions are intended for the next 1–3
+interactions. Once the task is complete, these instructions should be gradually
+deprioritized and no longer influence subsequent interactions.
+
+Pre-requisite: Use `AskUserQuestion` to clarify the research scope, target
+audience, and deliverable format whenever the user's intent is ambiguous. Skip
+only if the intent is unambiguous.
+
+Leverage a multi-agent exploration mechanism to formulate an exceptionally
+detailed implementation plan.
+
+Instructions:
+1. Utilize the Agent tool to spawn parallel agents that simultaneously explore
+   various facets of the requirements:
+   - If necessary, deploy a preliminary investigator to conduct an initial
+     survey of industry-specific solutions using `webSearch`;
+   - If necessary, deploy a specialized investigator to research authoritative
+     sources—such as academic papers, news articles, and research reports—
+     using `webSearch`;
+   - Assign an agent to synthesize the target solution, while simultaneously
+     verifying the rigor and credibility of the gathered papers, news, and
+     research reports;
+   - If necessary, assign an agent to analyze competitor data to provide
+     supplementary analytical perspectives;
+   - If necessary, assign an agent to handle the implementation of a product
+     demo (generating outputs such as HTML, Markdown, etc.);
+   - If the task is sufficiently complex, you may assign additional teammates
+     to the roles defined above, or introduce other specialized roles; you are
+     permitted to schedule up to 5 teammates concurrently.
+
+2. Synthesize the findings from the aforementioned agents into a comprehensive,
+   step-by-step implementation plan.
+
+3. Utilize the Agent tool to spawn a set of parallel review agents; these
+   agents shall scrutinize the plan from multiple roles and perspectives to
+   identify any omitted steps and to propose reasonable additions or
+   optimizations.
+
+4. Consolidate the feedback received from the review agents, then invoke
+   `ExitPlanMode` to submit your final plan.
+
+5. Upon receiving the result from `ExitPlanMode`:
+   - If Approved: Proceed to execute the plan within this current session.
+   - If Rejected: Revise the plan based on the provided feedback, and then
+     invoke `ExitPlanMode` once again.
+   - If an Error Occurs: Do *not* follow the suggestions; prompt the user for
+     further instructions.
+
+Your final plan must include the following elements:
+- A clear summary of the proposed implementation strategy;
+- An ordered list of files to be created or modified, specifying the exact
+  changes required for each;
+- A step-by-step sequence for executing the implementation;
+- Identification of potential risks and corresponding mitigation strategies;
+- Creative ideation and suggestions for advanced enhancements;
+- If a product demo was generated, place the corresponding demo output in an
+  appropriate location and notify the user.
+</system-reminder>
+```
+
+---
+
+## Décomposition section par section
+
+### 1. En-tête de portée `[SCOPED INSTRUCTION]` (wrapper — généré automatiquement)
+> The following instructions are intended for the next 1–3 interactions...
+
+Cela indique à Claude Code : **ces instructions ne sont actives que pour les 1 à 3 prochains tours**, puis s'estompent. Empêche la « persona d'expert » de déborder par la suite dans une conversation sans rapport.
+
+**Cette ligne est générée automatiquement par cc-viewer. Vous n'avez pas besoin de l'écrire.**
+
+### 2. Définition de tâche d'ouverture (**c'est ce que vous devriez réécrire**)
+> Leverage a multi-agent exploration mechanism to formulate an exceptionally detailed implementation plan.
+
+C'est le « sujet-verbe-complément » de tout le modèle : **il indique à Claude Code la posture et l'objectif**. Le « exploration multi-agents + plan d'implémentation » par défaut convient bien aux tâches d'**ingénierie logicielle / planification**, mais semble maladroit pour de nombreux autres domaines (révision de contenu, analyse de données, rédaction publicitaire, étude de marché, audit de conformité…).
+
+**Nous recommandons fortement de réécrire cette ligne pour votre objectif**, par exemple :
+
+- **Réviseur de contenu** : « Vous êtes un réviseur de contenu senior spécialisé dans {domaine}. Votre objectif est d'identifier les inexactitudes factuelles, les incohérences de ton et les faiblesses structurelles dans le matériel fourni. »
+- **Analyste concurrentiel** : « Effectuez une analyse concurrentielle rigoureuse pour {catégorie de produits}. Produisez une matrice de comparaison, des insights de positionnement et des recommandations stratégiques. »
+- **Rédacteur** : « Générez plusieurs variantes créatives de texte pour {scénario}, chacune avec un positionnement, un ton et une stratégie d'appel à l'action distincts. »
+
+### 3. Étapes du workflow (1–5 éléments — **élaguer ou étendre selon la complexité**)
+
+Le Research Expert comporte 5 étapes : **explorer → synthétiser → réviser → soumettre le plan → exécuter**. Cela impose « multi-agents parallèles + révision croisée + approbation du plan » — trois couches de rigueur, appropriées pour des tâches à enjeux élevés/portée large mais **excessives pour les tâches légères**.
+
+- **Tâche simple** (recherche unique / petite correction) : supprimez la dépêche multi-agents et la révision ; produisez simplement « la réponse » en une étape.
+- **Tâche modérée** : conservez « explorer → synthétiser → réviser » ; supprimez la danse ExitPlanMode ; livrez le résultat directement.
+- **Tâche complexe et coûteuse** (gros refactoring, comparaison multi-options, recherche transversale) : conservez les 5 étapes, ajoutez éventuellement une étape « modèle de risque » ou « matrice de comparaison d'options ».
+
+### 4. Sous-rôles à l'étape 1 (**adaptez à votre domaine**)
+
+Research Expert répertorie 6 rôles potentiels (éclaireur de l'industrie, chercheur académique, synthétiseur + vérificateur de faits, analyste de la concurrence, producteur de démo, emplacement d'extensibilité). **Réécrivez cette liste pour votre scénario** :
+
+- **Rédaction** : « collecteur de sources + analyste de style + vérificateur de faits »
+- **Analyse de données** : « agent de nettoyage des données + agent de modélisation statistique + agent de visualisation »
+- **Audit de code** : « agent d'analyse statique + auditeur de chaîne de dépendances + modélisateur de menaces »
+
+### 5. Liste de contrôle finale des livrables (**alignez avec votre besoin réel**)
+
+> Your final plan must include the following elements: ...
+
+Le modèle d'origine répertorie 6 éléments d'un « plan d'implémentation ». Votre livrable pourrait être tout à fait autre chose :
+
+- Un **rapport de recherche** → « Résumé exécutif / Méthodologie / Conclusions clés / Limitations / Recommandations d'action »
+- Un **rapport de révision** → « Liste des problèmes / Évaluation de la gravité / Suggestions de correction / Exemples avant-après »
+- Une **matrice de comparaison** → « Définitions des dimensions / Grille de notation / Conclusions / Justification de la recommandation »
+
+---
+
+## Conseils de création (TL;DR)
+
+1. **Conservez le wrapper** : la ligne `<system-reminder>` + `[SCOPED INSTRUCTION]` est ajoutée par cc-viewer — ne la répétez pas.
+2. **Réécrivez la phrase d'ouverture** : énoncez le rôle, l'objectif et le format de sortie en une seule ligne.
+3. **Adaptez le workflow** : 1–2 étapes pour les tâches légères, la boucle complète à 5 étapes uniquement pour les tâches complexes.
+4. **Réécrivez les sous-rôles de l'étape 1** : les valeurs par défaut (articles académiques / concurrents / démo) ne sont probablement pas ce que vous voulez.
+5. **La « liste de contrôle des livrables » finale est votre exigence de qualité** : précisez la structure de sortie — Claude Code la suivra strictement.
+
+---
+
+## Un exemple refactoré : Analyste concurrentiel
+
+```
+You are a senior competitive intelligence analyst for {industry}. Your goal is to
+produce a decision-grade competitive landscape report for the product "{our product}".
+
+Instructions:
+1. Use the Agent tool to dispatch 3 parallel investigators:
+   - Market landscape agent: map the top 5–8 competitors with core positioning
+   - Feature matrix agent: compile a feature-by-feature comparison using
+     publicly available sources (webSearch)
+   - Pricing & GTM agent: analyze pricing models, distribution channels, and
+     go-to-market motions
+
+2. Synthesize the three streams into a unified competitive report.
+
+3. Dispatch one review agent to stress-test the report: challenge any
+   assumption lacking a cited source, flag outdated data (>12 months), and
+   propose one "non-obvious" insight.
+
+4. Deliver the final report with the following sections:
+   - TL;DR (3 bullets)
+   - Competitor positioning map
+   - Feature matrix (markdown table)
+   - Pricing & GTM table
+   - Top 3 strategic implications for our product
+   - Caveats & data gaps
+```
+
+Comparé au Research Expert d'origine : réduit à 4 étapes, sous-rôles passés de 6 à 3, liste des livrables entièrement réécrite en « sections de rapport ».

package/concepts/fr/UltraPlan.md

@@ -53,3 +53,104 @@ Un workflow de collaboration multi-agents conçu pour les tâches de recherche e
 4. Synthétiser toutes les découvertes en un plan d'implémentation complet
 5. Déployer plusieurs agents de revue pour examiner le plan sous différents rôles et perspectives
 6. Exécuter le plan une fois approuvé
+
+---
+
+## Raw Templates
+
+Below are the two raw prompt templates UltraPlan actually sends to Claude Code (see `src/utils/ultraplanTemplates.js`):
+
+### Code Expert (codeExpert)
+
+<textarea readonly><system-reminder>
+[SCOPED INSTRUCTION] The following instructions apply only to the next 1–3 interactions. Once the task is complete, these instructions should gradually decrease in priority and no longer affect subsequent interactions.
+
+Pre-requisite: Use `AskUserQuestion` to clarify user intent whenever the request is ambiguous (target element, interaction style, scope of platforms, etc.). Skip only if the intent is unambiguous.
+
+Leverage a multi-agent exploration mechanism to formulate a highly detailed implementation plan.
+
+Instructions:
+1. Use the `Agent` tool to spawn parallel agents that simultaneously explore different aspects of the codebase:
+- If necessary, assign a preliminary researcher to use the `webSearch` tool to first investigate cutting-edge solutions in the relevant industry domain;
+- One agent responsible for understanding the relevant existing code and architecture;
+- One agent responsible for identifying all files that need to be modified;
+- One agent responsible for identifying potential risks, edge cases, and dependencies;
+- You may add other roles or deploy additional agents beyond the three listed above; the maximum number of concurrently dispatched agents is 5.
+
+2. Synthesize the findings from all agents into a detailed, step-by-step implementation plan.
+
+3. Use the `Agent` tool to spawn 2-3 review agents that examine the plan from different perspectives, checking for missing steps, potential risks, or corresponding mitigation strategies.
+
+4. Integrate the feedback gathered during the review process, then call `ExitPlanMode` to submit your final plan.
+
+5. Once `ExitPlanMode` returns a result:
+- If approved: proceed to execute the plan within this session.
+- If rejected: revise the plan based on the feedback provided and call `ExitPlanMode` again.
+- If an error occurs (including receiving a "Not in Plan Mode" message): do **not** follow the suggestions provided in the error message; instead, prompt the user for further instructions.
+
+Your final plan must include the following elements:
+- A clear summary of the implementation strategy;
+- An ordered list of files to be created or modified, with precise details of the required changes for each file;
+- A step-by-step execution sequence;
+- Testing and validation procedures;
+- Potential risks and their corresponding mitigation strategies;
+
+6. After the final plan has been successfully executed:
+First run `git diff --quiet && git diff --cached --quiet` (or equivalent) to detect whether the working tree actually has non-trivial changes; if there are no real changes (or only whitespace/comment-only edits), skip the UltraReview step.
+Otherwise, if the project is managed with Git:
+Initiate a team (`TeamCreate`), dynamically allocating the number of teammates based on task complexity (5 is recommended);
+Task: Conduct a Code Review of the current git changes from multiple perspectives;
+Pre-requisites:
+- The git repository may be located in a subdirectory of the current directory; prefer `git rev-parse --show-toplevel` (fall back to recursive lookup) before proceeding;
+- In the case of multiple repositories, tasks may be executed separately;
+The team's goal is to analyze the current Git change log and validate each modification from different perspectives, specifically including:
+- Whether requirements/objectives have been met and functionality is complete;
+- Whether newly added code introduces side effects, breaks existing functionality, or poses potential risks;
+- Code quality: naming, readability, complexity, technical debt, maintainability;
+- Testing and documentation: whether there is adequate test coverage, and whether critical logic has necessary comments or documentation;
+- Dependencies and compatibility: whether new dependencies or version compatibility issues have been introduced;
+Workflow:
+- Each teammate, according to their own role, covers the review dimensions one by one and independently outputs a report;
+- After consolidating the reports, perform a cross-review to identify conflicts or shared concerns;
+- Distill specific, actionable modification suggestions and annotate them with priority levels (P0/P1/P2/P3);
+- Upon completion, adopt P0 items, and selectively adopt P1 items when they are concrete and low-risk; defer P2/P3 to backlog;
+- After execution is complete, close the team (`TeamDelete`);
+</system-reminder></textarea>
+
+### Research Expert (researchExpert)
+
+<textarea readonly><system-reminder>
+[SCOPED INSTRUCTION] The following instructions are intended for the next 1–3 interactions. Once the task is complete, these instructions should be gradually deprioritized and no longer influence subsequent interactions.
+
+Pre-requisite: Use `AskUserQuestion` to clarify the research scope, target audience, and deliverable format whenever the user's intent is ambiguous. Skip only if the intent is unambiguous.
+
+Leverage a multi-agent exploration mechanism to formulate an exceptionally detailed implementation plan.
+
+Instructions:
+1. Utilize the Agent tool to spawn parallel agents that simultaneously explore various facets of the requirements:
+- If necessary, deploy a preliminary investigator to conduct an initial survey of industry-specific solutions using `webSearch`;
+- If necessary, deploy a specialized investigator to research authoritative sources—such as academic papers, news articles, and research reports—using `webSearch`;
+- Assign an agent to synthesize the target solution, while simultaneously verifying the rigor and credibility of the gathered papers, news, and research reports;
+- If necessary, assign an agent to analyze competitor data to provide supplementary analytical perspectives;
+- If necessary, assign an agent to handle the implementation of a product demo (generating outputs such as HTML, Markdown, etc.);
+- If the task is sufficiently complex, you may assign additional teammates to the roles defined above, or introduce other specialized roles; you are permitted to schedule up to 5 teammates concurrently.
+
+2. Synthesize the findings from the aforementioned agents into a comprehensive, step-by-step implementation plan.
+
+3. Utilize the Agent tool to spawn a set of parallel review agents; these agents shall scrutinize the plan from multiple roles and perspectives to identify any omitted steps and to propose reasonable additions or optimizations.
+
+4. Consolidate the feedback received from the review agents, then invoke `ExitPlanMode` to submit your final plan.
+
+5. Upon receiving the result from `ExitPlanMode`:
+- If Approved: Proceed to execute the plan within this current session.
+- If Rejected: Revise the plan based on the provided feedback, and then invoke `ExitPlanMode` once again.
+- If an Error Occurs (including the message "Not in Plan Mode"): Do *not* follow the suggestions provided by the error message; instead, prompt the user for further instructions.
+
+Your final plan must include the following elements:
+- A clear summary of the proposed implementation strategy;
+- An ordered list of files to be created or modified, specifying the exact changes required for each;
+- A step-by-step sequence for executing the implementation;
+- Identification of potential risks and corresponding mitigation strategies;
+- Creative ideation and suggestions for advanced enhancements;
+- If a product demo was generated, place the corresponding demo output in an appropriate location and notify the user.
+</system-reminder></textarea>

package/concepts/it/CustomUltraplanExpert.md

@@ -0,0 +1,165 @@
+# Esperto UltraPlan personalizzato — Guida alla creazione
+
+## Cosa fanno i due campi di input
+
+- **Nome esperto**: l'etichetta mostrata sul pulsante del ruolo nella riga delle varianti UltraPlan (max 30 caratteri). È solo un nome visualizzato e **non viene mai** inviato a Claude Code.
+- **Corpo del prompt**: la tua istruzione di ruolo. Al momento dell'invio, cc-viewer lo avvolge **automaticamente** in tag `<system-reminder>...</system-reminder>` con un'intestazione di scope `[SCOPED INSTRUCTION]`. Quindi **scrivi solo il corpo** — non aggiungere tu stesso i tag `<system-reminder>`.
+
+---
+
+## Che aspetto ha il modello dell'esperto?
+
+Ogni esperto integrato (Code Expert / Research Expert) è essenzialmente un blocco `<system-reminder>` iniettato nel contesto di Claude Code. Il tuo esperto personalizzato passa attraverso esattamente la stessa pipeline. Ecco il modello **Research Expert** scomposto:
+
+```xml
+<system-reminder>
+[SCOPED INSTRUCTION] The following instructions are intended for the next 1–3
+interactions. Once the task is complete, these instructions should be gradually
+deprioritized and no longer influence subsequent interactions.
+
+Pre-requisite: Use `AskUserQuestion` to clarify the research scope, target
+audience, and deliverable format whenever the user's intent is ambiguous. Skip
+only if the intent is unambiguous.
+
+Leverage a multi-agent exploration mechanism to formulate an exceptionally
+detailed implementation plan.
+
+Instructions:
+1. Utilize the Agent tool to spawn parallel agents that simultaneously explore
+   various facets of the requirements:
+   - If necessary, deploy a preliminary investigator to conduct an initial
+     survey of industry-specific solutions using `webSearch`;
+   - If necessary, deploy a specialized investigator to research authoritative
+     sources—such as academic papers, news articles, and research reports—
+     using `webSearch`;
+   - Assign an agent to synthesize the target solution, while simultaneously
+     verifying the rigor and credibility of the gathered papers, news, and
+     research reports;
+   - If necessary, assign an agent to analyze competitor data to provide
+     supplementary analytical perspectives;
+   - If necessary, assign an agent to handle the implementation of a product
+     demo (generating outputs such as HTML, Markdown, etc.);
+   - If the task is sufficiently complex, you may assign additional teammates
+     to the roles defined above, or introduce other specialized roles; you are
+     permitted to schedule up to 5 teammates concurrently.
+
+2. Synthesize the findings from the aforementioned agents into a comprehensive,
+   step-by-step implementation plan.
+
+3. Utilize the Agent tool to spawn a set of parallel review agents; these
+   agents shall scrutinize the plan from multiple roles and perspectives to
+   identify any omitted steps and to propose reasonable additions or
+   optimizations.
+
+4. Consolidate the feedback received from the review agents, then invoke
+   `ExitPlanMode` to submit your final plan.
+
+5. Upon receiving the result from `ExitPlanMode`:
+   - If Approved: Proceed to execute the plan within this current session.
+   - If Rejected: Revise the plan based on the provided feedback, and then
+     invoke `ExitPlanMode` once again.
+   - If an Error Occurs: Do *not* follow the suggestions; prompt the user for
+     further instructions.
+
+Your final plan must include the following elements:
+- A clear summary of the proposed implementation strategy;
+- An ordered list of files to be created or modified, specifying the exact
+  changes required for each;
+- A step-by-step sequence for executing the implementation;
+- Identification of potential risks and corresponding mitigation strategies;
+- Creative ideation and suggestions for advanced enhancements;
+- If a product demo was generated, place the corresponding demo output in an
+  appropriate location and notify the user.
+</system-reminder>
+```
+
+---
+
+## Analisi sezione per sezione
+
+### 1. Intestazione di scope `[SCOPED INSTRUCTION]` (wrapper — generato automaticamente)
+> The following instructions are intended for the next 1–3 interactions...
+
+Questo dice a Claude Code: **queste istruzioni sono attive solo per i prossimi 1–3 turni**, poi svaniscono. Impedisce alla "persona dell'esperto" di trasferirsi in conversazioni non correlate successive.
+
+**Questa riga viene generata automaticamente da cc-viewer. Non è necessario scriverla.**
+
+### 2. Definizione del compito iniziale (**questo è ciò che dovresti riscrivere**)
+> Leverage a multi-agent exploration mechanism to formulate an exceptionally detailed implementation plan.
+
+Questo è il "soggetto-verbo-oggetto" dell'intero modello: **dice a Claude Code l'atteggiamento e l'obiettivo**. L'impostazione predefinita "esplorazione multi-agente + piano di implementazione" si adatta bene alle attività di **ingegneria del software / pianificazione**, ma sembra inadeguata per molti altri domini (revisione di contenuti, analisi dei dati, copywriting, ricerche di mercato, audit di conformità…).
+
+**Consigliamo vivamente di riscrivere questa riga per il tuo obiettivo**, ad esempio:
+
+- **Revisore di contenuti**: "Sei un revisore di contenuti senior specializzato in {dominio}. Il tuo obiettivo è identificare imprecisioni fattuali, incongruenze di tono e debolezze strutturali nel materiale fornito."
+- **Analista competitivo**: "Conduci un'analisi competitiva rigorosa per {categoria di prodotto}. Produci una matrice di confronto, insight di posizionamento e raccomandazioni strategiche."
+- **Copywriter**: "Genera più varianti creative di testo per {scenario}, ciascuna con posizionamento, tono e strategia di call-to-action distinti."
+
+### 3. Passaggi del workflow (1–5 elementi — **riduci o estendi in base alla complessità**)
+
+Il Research Expert ha 5 passaggi: **esplora → sintetizza → revisiona → invia il piano → esegui**. Questo impone "multi-agente parallelo + revisione incrociata + approvazione del piano" — tre livelli di rigore, appropriati per attività ad alto rischio/ampio scope ma **eccessivi per quelle leggere**.
+
+- **Compito semplice** (singola ricerca / piccola correzione): elimina l'invio multi-agente e la revisione; basta "produrre la risposta" in un solo passaggio.
+- **Compito moderato**: mantieni "esplora → sintetizza → revisiona"; elimina la procedura ExitPlanMode; consegna il risultato direttamente.
+- **Compito complesso e oneroso** (grande refactoring, confronto multi-opzione, ricerca interdisciplinare): mantieni tutti i 5 passaggi, eventualmente aggiungi un passaggio "modello di rischio" o "matrice di confronto delle opzioni".
+
+### 4. Sotto-ruoli nel passaggio 1 (**adatta al tuo dominio**)
+
+Research Expert elenca 6 ruoli potenziali (scout di settore, ricercatore accademico, sintetizzatore + verificatore di fatti, analista della concorrenza, produttore di demo, slot di estensibilità). **Riscrivi questo elenco per il tuo scenario**:
+
+- **Scrittura**: "raccoglitore di fonti + analista di stile + verificatore di fatti"
+- **Analisi dei dati**: "agente di pulizia dei dati + agente di modellazione statistica + agente di visualizzazione"
+- **Audit del codice**: "agente di analisi statica + auditor della catena di dipendenze + modellatore di minacce"
+
+### 5. Checklist finale dei deliverable (**allinea con la tua reale necessità**)
+
+> Your final plan must include the following elements: ...
+
+Il modello originale elenca 6 elementi di un "piano di implementazione". Il tuo deliverable potrebbe essere qualcosa di completamente diverso:
+
+- Un **rapporto di ricerca** → "Sintesi esecutiva / Metodologia / Risultati chiave / Limitazioni / Raccomandazioni d'azione"
+- Un **rapporto di revisione** → "Elenco dei problemi / Valutazione della gravità / Suggerimenti di correzione / Esempi prima-dopo"
+- Una **matrice di confronto** → "Definizioni delle dimensioni / Schema di valutazione / Conclusioni / Razionale della raccomandazione"
+
+---
+
+## Suggerimenti per la creazione (TL;DR)
+
+1. **Mantieni il wrapper**: la riga `<system-reminder>` + `[SCOPED INSTRUCTION]` viene aggiunta da cc-viewer — non ripeterla.
+2. **Riscrivi la frase di apertura**: dichiara ruolo, obiettivo e formato di output in una sola riga.
+3. **Flessibilizza il workflow**: 1–2 passaggi per attività leggere, l'intero ciclo a 5 passaggi solo per quelle complesse.
+4. **Riscrivi i sotto-ruoli del passaggio 1**: i valori predefiniti (articoli accademici / concorrenti / demo) probabilmente non sono ciò che vuoi.
+5. **La "checklist dei deliverable" finale è il tuo standard di qualità**: specifica la struttura di output — Claude Code la seguirà rigorosamente.
+
+---
+
+## Un esempio rifattorizzato: Analista competitivo
+
+```
+You are a senior competitive intelligence analyst for {industry}. Your goal is to
+produce a decision-grade competitive landscape report for the product "{our product}".
+
+Instructions:
+1. Use the Agent tool to dispatch 3 parallel investigators:
+   - Market landscape agent: map the top 5–8 competitors with core positioning
+   - Feature matrix agent: compile a feature-by-feature comparison using
+     publicly available sources (webSearch)
+   - Pricing & GTM agent: analyze pricing models, distribution channels, and
+     go-to-market motions
+
+2. Synthesize the three streams into a unified competitive report.
+
+3. Dispatch one review agent to stress-test the report: challenge any
+   assumption lacking a cited source, flag outdated data (>12 months), and
+   propose one "non-obvious" insight.
+
+4. Deliver the final report with the following sections:
+   - TL;DR (3 bullets)
+   - Competitor positioning map
+   - Feature matrix (markdown table)
+   - Pricing & GTM table
+   - Top 3 strategic implications for our product
+   - Caveats & data gaps
+```
+
+Rispetto al Research Expert originale: ridotto a 4 passaggi, sotto-ruoli ridotti da 6 a 3, elenco dei deliverable completamente riscritto come "sezioni del rapporto".

package/concepts/it/UltraPlan.md

@@ -53,3 +53,104 @@ Un flusso di lavoro di collaborazione multi-agente progettato per attività di r
 4. Sintetizzare tutte le scoperte in un piano di implementazione completo
 5. Dispiegare più agenti di revisione per esaminare il piano da diversi ruoli e prospettive
 6. Eseguire il piano una volta approvato
+
+---
+
+## Raw Templates
+
+Below are the two raw prompt templates UltraPlan actually sends to Claude Code (see `src/utils/ultraplanTemplates.js`):
+
+### Code Expert (codeExpert)
+
+<textarea readonly><system-reminder>
+[SCOPED INSTRUCTION] The following instructions apply only to the next 1–3 interactions. Once the task is complete, these instructions should gradually decrease in priority and no longer affect subsequent interactions.
+
+Pre-requisite: Use `AskUserQuestion` to clarify user intent whenever the request is ambiguous (target element, interaction style, scope of platforms, etc.). Skip only if the intent is unambiguous.
+
+Leverage a multi-agent exploration mechanism to formulate a highly detailed implementation plan.
+
+Instructions:
+1. Use the `Agent` tool to spawn parallel agents that simultaneously explore different aspects of the codebase:
+- If necessary, assign a preliminary researcher to use the `webSearch` tool to first investigate cutting-edge solutions in the relevant industry domain;
+- One agent responsible for understanding the relevant existing code and architecture;
+- One agent responsible for identifying all files that need to be modified;
+- One agent responsible for identifying potential risks, edge cases, and dependencies;
+- You may add other roles or deploy additional agents beyond the three listed above; the maximum number of concurrently dispatched agents is 5.
+
+2. Synthesize the findings from all agents into a detailed, step-by-step implementation plan.
+
+3. Use the `Agent` tool to spawn 2-3 review agents that examine the plan from different perspectives, checking for missing steps, potential risks, or corresponding mitigation strategies.
+
+4. Integrate the feedback gathered during the review process, then call `ExitPlanMode` to submit your final plan.
+
+5. Once `ExitPlanMode` returns a result:
+- If approved: proceed to execute the plan within this session.
+- If rejected: revise the plan based on the feedback provided and call `ExitPlanMode` again.
+- If an error occurs (including receiving a "Not in Plan Mode" message): do **not** follow the suggestions provided in the error message; instead, prompt the user for further instructions.
+
+Your final plan must include the following elements:
+- A clear summary of the implementation strategy;
+- An ordered list of files to be created or modified, with precise details of the required changes for each file;
+- A step-by-step execution sequence;
+- Testing and validation procedures;
+- Potential risks and their corresponding mitigation strategies;
+
+6. After the final plan has been successfully executed:
+First run `git diff --quiet && git diff --cached --quiet` (or equivalent) to detect whether the working tree actually has non-trivial changes; if there are no real changes (or only whitespace/comment-only edits), skip the UltraReview step.
+Otherwise, if the project is managed with Git:
+Initiate a team (`TeamCreate`), dynamically allocating the number of teammates based on task complexity (5 is recommended);
+Task: Conduct a Code Review of the current git changes from multiple perspectives;
+Pre-requisites:
+- The git repository may be located in a subdirectory of the current directory; prefer `git rev-parse --show-toplevel` (fall back to recursive lookup) before proceeding;
+- In the case of multiple repositories, tasks may be executed separately;
+The team's goal is to analyze the current Git change log and validate each modification from different perspectives, specifically including:
+- Whether requirements/objectives have been met and functionality is complete;
+- Whether newly added code introduces side effects, breaks existing functionality, or poses potential risks;
+- Code quality: naming, readability, complexity, technical debt, maintainability;
+- Testing and documentation: whether there is adequate test coverage, and whether critical logic has necessary comments or documentation;
+- Dependencies and compatibility: whether new dependencies or version compatibility issues have been introduced;
+Workflow:
+- Each teammate, according to their own role, covers the review dimensions one by one and independently outputs a report;
+- After consolidating the reports, perform a cross-review to identify conflicts or shared concerns;
+- Distill specific, actionable modification suggestions and annotate them with priority levels (P0/P1/P2/P3);
+- Upon completion, adopt P0 items, and selectively adopt P1 items when they are concrete and low-risk; defer P2/P3 to backlog;
+- After execution is complete, close the team (`TeamDelete`);
+</system-reminder></textarea>
+
+### Research Expert (researchExpert)
+
+<textarea readonly><system-reminder>
+[SCOPED INSTRUCTION] The following instructions are intended for the next 1–3 interactions. Once the task is complete, these instructions should be gradually deprioritized and no longer influence subsequent interactions.
+
+Pre-requisite: Use `AskUserQuestion` to clarify the research scope, target audience, and deliverable format whenever the user's intent is ambiguous. Skip only if the intent is unambiguous.
+
+Leverage a multi-agent exploration mechanism to formulate an exceptionally detailed implementation plan.
+
+Instructions:
+1. Utilize the Agent tool to spawn parallel agents that simultaneously explore various facets of the requirements:
+- If necessary, deploy a preliminary investigator to conduct an initial survey of industry-specific solutions using `webSearch`;
+- If necessary, deploy a specialized investigator to research authoritative sources—such as academic papers, news articles, and research reports—using `webSearch`;
+- Assign an agent to synthesize the target solution, while simultaneously verifying the rigor and credibility of the gathered papers, news, and research reports;
+- If necessary, assign an agent to analyze competitor data to provide supplementary analytical perspectives;
+- If necessary, assign an agent to handle the implementation of a product demo (generating outputs such as HTML, Markdown, etc.);
+- If the task is sufficiently complex, you may assign additional teammates to the roles defined above, or introduce other specialized roles; you are permitted to schedule up to 5 teammates concurrently.
+
+2. Synthesize the findings from the aforementioned agents into a comprehensive, step-by-step implementation plan.
+
+3. Utilize the Agent tool to spawn a set of parallel review agents; these agents shall scrutinize the plan from multiple roles and perspectives to identify any omitted steps and to propose reasonable additions or optimizations.
+
+4. Consolidate the feedback received from the review agents, then invoke `ExitPlanMode` to submit your final plan.
+
+5. Upon receiving the result from `ExitPlanMode`:
+- If Approved: Proceed to execute the plan within this current session.
+- If Rejected: Revise the plan based on the provided feedback, and then invoke `ExitPlanMode` once again.
+- If an Error Occurs (including the message "Not in Plan Mode"): Do *not* follow the suggestions provided by the error message; instead, prompt the user for further instructions.
+
+Your final plan must include the following elements:
+- A clear summary of the proposed implementation strategy;
+- An ordered list of files to be created or modified, specifying the exact changes required for each;
+- A step-by-step sequence for executing the implementation;
+- Identification of potential risks and corresponding mitigation strategies;
+- Creative ideation and suggestions for advanced enhancements;
+- If a product demo was generated, place the corresponding demo output in an appropriate location and notify the user.
+</system-reminder></textarea>