cc-viewer 1.6.281 → 1.6.283

package/README.md

@@ -205,6 +205,14 @@ You can customize plugins directly, manage all cc-viewer processes, and cc-viewe
 
 More features waiting for you to discover... for example: the system supports Agent Team and ships with a built-in Code Reviewer. Codex Code Reviewer integration is coming very soon (I strongly recommend using Codex to review Claude Code's code).
 
+<a href="https://www.star-history.com/?repos=weiesky%2Fcc-viewer&type=date&legend=top-left">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=weiesky/cc-viewer&type=date&theme=dark&legend=top-left" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=weiesky/cc-viewer&type=date&legend=top-left" />
+   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=weiesky/cc-viewer&type=date&legend=top-left" />
+ </picture>
+</a>
+
 ## License
 
 MIT

package/concepts/ar/Tool-LSP.md

@@ -0,0 +1,28 @@
+# LSP
+
+يستعلم من خوادم بروتوكول خادم اللغة (LSP) للحصول على ذكاء الشيفرة — التعريفات والمراجع والتلميحات والرموز والتنفيذات وتسلسل الاستدعاءات. أكثر دقة من البحث النصي لأنه يفهم الشيفرة دلاليًا.
+
+## متى تستخدمه
+
+- الانتقال إلى تعريف رمز (`goToDefinition`) أو العثور على كل مرجع له (`findReferences`)
+- قراءة توقيعات الأنواع / التوثيق لرمز ما (`hover`)
+- سرد الرموز في ملف واحد (`documentSymbol`) أو البحث عنها عبر المشروع بأكمله (`workspaceSymbol`)
+- العثور على تنفيذات واجهة أو طريقة مجردة (`goToImplementation`)
+- التنقل في تسلسل استدعاءات دالة (`prepareCallHierarchy` و`incomingCalls` و`outgoingCalls`)
+
+## المعاملات
+
+- `operation` (string، مطلوب): إحدى العمليات المذكورة أعلاه.
+- `filePath` (string، مطلوب): الملف المراد العمل عليه.
+- `line` (number، مطلوب): رقم السطر يبدأ من 1، كما هو معروض في المحرر.
+- `character` (number، مطلوب): إزاحة الحرف تبدأ من 1، كما هي معروضة في المحرر.
+
+## ملاحظات
+
+- يتطلب خادم LSP مُهيَّأً لنوع الملف هذا؛ وإلا فإن الاستدعاء يُرجع خطأً.
+- يبدأ السطر والحرف من 1 (إحداثيات المحرر)، وليس من 0.
+- فضِّل LSP على `Grep` عندما تحتاج إلى تنقل دلالي (تعريف/مرجع حقيقي) بدلاً من تطابق نصي.
+
+## مفاهيم ذات صلة
+
+- يكمّل `Read` و`Edit` عند التنقل في الشيفرة وتعديلها.

package/concepts/ar/Tool-Workflow.md

@@ -0,0 +1,26 @@
+# Workflow
+
+يشغّل نصًا برمجيًا ينسّق العديد من الوكلاء الفرعيين بشكل حتمي — التوزيع المتوازي والمسارات والحلقات والتحقق — للأعمال الواسعة جدًا أو غير المؤكدة جدًا أو الكبيرة جدًا بحيث لا يستوعبها سياق واحد.
+
+## متى تستخدمه
+
+- تفكيك مهمة كبيرة وتغطيتها بالتوازي عبر العديد من الوكلاء
+- التحقق المتبادل من النتائج بتحقق مستقل أو تنافسي قبل الاعتماد عليها
+- التعامل مع نطاق لا يستوعبه سياق واحد: عمليات الترحيل والتدقيقات والمسوحات الواسعة متعددة الملفات
+
+## كيف يعمل
+
+- يعمل في الخلفية؛ ويتم إشعارك عند انتهائه. تابع التقدم المباشر عبر `/workflows`.
+- ينسّق النص البرمجي الوكلاء باستخدام `agent()` و`parallel()` و`pipeline()` و`phase()`.
+- يدفق `pipeline()` كل عنصر عبر المراحل دون حاجز (الوضع الافتراضي)؛ بينما `parallel()` حاجز ينتظر جميع النتائج.
+- مع `schema`، يُرجع كل `agent()` بيانات منظمة ومُتحقَّقًا منها بدلاً من نص حر.
+
+## ملاحظات
+
+- لا يعمل إلا عندما يختار المستخدم صراحةً تنسيق متعدد الوكلاء؛ فقد يُنشئ العديد من الوكلاء ويستهلك قدرًا كبيرًا من الرموز (token).
+- التزامن محدود بسقف لكل سير عمل؛ والوكلاء الزائدون ينتظرون في طابور ويعملون كلما تحررت الفتحات.
+- لوكيل فرعي واحد، استخدم أداة `Agent` بدلاً من ذلك — واحتفظ بـ Workflow للتوزيع المتوازي الحقيقي.
+
+## مفاهيم ذات صلة
+
+- يُبنى على أداة `Agent`، مشغّلاً العديد من الوكلاء ضمن تدفق تحكم حتمي.

package/concepts/da/Tool-LSP.md

@@ -0,0 +1,28 @@
+# LSP
+
+Forespørger Language Server Protocol-servere (LSP) for kodeintelligens — definitioner, referencer, hover, symboler, implementeringer og kaldhierarki. Mere præcist end tekstsøgning, fordi det forstår kode semantisk.
+
+## Hvornår skal det bruges
+
+- Spring til et symbols definition (`goToDefinition`) eller find alle referencer (`findReferences`)
+- Læs typesignaturer / dokumentation for et symbol (`hover`)
+- List symboler i én fil (`documentSymbol`) eller søg efter dem på tværs af projektet (`workspaceSymbol`)
+- Find implementeringer af en grænseflade eller abstrakt metode (`goToImplementation`)
+- Gennemløb kaldhierarkiet for en funktion (`prepareCallHierarchy`, `incomingCalls`, `outgoingCalls`)
+
+## Parametre
+
+- `operation` (streng, påkrævet): en af de operationer, der er nævnt ovenfor.
+- `filePath` (streng, påkrævet): den fil, der skal arbejdes på.
+- `line` (tal, påkrævet): 1-baseret linjenummer, som vist i editoren.
+- `character` (tal, påkrævet): 1-baseret tegnforskydning, som vist i editoren.
+
+## Noter
+
+- Kræver en konfigureret LSP-server til den filtype; ellers returnerer kaldet en fejl.
+- Linje og tegn er 1-baserede (editorkoordinater), ikke 0-baserede.
+- Foretræk LSP frem for `Grep`, når du har brug for semantisk navigation (sand definition/reference) frem for et tekstmatch.
+
+## Relaterede begreber
+
+- Supplerer `Read` og `Edit`, når du navigerer i og ændrer kode.

package/concepts/da/Tool-Workflow.md

@@ -0,0 +1,26 @@
+# Workflow
+
+Kører et script, der deterministisk orkestrerer mange underagenter — fan-out, pipelines, løkker og verifikation — til arbejde, der er for bredt, for usikkert eller for stort til en enkelt kontekst.
+
+## Hvornår skal det bruges
+
+- Nedbryd en stor opgave og dæk den parallelt på tværs af mange agenter
+- Krydstjek fund med uafhængig eller adversarial verifikation, før du fæster lid til dem
+- Tag fat på skala, som én kontekst ikke kan rumme: migreringer, audits, brede gennemløb af mange filer
+
+## Sådan fungerer det
+
+- Kører i baggrunden; du får besked, når det er færdigt. Følg den løbende fremdrift med `/workflows`.
+- Scriptet koordinerer agenter med `agent()`, `parallel()`, `pipeline()` og `phase()`.
+- `pipeline()` streamer hvert element gennem stadierne uden barriere (standard); `parallel()` er en barriere, der venter på alle resultater.
+- Med et schema returnerer hvert `agent()` valideret struktureret data i stedet for fri tekst.
+
+## Noter
+
+- Kører kun, når brugeren udtrykkeligt vælger orkestrering med flere agenter; det kan starte mange agenter og forbruge betydelige tokens.
+- Samtidigheden er begrænset pr. workflow; overskydende agenter sættes i kø og kører, efterhånden som pladser bliver ledige.
+- Til en enkelt underagent skal du bruge `Agent`-værktøjet i stedet — gem Workflow til reel fan-out.
+
+## Relaterede begreber
+
+- Bygger på `Agent`-værktøjet og kører mange agenter under deterministisk kontrolflow.

package/concepts/de/Tool-LSP.md

@@ -0,0 +1,28 @@
+# LSP
+
+Fragt Language-Server-Protocol-(LSP-)Server nach Code-Intelligenz ab — Definitionen, Referenzen, Hover-Informationen, Symbole, Implementierungen und Aufrufhierarchie. Präziser als eine Textsuche, weil es Code semantisch versteht.
+
+## Wann zu verwenden
+
+- Zur Definition eines Symbols springen (`goToDefinition`) oder jede Referenz finden (`findReferences`)
+- Typsignaturen / Dokumentation für ein Symbol lesen (`hover`)
+- Symbole in einer Datei auflisten (`documentSymbol`) oder projektweit danach suchen (`workspaceSymbol`)
+- Implementierungen einer Schnittstelle oder abstrakten Methode finden (`goToImplementation`)
+- Die Aufrufhierarchie einer Funktion durchlaufen (`prepareCallHierarchy`, `incomingCalls`, `outgoingCalls`)
+
+## Parameter
+
+- `operation` (string, erforderlich): eine der oben aufgeführten Operationen.
+- `filePath` (string, erforderlich): die zu bearbeitende Datei.
+- `line` (number, erforderlich): 1-basierte Zeilennummer, wie im Editor angezeigt.
+- `character` (number, erforderlich): 1-basierter Zeichenoffset, wie im Editor angezeigt.
+
+## Hinweise
+
+- Erfordert einen konfigurierten LSP-Server für diesen Dateityp; andernfalls gibt der Aufruf einen Fehler zurück.
+- Zeile und Zeichen sind 1-basiert (Editor-Koordinaten), nicht 0-basiert.
+- Bevorzuge LSP gegenüber `Grep`, wenn du semantische Navigation (echte Definition/Referenz) statt einer textuellen Übereinstimmung benötigst.
+
+## Verwandte Konzepte
+
+- Ergänzt `Read` und `Edit` beim Navigieren und Ändern von Code.

package/concepts/de/Tool-Workflow.md

@@ -0,0 +1,26 @@
+# Workflow
+
+Führt ein Skript aus, das viele Subagenten deterministisch orchestriert — Fan-out, Pipelines, Schleifen und Verifizierung — für Arbeit, die zu breit, zu unsicher oder zu groß für einen einzelnen Kontext ist.
+
+## Wann zu verwenden
+
+- Eine große Aufgabe zerlegen und parallel über viele Agenten hinweg abdecken
+- Ergebnisse durch unabhängige oder adversariale Verifizierung gegenprüfen, bevor man sich auf sie verlässt
+- Einen Umfang bewältigen, den ein einzelner Kontext nicht fassen kann: Migrationen, Audits, breite dateiübergreifende Durchläufe
+
+## Funktionsweise
+
+- Läuft im Hintergrund; du wirst benachrichtigt, wenn es fertig ist. Verfolge den Live-Fortschritt mit `/workflows`.
+- Das Skript koordiniert Agenten mit `agent()`, `parallel()`, `pipeline()` und `phase()`.
+- `pipeline()` streamt jedes Element ohne Barriere durch die Stufen (Standard); `parallel()` ist eine Barriere, die auf alle Ergebnisse wartet.
+- Mit einem `schema` gibt jeder `agent()` validierte strukturierte Daten statt Freitext zurück.
+
+## Hinweise
+
+- Läuft nur, wenn sich der Benutzer ausdrücklich für eine Multi-Agenten-Orchestrierung entscheidet; es kann viele Agenten erzeugen und erhebliche Token verbrauchen.
+- Die Nebenläufigkeit ist pro Workflow gedeckelt; überschüssige Agenten werden in eine Warteschlange gestellt und laufen, sobald Plätze frei werden.
+- Für einen einzelnen Subagenten verwende stattdessen das Werkzeug `Agent` — reserviere Workflow für echtes Fan-out.
+
+## Verwandte Konzepte
+
+- Baut auf dem Werkzeug `Agent` auf und führt viele Agenten unter deterministischem Kontrollfluss aus.

package/concepts/en/Tool-LSP.md

@@ -0,0 +1,28 @@
+# LSP
+
+Queries Language Server Protocol (LSP) servers for code intelligence — definitions, references, hovers, symbols, implementations, and call hierarchy. More precise than text search because it understands code semantically.
+
+## When to Use
+
+- Jump to a symbol's definition (`goToDefinition`) or find every reference (`findReferences`)
+- Read type signatures / documentation for a symbol (`hover`)
+- List symbols in one file (`documentSymbol`) or search them across the project (`workspaceSymbol`)
+- Find implementations of an interface or abstract method (`goToImplementation`)
+- Walk the call hierarchy of a function (`prepareCallHierarchy`, `incomingCalls`, `outgoingCalls`)
+
+## Parameters
+
+- `operation` (string, required): one of the operations listed above.
+- `filePath` (string, required): the file to operate on.
+- `line` (number, required): 1-based line number, as shown in the editor.
+- `character` (number, required): 1-based character offset, as shown in the editor.
+
+## Notes
+
+- Requires a configured LSP server for that file type; otherwise the call returns an error.
+- Line and character are 1-based (editor coordinates), not 0-based.
+- Prefer LSP over `Grep` when you need semantic navigation (true definition/reference) rather than a textual match.
+
+## Related Concepts
+
+- Complements `Read` and `Edit` when navigating and changing code.

package/concepts/en/Tool-Workflow.md

@@ -0,0 +1,26 @@
+# Workflow
+
+Runs a script that orchestrates many subagents deterministically — fan-out, pipelines, loops, and verification — for work that is too broad, too uncertain, or too large for a single context.
+
+## When to Use
+
+- Decompose a large task and cover it in parallel across many agents
+- Cross-check findings with independent or adversarial verification before committing to them
+- Take on scale one context can't hold: migrations, audits, broad multi-file sweeps
+
+## How It Works
+
+- Runs in the background; you are notified when it finishes. Watch live progress with `/workflows`.
+- The script coordinates agents with `agent()`, `parallel()`, `pipeline()`, and `phase()`.
+- `pipeline()` streams each item through stages with no barrier (default); `parallel()` is a barrier that waits for all results.
+- With a schema, each `agent()` returns validated structured data instead of free text.
+
+## Notes
+
+- Only runs when the user explicitly opts into multi-agent orchestration; it can spawn many agents and consume significant tokens.
+- Concurrency is capped per workflow; excess agents queue and run as slots free up.
+- For a single subagent, use the `Agent` tool instead — reserve Workflow for real fan-out.
+
+## Related Concepts
+
+- Builds on the `Agent` tool, running many agents under deterministic control flow.

package/concepts/es/Tool-LSP.md

@@ -0,0 +1,28 @@
+# LSP
+
+Consulta servidores Language Server Protocol (LSP) para obtener inteligencia de código: definiciones, referencias, información al pasar el cursor, símbolos, implementaciones y jerarquía de llamadas. Más preciso que la búsqueda de texto porque entiende el código de forma semántica.
+
+## Cuándo usarlo
+
+- Saltar a la definición de un símbolo (`goToDefinition`) o encontrar cada una de sus referencias (`findReferences`)
+- Leer las firmas de tipos / la documentación de un símbolo (`hover`)
+- Listar los símbolos de un archivo (`documentSymbol`) o buscarlos en todo el proyecto (`workspaceSymbol`)
+- Encontrar las implementaciones de una interfaz o un método abstracto (`goToImplementation`)
+- Recorrer la jerarquía de llamadas de una función (`prepareCallHierarchy`, `incomingCalls`, `outgoingCalls`)
+
+## Parámetros
+
+- `operation` (string, obligatorio): una de las operaciones enumeradas arriba.
+- `filePath` (string, obligatorio): el archivo sobre el que operar.
+- `line` (number, obligatorio): número de línea basado en 1, tal como se muestra en el editor.
+- `character` (number, obligatorio): desplazamiento de carácter basado en 1, tal como se muestra en el editor.
+
+## Notas
+
+- Requiere un servidor LSP configurado para ese tipo de archivo; de lo contrario, la llamada devuelve un error.
+- La línea y el carácter están basados en 1 (coordenadas del editor), no en 0.
+- Prefiere LSP frente a `Grep` cuando necesites navegación semántica (definición/referencia real) en lugar de una coincidencia textual.
+
+## Conceptos relacionados
+
+- Complementa a `Read` y `Edit` al navegar y modificar código.

package/concepts/es/Tool-Workflow.md

@@ -0,0 +1,26 @@
+# Workflow
+
+Ejecuta un script que orquesta muchos subagentes de forma determinista —distribución en abanico, canalizaciones, bucles y verificación— para trabajo demasiado amplio, demasiado incierto o demasiado grande para un solo contexto.
+
+## Cuándo usarlo
+
+- Descomponer una tarea grande y cubrirla en paralelo a través de muchos agentes
+- Contrastar los hallazgos con una verificación independiente o adversarial antes de confiar en ellos
+- Abordar una escala que un solo contexto no puede contener: migraciones, auditorías, barridos amplios en múltiples archivos
+
+## Cómo funciona
+
+- Se ejecuta en segundo plano; se te notifica cuando termina. Sigue el progreso en directo con `/workflows`.
+- El script coordina agentes con `agent()`, `parallel()`, `pipeline()` y `phase()`.
+- `pipeline()` transmite cada elemento a través de las etapas sin barrera (por defecto); `parallel()` es una barrera que espera todos los resultados.
+- Con un `schema`, cada `agent()` devuelve datos estructurados y validados en lugar de texto libre.
+
+## Notas
+
+- Solo se ejecuta cuando el usuario opta explícitamente por la orquestación multiagente; puede generar muchos agentes y consumir una cantidad considerable de token.
+- La concurrencia tiene un límite por workflow; los agentes sobrantes se ponen en cola y se ejecutan a medida que se liberan espacios.
+- Para un solo subagente, usa en su lugar la herramienta `Agent`; reserva Workflow para una verdadera distribución en abanico.
+
+## Conceptos relacionados
+
+- Se basa en la herramienta `Agent`, ejecutando muchos agentes bajo un flujo de control determinista.

package/concepts/fr/Tool-LSP.md

@@ -0,0 +1,28 @@
+# LSP
+
+Interroge les serveurs Language Server Protocol (LSP) pour obtenir de l'intelligence de code — définitions, références, info-bulles, symboles, implémentations et hiérarchie d'appels. Plus précis qu'une recherche textuelle, car il comprend le code de manière sémantique.
+
+## Quand l'utiliser
+
+- Sauter à la définition d'un symbole (`goToDefinition`) ou trouver chacune de ses références (`findReferences`)
+- Lire les signatures de types / la documentation d'un symbole (`hover`)
+- Lister les symboles d'un fichier (`documentSymbol`) ou les rechercher dans tout le projet (`workspaceSymbol`)
+- Trouver les implémentations d'une interface ou d'une méthode abstraite (`goToImplementation`)
+- Parcourir la hiérarchie d'appels d'une fonction (`prepareCallHierarchy`, `incomingCalls`, `outgoingCalls`)
+
+## Paramètres
+
+- `operation` (string, requis) : l'une des opérations énumérées ci-dessus.
+- `filePath` (string, requis) : le fichier sur lequel opérer.
+- `line` (number, requis) : numéro de ligne commençant à 1, tel qu'affiché dans l'éditeur.
+- `character` (number, requis) : décalage de caractère commençant à 1, tel qu'affiché dans l'éditeur.
+
+## Notes
+
+- Nécessite un serveur LSP configuré pour ce type de fichier ; sinon, l'appel renvoie une erreur.
+- La ligne et le caractère commencent à 1 (coordonnées de l'éditeur), pas à 0.
+- Préférez LSP à `Grep` lorsque vous avez besoin d'une navigation sémantique (définition/référence réelle) plutôt que d'une correspondance textuelle.
+
+## Concepts associés
+
+- Complète `Read` et `Edit` lors de la navigation dans le code et de sa modification.

package/concepts/fr/Tool-Workflow.md

@@ -0,0 +1,26 @@
+# Workflow
+
+Exécute un script qui orchestre de nombreux sous-agents de manière déterministe — diffusion en éventail, pipelines, boucles et vérification — pour un travail trop vaste, trop incertain ou trop volumineux pour un seul contexte.
+
+## Quand l'utiliser
+
+- Décomposer une tâche volumineuse et la couvrir en parallèle sur de nombreux agents
+- Recouper les résultats par une vérification indépendante ou contradictoire avant de s'y fier
+- Prendre en charge une échelle qu'un seul contexte ne peut contenir : migrations, audits, balayages étendus sur plusieurs fichiers
+
+## Fonctionnement
+
+- S'exécute en arrière-plan ; vous êtes notifié à la fin. Suivez la progression en direct avec `/workflows`.
+- Le script coordonne les agents avec `agent()`, `parallel()`, `pipeline()` et `phase()`.
+- `pipeline()` fait transiter chaque élément à travers les étapes sans barrière (par défaut) ; `parallel()` est une barrière qui attend tous les résultats.
+- Avec un `schema`, chaque `agent()` renvoie des données structurées validées plutôt qu'un texte libre.
+
+## Notes
+
+- Ne s'exécute que lorsque l'utilisateur opte explicitement pour une orchestration multi-agents ; il peut générer de nombreux agents et consommer une quantité importante de token.
+- La concurrence est plafonnée par workflow ; les agents excédentaires sont mis en file d'attente et s'exécutent à mesure que des emplacements se libèrent.
+- Pour un seul sous-agent, utilisez plutôt l'outil `Agent` — réservez Workflow à une véritable diffusion en éventail.
+
+## Concepts associés
+
+- S'appuie sur l'outil `Agent`, en exécutant de nombreux agents sous un flux de contrôle déterministe.

package/concepts/it/Tool-LSP.md

@@ -0,0 +1,28 @@
+# LSP
+
+Interroga i server del Language Server Protocol (LSP) per ottenere intelligenza sul codice — definizioni, riferimenti, hover, simboli, implementazioni e gerarchia delle chiamate. Più preciso della ricerca testuale perché comprende il codice in modo semantico.
+
+## Quando usare
+
+- Saltare alla definizione di un simbolo (`goToDefinition`) o trovare ogni riferimento (`findReferences`)
+- Leggere le firme di tipo / la documentazione di un simbolo (`hover`)
+- Elencare i simboli in un file (`documentSymbol`) o cercarli in tutto il progetto (`workspaceSymbol`)
+- Trovare le implementazioni di un'interfaccia o di un metodo astratto (`goToImplementation`)
+- Percorrere la gerarchia delle chiamate di una funzione (`prepareCallHierarchy`, `incomingCalls`, `outgoingCalls`)
+
+## Parametri
+
+- `operation` (string, obbligatorio): una delle operazioni elencate sopra.
+- `filePath` (string, obbligatorio): il file su cui operare.
+- `line` (number, obbligatorio): numero di riga a base 1, come mostrato nell'editor.
+- `character` (number, obbligatorio): offset di carattere a base 1, come mostrato nell'editor.
+
+## Note
+
+- Richiede un server LSP configurato per quel tipo di file; altrimenti la chiamata restituisce un errore.
+- Riga e carattere sono a base 1 (coordinate dell'editor), non a base 0.
+- Preferisci LSP a `Grep` quando hai bisogno di navigazione semantica (definizione/riferimento reali) anziché di una corrispondenza testuale.
+
+## Concetti correlati
+
+- Complementa `Read` ed `Edit` quando navighi e modifichi il codice.

package/concepts/it/Tool-Workflow.md

@@ -0,0 +1,26 @@
+# Workflow
+
+Esegue uno script che orchestra molti subagenti in modo deterministico — fan-out, pipeline, loop e verifica — per lavoro troppo ampio, troppo incerto o troppo grande per un singolo contesto.
+
+## Quando usare
+
+- Scomporre un compito grande e coprirlo in parallelo su molti agenti
+- Verificare i risultati con una verifica indipendente o avversaria prima di farli propri
+- Affrontare una scala che un singolo contesto non può contenere: migrazioni, audit, ampie scansioni multi-file
+
+## Come funziona
+
+- Viene eseguito in background; ricevi una notifica al termine. Osserva il progresso in tempo reale con `/workflows`.
+- Lo script coordina gli agenti con `agent()`, `parallel()`, `pipeline()` e `phase()`.
+- `pipeline()` fa scorrere ogni elemento attraverso gli stadi senza barriera (default); `parallel()` è una barriera che attende tutti i risultati.
+- Con uno schema, ogni `agent()` restituisce dati strutturati validati anziché testo libero.
+
+## Note
+
+- Viene eseguito solo quando l'utente sceglie esplicitamente l'orchestrazione multi-agente; può generare molti agenti e consumare un numero significativo di token.
+- La concorrenza è limitata per ciascun workflow; gli agenti in eccesso si accodano e vengono eseguiti man mano che si liberano slot.
+- Per un singolo subagente, usa invece il tool `Agent` — riserva Workflow per un vero fan-out.
+
+## Concetti correlati
+
+- Si basa sul tool `Agent`, eseguendo molti agenti sotto un flusso di controllo deterministico.

package/concepts/ja/Tool-LSP.md

@@ -0,0 +1,28 @@
+# LSP
+
+Language Server Protocol (LSP) サーバーに問い合わせてコードインテリジェンス — 定義、参照、ホバー、シンボル、実装、呼び出し階層 — を取得します。コードを意味的に理解するため、テキスト検索よりも正確です。
+
+## 使用タイミング
+
+- シンボルの定義へジャンプする (`goToDefinition`)、またはすべての参照を見つける (`findReferences`)
+- シンボルの型シグネチャ / ドキュメントを読む (`hover`)
+- 1 つのファイル内のシンボルを一覧する (`documentSymbol`)、またはプロジェクト全体で検索する (`workspaceSymbol`)
+- インターフェースや抽象メソッドの実装を見つける (`goToImplementation`)
+- 関数の呼び出し階層をたどる (`prepareCallHierarchy`、`incomingCalls`、`outgoingCalls`)
+
+## パラメータ
+
+- `operation` (string, required): 上記のいずれかの操作。
+- `filePath` (string, required): 操作対象のファイル。
+- `line` (number, required): エディタに表示される 1 始まりの行番号。
+- `character` (number, required): エディタに表示される 1 始まりの文字オフセット。
+
+## 注意事項
+
+- そのファイルタイプ用に構成された LSP サーバーが必要です。そうでない場合、呼び出しはエラーを返します。
+- line と character は 0 始まりではなく 1 始まり (エディタ座標) です。
+- テキストの一致ではなく意味的なナビゲーション (真の定義/参照) が必要な場合は、`Grep` よりも LSP を優先してください。
+
+## 関連概念
+
+- コードをナビゲートして変更する際に `Read` と `Edit` を補完します。

package/concepts/ja/Tool-Workflow.md

@@ -0,0 +1,26 @@
+# Workflow
+
+多数のサブエージェントを決定論的にオーケストレーションする — ファンアウト、パイプライン、ループ、検証 — スクリプトを実行します。単一のコンテキストには広すぎる、不確実すぎる、または大きすぎる作業向けです。
+
+## 使用タイミング
+
+- 大きなタスクを分解し、多数のエージェントにまたがって並列にカバーする
+- 結果を採用する前に、独立したまたは敵対的な検証でクロスチェックする
+- 単一のコンテキストでは保持できない規模に取り組む: 移行、監査、広範な複数ファイルの一括処理
+
+## 仕組み
+
+- バックグラウンドで実行され、完了時に通知されます。`/workflows` でライブの進捗を確認できます。
+- スクリプトは `agent()`、`parallel()`、`pipeline()`、`phase()` でエージェントを調整します。
+- `pipeline()` は各アイテムをバリアなしでステージにストリームします (デフォルト)。`parallel()` はすべての結果を待つバリアです。
+- スキーマを指定すると、各 `agent()` は自由テキストではなく検証済みの構造化データを返します。
+
+## 注意事項
+
+- ユーザーがマルチエージェントオーケストレーションを明示的に選択した場合にのみ実行されます。多数のエージェントを起動し、かなりの token を消費する可能性があります。
+- 同時実行数はワークフローごとに上限が設けられています。超過したエージェントはキューに入り、スロットが空き次第実行されます。
+- 単一のサブエージェントには、代わりに `Agent` ツールを使用してください — Workflow は真のファンアウトに留めてください。
+
+## 関連概念
+
+- `Agent` ツールを基盤とし、決定論的な制御フローのもとで多数のエージェントを実行します。

package/concepts/ko/Tool-LSP.md

@@ -0,0 +1,28 @@
+# LSP
+
+Language Server Protocol (LSP) 서버에 질의하여 코드 인텔리전스 — 정의, 참조, 호버, 심볼, 구현, 호출 계층 — 를 가져옵니다. 코드를 의미적으로 이해하므로 텍스트 검색보다 정확합니다.
+
+## 사용 시점
+
+- 심볼의 정의로 이동하거나 (`goToDefinition`) 모든 참조를 찾기 (`findReferences`)
+- 심볼의 타입 시그니처 / 문서 읽기 (`hover`)
+- 한 파일의 심볼을 나열하거나 (`documentSymbol`) 프로젝트 전체에서 검색하기 (`workspaceSymbol`)
+- 인터페이스나 추상 메서드의 구현 찾기 (`goToImplementation`)
+- 함수의 호출 계층 따라가기 (`prepareCallHierarchy`, `incomingCalls`, `outgoingCalls`)
+
+## 매개변수
+
+- `operation` (string, 필수): 위에 나열된 작업 중 하나.
+- `filePath` (string, 필수): 작업할 파일.
+- `line` (number, 필수): 에디터에 표시되는 1부터 시작하는 줄 번호.
+- `character` (number, 필수): 에디터에 표시되는 1부터 시작하는 문자 오프셋.
+
+## 참고사항
+
+- 해당 파일 타입에 맞게 구성된 LSP 서버가 필요합니다. 그렇지 않으면 호출이 오류를 반환합니다.
+- line과 character는 0부터가 아니라 1부터 시작합니다 (에디터 좌표).
+- 텍스트 일치가 아니라 의미적 탐색 (실제 정의/참조)이 필요할 때는 `Grep`보다 LSP를 선호하십시오.
+
+## 관련 개념
+
+- 코드를 탐색하고 변경할 때 `Read`와 `Edit`를 보완합니다.

package/concepts/ko/Tool-Workflow.md

@@ -0,0 +1,26 @@
+# Workflow
+
+여러 서브에이전트를 결정론적으로 오케스트레이션하는 — 팬아웃, 파이프라인, 루프, 검증 — 스크립트를 실행합니다. 단일 컨텍스트에 담기에는 너무 광범위하거나, 너무 불확실하거나, 너무 큰 작업을 위한 것입니다.
+
+## 사용 시점
+
+- 큰 작업을 분해하여 여러 에이전트에 걸쳐 병렬로 처리하기
+- 결과를 채택하기 전에 독립적이거나 적대적인 검증으로 교차 확인하기
+- 단일 컨텍스트가 담을 수 없는 규모를 다루기: 마이그레이션, 감사, 광범위한 다중 파일 일괄 작업
+
+## 작동 원리
+
+- 백그라운드에서 실행되며, 완료 시 알림을 받습니다. `/workflows`로 실시간 진행 상황을 확인하십시오.
+- 스크립트는 `agent()`, `parallel()`, `pipeline()`, `phase()`로 에이전트를 조율합니다.
+- `pipeline()`은 각 항목을 배리어 없이 단계들로 스트리밍합니다 (기본값). `parallel()`은 모든 결과를 기다리는 배리어입니다.
+- 스키마를 지정하면 각 `agent()`는 자유 텍스트 대신 검증된 구조화 데이터를 반환합니다.
+
+## 참고사항
+
+- 사용자가 다중 에이전트 오케스트레이션을 명시적으로 선택한 경우에만 실행됩니다. 많은 에이전트를 생성하고 상당한 token을 소비할 수 있습니다.
+- 동시성은 워크플로우별로 상한이 있습니다. 초과된 에이전트는 큐에 들어가며 슬롯이 비는 대로 실행됩니다.
+- 단일 서브에이전트의 경우 대신 `Agent` 도구를 사용하십시오 — Workflow는 진정한 팬아웃을 위해 남겨두십시오.
+
+## 관련 개념
+
+- `Agent` 도구를 기반으로 하여, 결정론적 제어 흐름 아래에서 여러 에이전트를 실행합니다.

package/concepts/no/Tool-LSP.md

@@ -0,0 +1,28 @@
+# LSP
+
+Spør Language Server Protocol-servere (LSP) om kodeintelligens — definisjoner, referanser, hover, symboler, implementeringer og kallhierarki. Mer presist enn tekstsøk fordi det forstår kode semantisk.
+
+## Når skal det brukes
+
+- Hopp til et symbols definisjon (`goToDefinition`) eller finn alle referanser (`findReferences`)
+- Les typesignaturer / dokumentasjon for et symbol (`hover`)
+- List symboler i én fil (`documentSymbol`) eller søk etter dem på tvers av prosjektet (`workspaceSymbol`)
+- Finn implementeringer av et grensesnitt eller en abstrakt metode (`goToImplementation`)
+- Gå gjennom kallhierarkiet til en funksjon (`prepareCallHierarchy`, `incomingCalls`, `outgoingCalls`)
+
+## Parametre
+
+- `operation` (streng, påkrevd): en av operasjonene nevnt ovenfor.
+- `filePath` (streng, påkrevd): filen det skal arbeides på.
+- `line` (tall, påkrevd): 1-basert linjenummer, slik det vises i editoren.
+- `character` (tall, påkrevd): 1-basert tegnforskyvning, slik det vises i editoren.
+
+## Notater
+
+- Krever en konfigurert LSP-server for den filtypen; ellers returnerer kallet en feil.
+- Linje og tegn er 1-baserte (editorkoordinater), ikke 0-baserte.
+- Foretrekk LSP fremfor `Grep` når du trenger semantisk navigasjon (sann definisjon/referanse) i stedet for et tekstmatch.
+
+## Relaterte begreper
+
+- Utfyller `Read` og `Edit` når du navigerer i og endrer kode.

package/concepts/no/Tool-Workflow.md

@@ -0,0 +1,26 @@
+# Workflow
+
+Kjører et skript som deterministisk orkestrerer mange underagenter — fan-out, pipelines, løkker og verifisering — for arbeid som er for bredt, for usikkert eller for stort for én enkelt kontekst.
+
+## Når skal det brukes
+
+- Bryt ned en stor oppgave og dekk den parallelt på tvers av mange agenter
+- Kryssjekk funn med uavhengig eller adversariell verifisering før du fester lit til dem
+- Ta på deg skala som én kontekst ikke kan romme: migreringer, revisjoner, brede gjennomganger av mange filer
+
+## Slik fungerer det
+
+- Kjører i bakgrunnen; du får beskjed når det er ferdig. Følg fremdriften i sanntid med `/workflows`.
+- Skriptet koordinerer agenter med `agent()`, `parallel()`, `pipeline()` og `phase()`.
+- `pipeline()` streamer hvert element gjennom stadiene uten barriere (standard); `parallel()` er en barriere som venter på alle resultater.
+- Med et schema returnerer hvert `agent()` validerte strukturerte data i stedet for fri tekst.
+
+## Notater
+
+- Kjører bare når brukeren uttrykkelig velger orkestrering med flere agenter; det kan starte mange agenter og bruke betydelige tokens.
+- Samtidigheten er begrenset per workflow; overskytende agenter settes i kø og kjøres etter hvert som plasser blir ledige.
+- For én enkelt underagent bruker du `Agent`-verktøyet i stedet — reserver Workflow for reell fan-out.
+
+## Relaterte begreper
+
+- Bygger på `Agent`-verktøyet og kjører mange agenter under deterministisk kontrollflyt.

package/concepts/pl/Tool-LSP.md

@@ -0,0 +1,28 @@
+# LSP
+
+Odpytuje serwery Language Server Protocol (LSP) o inteligencję kodu — definicje, referencje, podpowiedzi (hover), symbole, implementacje i hierarchię wywołań. Bardziej precyzyjne niż wyszukiwanie tekstowe, ponieważ rozumie kod semantycznie.
+
+## Kiedy używać
+
+- Przejść do definicji symbolu (`goToDefinition`) lub znaleźć każdą referencję (`findReferences`)
+- Odczytać sygnatury typów / dokumentację symbolu (`hover`)
+- Wylistować symbole w jednym pliku (`documentSymbol`) lub wyszukać je w całym projekcie (`workspaceSymbol`)
+- Znaleźć implementacje interfejsu lub metody abstrakcyjnej (`goToImplementation`)
+- Przejść hierarchię wywołań funkcji (`prepareCallHierarchy`, `incomingCalls`, `outgoingCalls`)
+
+## Parametry
+
+- `operation` (string, wymagany): jedna z operacji wymienionych powyżej.
+- `filePath` (string, wymagany): plik, na którym wykonać operację.
+- `line` (liczba, wymagany): numer wiersza liczony od 1, tak jak pokazano w edytorze.
+- `character` (liczba, wymagany): przesunięcie znaku liczone od 1, tak jak pokazano w edytorze.
+
+## Uwagi
+
+- Wymaga skonfigurowanego serwera LSP dla danego typu pliku; w przeciwnym razie wywołanie zwraca błąd.
+- Wiersz i znak są liczone od 1 (współrzędne edytora), a nie od 0.
+- Preferuj LSP zamiast `Grep`, gdy potrzebujesz nawigacji semantycznej (prawdziwa definicja/referencja), a nie dopasowania tekstowego.
+
+## Powiązane pojęcia
+
+- Uzupełnia `Read` i `Edit` podczas nawigacji po kodzie i jego zmieniania.