# Lagune प्रॉम्प्ट के उदाहरण: Blue Team फ़्लो को ऑटोमेट करें

> कॉपी करके तुरंत इस्तेमाल करने लायक़ Lagune प्रॉम्प्ट: सिर्फ़ पढ़ने वाला स्कैन, पूरा Blue Team फ़्लो और ज़ीरो ट्रस्ट ऑडिट, साथ ही किसी कमिट, ब्रांच या PR के diff, या किसी असली सुरक्षा घटना तक सीमित पहचान।

कैनोनिकल: https://lagune.ai/hi-IN/docs/examples/prompts
भाषा: hi-IN
मूल: https://lagune.ai/docs/examples/prompts
आख़िरी अपडेट: 2026-11-06

Lagune के कॉपी करने लायक़ प्रॉम्प्ट, जिन्हें आप सीधे अपने AI एजेंट में पेस्ट कर सकते हैं।

## 💧 हल्का स्कैन

सिर्फ़ पढ़ने वाला एक स्कैन, जो ख़ुद कोड पढ़ता है और हर कमी को उसके सुधार के साथ बताता है, Blue Team फ़्लो चलाए बिना और Lagune की ट्रैकिंग में कुछ लिखे बिना।

**टिप**

यह प्लानिंग मोड में, और सुरक्षा सिद्धांत (`/lagune-charter`) तय होने पर बेहतर काम करता है।

**🪼 डिफ़ॉल्ट**

| पहलू         | फ़ायदा और नुक़सान                                             | स्तर                |
| ------------ | ------------------------------------------------------------- | ------------------- |
| **मेहनत**    | एक एजेंट स्कैन करता है और रिपोर्ट देता है, कोई सब-एजेंट नहीं। | 1/5 |
| **समय**      | तेज़। सिर्फ़ पढ़ने वाला एक ही दौर, कुछ भी लागू नहीं होता।     | 2/5 |
| **टोकन खपत** | मध्यम, साझा। पूरा स्कैन एक ही कॉन्टेक्स्ट में चलता है।        | 2/5 |

```md
/lagune तुम रक्षात्मक सुरक्षा में गहरी विशेषज्ञता रखने वाले साइबर सुरक्षा शोधकर्ता हो, और अपना ज्ञान और सटीकता बढ़ाने के लिए Lagune का इस्तेमाल कर रहे हो।

वर्कस्पेस को ख़ुद स्कैन करो और जो भी कमी मिले, उसके साथ एक ठोस सुधार बताओ। यह एक अलग स्कैन है, Blue Team फ़्लो नहीं: detect, plan, harden या verify मत चलाना, और Lagune की ट्रैकिंग में कुछ भी मत लिखना।

आख़िर में, मिली हुई हर कमी की सूची दो, हर एक के साथ उसकी गंभीरता और एक ठोस सुधार।
```

**🐬 मल्टी एजेंट**

| पहलू         | फ़ायदा और नुक़सान                                                          | स्तर                |
| ------------ | -------------------------------------------------------------------------- | ------------------- |
| **मेहनत**    | हर फ़ाइल के लिए एक सब-एजेंट, आपके कोडबेस के आकार के हिसाब से।              | 2/5 |
| **समय**      | हर फ़ाइल पर समानांतर काम, फिर सब एक रिपोर्ट में। अब भी सिर्फ़ पढ़ने वाला।  | 3/5 |
| **टोकन खपत** | ज़्यादा, लेकिन अलग-थलग। हर सब-एजेंट अपने ही कॉन्टेक्स्ट में स्कैन करता है। | 3/5 |

````md
/lagune तुम एक साइबर सुरक्षा ऑर्केस्ट्रेटर हो, जो Lagune के ज़रिए पाथ की सूची बनाता है, हर पाथ के लिए एक सब-एजेंट भेजता है और उनकी रिपोर्टें जोड़ता है (सारा कंटेंट सब-एजेंट पढ़ते हैं)।

तुम्हें मौजूदा प्रोजेक्ट के आकार के हिसाब से काम सब-एजेंट को सौंपना है: कोडबेस जितना बड़ा हो, उतने ज़्यादा सब-एजेंट भेजो, सबको एक साथ समानांतर में, और हर एक को नीचे वाला प्रॉम्प्ट दो:

```prompt
/lagune तुम रक्षात्मक सुरक्षा में गहरी विशेषज्ञता रखने वाले साइबर सुरक्षा शोधकर्ता हो, और अपना ज्ञान और सटीकता बढ़ाने के लिए Lagune का इस्तेमाल कर रहे हो।

<path> को ख़ुद स्कैन करो और जो भी कमी मिले, उसके साथ एक ठोस सुधार बताओ। यह एक अलग स्कैन है, Blue Team फ़्लो नहीं: detect, plan, harden या verify मत चलाना, और Lagune की ट्रैकिंग में कुछ भी मत लिखना।

आख़िर में, <path> में मिली हर कमी की सूची दो, हर एक के साथ उसकी गंभीरता और एक ठोस सुधार।
```

आख़िर में, सभी सब-एजेंट की रिपोर्टों को कमियों और सुधारों की एक ऐसी सूची में जोड़ दो, जो प्राथमिकता के क्रम में हो।
````

**चेतावनी**

हल्का स्कैन एक बड़ा, बिना दायरे वाला प्रॉम्प्ट होता है, इसलिए कुछ एजेंट इसे मना कर सकते हैं या बीच में ही छोड़ सकते हैं। अगर आपका एजेंट आनाकानी करे, तो इसके बजाय नीचे दिया पूरा **Blue Team फ़्लो** चलाएँ: इसके चरण दायरे में बँधे हैं और एक-एक कदम चलते हैं, इसलिए इनके रुकने की संभावना बहुत कम है।

---

## 🌊 ऑटो Blue Team ऑडिट फ़्लो

[पूरा कमांड फ़्लो](https://lagune.ai/hi-IN/docs/get-started/commands) शुरू से आख़िर तक चलाता है।

**🪼 डिफ़ॉल्ट**

| पहलू         | फ़ायदा और नुक़सान                                                                | स्तर                |
| ------------ | -------------------------------------------------------------------------------- | ------------------- |
| **मेहनत**    | एक एजेंट, कोई सब-एजेंट नहीं, कोडबेस का आकार चाहे जो हो।                          | 3/5 |
| **समय**      | मध्यम, लेकिन बड़े कोडबेस में कम गहराई से। हर कमांड एक बार, एक के बाद एक चलती है। | 4/5 |
| **टोकन खपत** | कम, लेकिन कम अलग-थलग। हर कमांड एक ही कॉन्टेक्स्ट साझा करती है।                   | 4/5 |

```md
ये कमांड एक-एक करके चलाओ: `/lagune-charter`, `/lagune-detect`, `/lagune-plan`, `/lagune-harden` और `/lagune-verify`।

## लूप

जब `/lagune-verify` एक या ज़्यादा सुधार नामंज़ूर करे, तो `/lagune-harden` और फिर `/lagune-verify` तब तक दोहराओ, जब तक सारे निष्कर्ष ठीक से हल न हो जाएँ।
```

**🐋 मल्टी एजेंट (डीप स्कैन)**

| पहलू         | फ़ायदा और नुक़सान                                                                                                                             | स्तर                |
| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- |
| **मेहनत**    | सब-एजेंट की संख्या आपके कोडबेस के आकार के हिसाब से तय होती है।                                                                                | 5/5 |
| **समय**      | ज़्यादा लंबा, लेकिन ज़्यादा गहराई से। निष्कर्षों को समानांतर में पहचानने, उनकी योजना बनाने और उन्हें मज़बूत करने के लिए कई सब-एजेंट भेजता है। | 5/5 |
| **टोकन खपत** | ज़्यादा, लेकिन ज़्यादा सुरक्षित। हर सब-एजेंट का अपना अलग कॉन्टेक्स्ट होता है, बिना किसी पूर्वाग्रह के।                                        | 5/5 |

````md
ये कमांड एक-एक करके चलाओ, हर कमांड एक सब-एजेंट को देकर (बैकटिक के बिना, सिर्फ़ कमांड):

सब-एजेंट 1 का प्रॉम्प्ट: `/lagune-charter`
सब-एजेंट 2 का प्रॉम्प्ट: `/lagune-detect`
सब-एजेंट 3 का प्रॉम्प्ट: `/lagune-plan`
सब-एजेंट 4 का प्रॉम्प्ट: `/lagune-harden`
सब-एजेंट 5 का प्रॉम्प्ट: `/lagune-verify`

`/lagune-detect`, `/lagune-plan`, `/lagune-harden` और `/lagune-verify` कमांड में तुम्हें मौजूदा प्रोजेक्ट के आकार के हिसाब से काम सब-एजेंट को सौंपना है: कोडबेस जितना बड़ा हो, उतने ज़्यादा सब-एजेंट भेजने चाहिए। उदाहरण के लिए:

```prompt
/lagune-detect <path>
```

```prompt
/lagune-plan <finding>
```

```prompt
/lagune-harden <finding>
```

```prompt
/lagune-verify <finding>
```

- एक ही कमांड पर लगे कई एजेंट समानांतर में भेजो।
- सारे `/lagune-detect` सब-एजेंट पूरे होने पर, यह चलाओ:

```prompt
/lagune-detect एक जैसे निष्कर्षों को मिलाकर एक करो। नए निष्कर्ष मत खोजो, और कोडबेस को दोबारा स्कैन मत करो।
```

## लूप

जब `/lagune-verify` एक या ज़्यादा सुधार नामंज़ूर करे, तो `/lagune-harden` और फिर `/lagune-verify` तब तक दोहराओ, जब तक सारे निष्कर्ष ठीक से हल न हो जाएँ।
````

---

## 🪄 सीमित दायरे में पहचान

[`/lagune-detect`](https://lagune.ai/hi-IN/docs/commands/detect) कमांड को पूरे प्रोजेक्ट के बजाय उसके किसी हिस्से पर चलाएँ। दायरा आम भाषा में बताएँ (कोई कमिट, कोई पुल रिक्वेस्ट या कोई असली स्थिति), और यह सिर्फ़ वहीं के सुरक्षा से जुड़े निष्कर्षों का खाका बनाती है।

**टिप**

यहाँ जो कुछ भी पकड़ा जाता है, वह सामान्य निष्कर्ष ही है, इसलिए आप उसे सीधे `/lagune-plan`, `/lagune-harden` और `/lagune-verify` तक ले जा सकते हैं, सिर्फ़ उन्हीं आइटम के दायरे में।

**📌 किसी कमिट के बाद से**

नए कमिट के एक बैच की अलग से सुरक्षा जाँच करें, सिर्फ़ उन्हीं के बदलावों के दायरे में, उदाहरण के लिए:

```prompt
/lagune-detect कमिट `a1b2c3d` के बाद से जो कुछ भी बदला है, जाँच को सिर्फ़ उसी तक सीमित रखो।
```

**🔀 ब्रांच या PR का diff**

किसी पुल रिक्वेस्ट को मर्ज होने से पहले सुरक्षा के लिहाज़ से जाँचें, सिर्फ़ उसके diff के दायरे में, उदाहरण के लिए:

```prompt
/lagune-detect जाँच को सिर्फ़ उन बदलावों तक सीमित रखो जो यह ब्रांच `main` के मुक़ाबले लाती है।
```

**⛑️ किसी घटना के बाद**

जो हुआ, उसे अपने शब्दों में बताएँ। Lagune किसी फ़्लैग को नहीं, बल्कि स्थिति को पढ़ता है, और उसे एक केंद्रित खोज में बदल देता है, उदाहरण के लिए:

```prompt
/lagune-detect कुछ हफ़्ते पहले हमारी साइट से डेटा लीक हुआ था। मुझे ठीक-ठीक नहीं पता कि यह कैसे हुआ, और मुझे डर है कि कोई रास्ता अब भी खुला है जिससे डेटा फिर से लीक हो सकता है। कोड को ध्यान से देखो, ख़ासकर वहाँ जहाँ संवेदनशील डेटा पढ़ा, स्टोर या उजागर किया जाता है, और जो कुछ भी अब भी डेटा बाहर निकलने का रास्ता बन सकता है, उसका खाका बनाओ। इसे अभ्यास नहीं, असली घटना मानकर चलो।
```

---

## 🚨 ज़ीरो ट्रस्ट ऑडिट

पूरे वर्कस्पेस और हर डिपेंडेंसी को दुश्मन मानकर चलता है: यह इंटरप्रेटर, नेटवर्क कॉल, एनकोड किए गए पेलोड, और स्कैनर से बचने के लिए अनपेक्षित जगहों पर छिपाया गया कोड खोजता है, फिर आख़िर में go/no-go फ़ैसला देता है कि प्रोजेक्ट इस्तेमाल के लिए सुरक्षित है या नहीं।

ये प्रॉम्प्ट इस ऑडिट के लिए ज़रूरी विशेषज्ञताएँ सीधे लोड करते हैं, आपके प्रोजेक्ट की श्रेणियाँ चाहे जो हों। कैटलॉग की बाक़ी विशेषज्ञताओं के लिए, जिन्हें `/lagune` मिलाकर चुनता है, पक्का करें कि प्रोजेक्ट **OWASP**, **AI/LLM** और अपने स्टैक की श्रेणी (जैसे **JavaScript**, **Python** आदि) का इस्तेमाल करता हो:

```bash
npx lagune write add --categories owasp ai javascript
```

रिपॉज़िटरी की अपनी `.gitignore` फ़ाइलें और कॉन्फ़िगरेशन चेकर से फ़ाइलें छिपा सकते हैं, इसलिए [सब कुछ स्कैन करने](https://lagune.ai/hi-IN/docs/hooks/configure) के लिए `checkers` ब्लॉक को `.lagune/configs.json` में इस तरह सेट करें, और रिपॉज़िटरी के साथ आया कोई भी ब्लॉक इससे बदल दें:

```json
{
  "checkers": { "gitignore": false }
}
```

**ख़तरा**

किसी अविश्वसनीय स्रोत के प्रोजेक्ट को अपने लोकल एनवायरनमेंट में चलाते समय सावधान रहें। नुक़सानदेह कोड को अपने सिस्टम पर असर डालने से रोकने के लिए किसी अलग-थलग एनवायरनमेंट का इस्तेमाल करें, जैसे **सैंडबॉक्स** (सुझाया गया), **VM** या ऐसा ही कुछ।

**🪼 डिफ़ॉल्ट**

| पहलू         | फ़ायदा और नुक़सान                                                                          | स्तर                |
| ------------ | ------------------------------------------------------------------------------------------ | ------------------- |
| **मेहनत**    | एक एजेंट पूरे वर्कस्पेस को स्कैन करता है, कोई सब-एजेंट नहीं।                               | 2/5 |
| **समय**      | मध्यम। एक एजेंट कोड और उसकी डिपेंडेंसी को क्रम से जाँचता है।                               | 3/5 |
| **टोकन खपत** | मध्यम, लेकिन साझा। विशेषज्ञताएँ, कोड और डिपेंडेंसी, सब एक ही कॉन्टेक्स्ट में लोड होते हैं। | 3/5 |

```md
/lagune तुम ज़ीरो ट्रस्ट रक्षात्मक सुरक्षा में गहरी विशेषज्ञता रखने वाले साइबर सुरक्षा शोधकर्ता हो, और अपना ज्ञान और सटीकता बढ़ाने के लिए Lagune का इस्तेमाल कर रहे हो।

पूरे वर्कस्पेस को एक अविश्वसनीय स्रोत और संभावित रूप से नुक़सानदेह दायरा मानकर उसका खाका बनाओ। हर इंटरप्रेटर, fetch, base64 और ऐसी हर चीज़ को संभावित ख़तरा मानना है।

अपना विश्लेषण डिपेंडेंसी और सब-डिपेंडेंसी तक ले जाओ: कोई प्रोजेक्ट स्कैनर से बचने के लिए नुक़सानदेह कोड को किसी अनपेक्षित जगह छिपाने की कोशिश कर सकता है।

ज़रूरी विशेषज्ञताएँ (इन्हें `npx lagune read catalog <name>` से एक-एक करके लोड करो):

- interpreter
- secrets
- llm
- path

साफ़ कह दूँ: खाके में आई हर कमज़ोरी को, बिना किसी अपवाद के, संभावित ख़तरा मानना है।

आख़िर में, यह फ़ैसला दो कि यह प्रोजेक्ट मेरे इस्तेमाल के लिए सुरक्षित और भरोसेमंद है या नहीं।
```

**🐋 मल्टी एजेंट (डीप स्कैन)**

| पहलू         | फ़ायदा और नुक़सान                                                                                              | स्तर                |
| ------------ | -------------------------------------------------------------------------------------------------------------- | ------------------- |
| **मेहनत**    | हर फ़ाइल के लिए एक सब-एजेंट, आपके कोडबेस के आकार के हिसाब से।                                                  | 5/5 |
| **समय**      | ज़्यादा लंबा, लेकिन ज़्यादा गहराई से। फ़ाइलें समानांतर में स्कैन होती हैं, फिर सब एक फ़ैसले में जुड़ जाती हैं। | 4/5 |
| **टोकन खपत** | सबसे ज़्यादा, लेकिन सबसे सुरक्षित। हर सब-एजेंट अपने अलग-थलग कॉन्टेक्स्ट में विशेषज्ञताएँ पढ़ता है।             | 5/5 |

````md
/lagune तुम एक साइबर सुरक्षा ऑर्केस्ट्रेटर हो, जो Lagune के ज़रिए फ़ाइलों की सूची बनाता है, हर फ़ाइल के लिए एक सब-एजेंट भेजता है और रिपोर्टें तैयार करता है (सारा कंटेंट सब-एजेंट पढ़ते हैं)।

हर फ़ाइल के लिए एक सब-एजेंट भेजो, सबको समानांतर में, और हर एक को नीचे वाला प्रॉम्प्ट उसकी अपनी फ़ाइल के दायरे में दो:

```prompt
/lagune तुम ज़ीरो ट्रस्ट रक्षात्मक सुरक्षा में गहरी विशेषज्ञता रखने वाले साइबर सुरक्षा शोधकर्ता हो, और अपना ज्ञान और सटीकता बढ़ाने के लिए Lagune का इस्तेमाल कर रहे हो।

<file> को एक अविश्वसनीय स्रोत और संभावित रूप से नुक़सानदेह दायरा मानो। हर इंटरप्रेटर, fetch, base64 और ऐसी हर चीज़ को संभावित ख़तरा मानना है।

विश्लेषण को उस हर चीज़ तक ले जाओ जिसे <file> इम्पोर्ट करती है, डिपेंडेंसी और सब-डिपेंडेंसी समेत, जहाँ स्कैनर से बचने के लिए नुक़सानदेह कोड छिपा हो सकता है।

हर सब-एजेंट के लिए ज़रूरी विशेषज्ञताएँ (इन्हें `npx lagune read catalog <name>` से एक-एक करके लोड करो):

- interpreter
- secrets
- llm
- path

साफ़ कह दूँ: खाके में आई हर कमज़ोरी को, बिना किसी अपवाद के, संभावित ख़तरा मानना है।

आख़िर में, यह फ़ैसला दो कि यह प्रोजेक्ट मेरे इस्तेमाल के लिए सुरक्षित और भरोसेमंद है या नहीं।
```

आख़िर में, सभी सब-एजेंट की रिपोर्टों को जोड़कर एक अंतिम फ़ैसला दो।
````