AI कोडिंग एजेंट सीक्रेट लीक: स्कैनिंग बनाम कंटेनमेंट
AI कोडिंग एजेंट की 'Don't ask again' allowlist से सीक्रेट लीक: सीक्रेट स्कैनिंग बनाम कंटेनमेंट की तुलना और वे गार्डरेल जो commit हुए credentials को रोकें।

सुरक्षा शोधकर्ताओं ने अभी पाया है कि एक हज़ार से ज़्यादा सार्वजनिक GitHub फ़ाइलों में पासवर्ड, API टोकन और क्लाउड credentials पड़े हैं, और ये किसी लापरवाह .env फ़ाइल में नहीं, बल्कि AI कोडिंग एजेंट की settings में हैं। इसकी जड़ में AI कोडिंग एजेंट सीक्रेट लीक का एक चुपचाप चलने वाला पैटर्न है: डेवलपर curl -H "Authorization: Bearer sk-..." जैसी कमांड को approve करता है, “Don't ask again” पर क्लिक करता है, और पूरी कमांड, टोकन समेत, एक लोकल settings फ़ाइल में लिख दी जाती है। वह फ़ाइल commit कर दो, तो सीक्रेट सार्वजनिक हो जाता है। मैं सालों से इन्फ्रास्ट्रक्चर सिक्योरिटी का काम कर रहा हूँ, और यह मुझे सबसे आसानी से टाले जा सकने वाले लीक वर्गों में से एक लगता है। यह नया भी है, क्योंकि जो फ़ाइल यह लीक करती है, वह दो साल पहले तक थी ही नहीं।
दो बचाव हैं जिन पर टीमें आम तौर पर भरोसा करती हैं: सीक्रेट स्कैनिंग (लीक पकड़ो, फिर साफ़ करो) और कंटेनमेंट (यह सुनिश्चित करो कि सीक्रेट कभी एजेंट या repo तक पहुँचे ही नहीं)। दोनों ज़रूरी हैं, पर अकेले कोई भी काफ़ी नहीं। यह लेख दोनों की आमने-सामने तुलना करता है, कब कौन जीतता है और कहाँ कौन फ़ेल होता है, और अंत में बताता है कि Claude Code, Cursor या किसी भी permission allowlist वाले एजेंट पर मैं टीम में असल में क्या लगाऊँगा।
पहले एक बात साफ़ कर दूँ: यह agentic coding tools के ख़िलाफ़ कोई तर्क नहीं है। मैं इन्हें रोज़ इस्तेमाल करता हूँ और अब वापस नहीं जाऊँगा। Permission prompt, यानी जब एजेंट पूछता है “क्या मैं यह चला सकता हूँ?”, इन टूल्स के सबसे अच्छे सेफ़्टी मैकेनिज़्म में से एक है। समस्या ठीक उस “हाँ” के बाद की है: वह “हाँ” कहाँ दर्ज होती है, और उसमें क्या रहता है।
Allowlist कैसे सीक्रेट स्टोर बन जाती है
इस failure mode को समझने के लिए देखना होगा कि “Don't ask again” असल में क्या सहेजता है। जब एजेंटिक CLI कोई कमांड चलाने की अनुमति माँगता है, तो सीधा-सादा implementation पूरी कमांड स्ट्रिंग को permission rule में सहेज लेता है। कोई pattern नहीं, कोई hash नहीं। वही शाब्दिक स्ट्रिंग जो आपने approve की।
जब डेवलपर aws s3 cp s3://bucket/backup.sql . --profile prod approve करता है, तो वह नुक़सानदेह नहीं है। पर जब वह psql postgresql://admin:hunter2@db.internal/myapp या curl -u deploy:APIKEY123 https://.../deploy approve करता है, तो credentials .claude/settings.local.json या उसके समकक्ष config में पड़े रह जाते हैं। यह settings फ़ाइल लोकल रहने के लिए बनी है, Claude Code तो टूल खुद फ़ाइल बनाए तो उसे अपने-आप gitignore भी कर देता है। लेकिन अगर डेवलपर ने फ़ाइल हाथ से बनाई, या उसे force-add किया, या उसका global gitignore उसे कवर नहीं करता, तो एक git add . और एक push के बाद वह GitHub पर है। ठीक यही चेन उन 1,122 फ़ाइलों के पीछे है जो शोधकर्ताओं को मिलीं।
ध्यान दीजिए कि इस चेन की कितनी कड़ियाँ अलग-अलग तौर पर तर्कसंगत हैं। Inline credential वाली कमांड approve करना डेवलपर दशकों से interactively करते आए हैं, बिना किसी नतीजे के: कमांड चलती है, shell history लोकल रहती है, किसी को फ़र्क नहीं पड़ता। “Don't ask again” पर क्लिक करना तर्कसंगत है; prompt की थकान असली है, और इन एजेंट्स की पूरी ख़ासियत ही कम interruption है। यहाँ तक कि git add . भी बचाव योग्य है, जब टूल ने आपको बताया हो कि फ़ाइल लोकल है। घटना किसी एक लापरवाह क़दम से नहीं होती। यह ऐसी व्यवस्था से होती है जहाँ पाँच हानिरहित काम मिलकर एक सार्वजनिक credential बन जाते हैं। ऐसी सिक्योरिटी फ़ेल्योर सबसे मुश्किल से ठीक होती हैं, क्योंकि कोई भी व्यक्ति खुद को कुछ ग़लत करते नहीं देखता।
एजेंट बनने से पहले भी मैंने यही ग़लती असल दुनिया में देखी है। एक फ़िनटेक में, जिसके साथ मैंने कंसल्टिंग की थी, एक CI हेल्पर बॉट के लिए allowed_commands.sh था, यानी वही विचार, हाथ से बना हुआ। किसी ने एक बार की database migration कमांड को DSN समेत inline approve कर दिया। छह महीने बाद repo open-source हो गया, और DSN उस फ़ाइल की git history में था जिसे किसी ने ऑडिट करने की ज़रूरत नहीं समझी, क्योंकि “वो config नहीं है।” फ़ाइल config ही थी। बस उसकी शक्ल config जैसी नहीं थी।
असली बात यही है: permission allowlists ऐसी configuration फ़ाइलें हैं जो बाई-प्रोडक्ट के रूप में operational secrets पकड़ लेती हैं। कोई उन्हें सीक्रेट के लिए रिव्यू नहीं करता, क्योंकि कोई उन्हें सीक्रेट रखने वाली फ़ाइल मानता ही नहीं। आपकी secret management policy .env, credentials.yml, शायद Terraform state को कवर करती है। .claude/settings.local.json या .cursor/ configs को लगभग निश्चित रूप से नहीं। इससे मिलते-जुलते एक blind spot पर हमने API clients को credential vaults के रूप में ऑडिट करने पर लिखा था: जिन टूल्स को आप रोज़ इस्तेमाल करते हैं, वे ऐसी जगहों पर सीक्रेट्स जमा करते हैं जिनका आपकी policy नाम तक नहीं लेती।
और यह श्रेणी बढ़ रही है। पिछले कुछ सालों में लॉन्च हुआ हर agentic टूल किसी न किसी रूप में यही करता है: allowlists, trusted directories, याद रखी गई approvals, inline tokens वाली MCP server configs। हर एक एक नई फ़ाइल path है, जिसे आपकी मौजूदा policies, gitignores और scanner configs में कोई नहीं गिनता। इस घटना का अगला संस्करण वही ग़लती होगी, बस किसी दूसरे नाम वाली फ़ाइल में।
Secret Scanning बनाम Containment: दो बचाव
यह वो तुलना है जिसे मैं बाक़ी लेख में चलाऊँगा:
- Detection-first (secret scanning): pre-commit hooks, gitleaks और trufflehog जैसे repo scanners, GitHub या GitLab की push-protection, और समय-समय पर history scans। मान लीजिए सीक्रेट लीक होंगे; उन्हें जल्दी पकड़ो और rotate करो।
- Containment-first (सीक्रेट बाहर रखो): सीक्रेट्स केवल environment variables, password manager CLIs, या short-lived credentials के ज़रिए कमांड तक पहुँचें; एजेंट sandboxes या ephemeral VMs में चलें; लोकल settings फ़ाइलें global रूप से gitignore हों। ऐसा डिज़ाइन करो कि लीक करने को कुछ बचे ही नहीं।
Detection एक cleanup operation है, जबकि containment एक design property है। दोनों उल्टी दिशा में फ़ेल होते हैं: scanning में false negatives होते हैं और वह हमेशा घटना के बाद चलता है; containment की adoption की कीमत है और वह developer friction से लड़ता है। कौन जीतता है, यह इस पर निर्भर करता है कि आप कौन-सी failure mode झेल सकते हैं।
इनके समय के साथ बिगड़ने का तरीक़ा भी अलग है। Scanning सुंदरता से degrade होता है: जो सीक्रेट छूट गया वह बुरा है, पर जो पकड़ा गया वह पकड़ा ही जाता है, और rulesets बेहतर होते जाते हैं। Containment exceptions से degrade होता है। हर बार जब डेवलपर friction से बचने का रास्ता निकालता है, “बस इस बार, टोकन सीधे चिपका देता हूँ”, तो property कमज़ोर होती है, और उस कमज़ोरी का कोई log नहीं बनता। पता तब चलता है जब कोई जाँचता है, ठीक वैसे ही जैसे किसी खुले लॉक का पता तब चलता है जब कोई देखे। इसलिए दोनों प्रतिद्वंद्वी नहीं, साथी हैं, पर मैं उन्हें अलग तौल देता हूँ। नीचे का हिस्सा बताता है कि क्यों scanning, उद्योग का डिफ़ॉल्ट जवाब होने के बावजूद, इस विशेष लीक वर्ग के लिए दोनों में कमज़ोर है।
Secret Scanning: ताक़तें और कठोर सीमाएँ
Scanning तब जीतता है जब लीक हो चुका हो या होने वाला हो, और इंसानी स्वभाव को देखते हुए ऐसा अक्सर होता है। GitHub की push protection push के समय ज्ञात token formats को ब्लॉक करती है। pre-commit hook में gitleaks लैपटॉप से बाहर जाने से पहले ही काफ़ी कुछ पकड़ लेता है। अगर इस लेख से आप सिर्फ़ एक चीज़ करें, तो यह करें:
# .pre-commit-config.yaml
repos:
- repo: https://github.com/gitleaks/gitleaks
rev: v8.18.4
hooks:
- id: gitleaks
दस मिनट का setup, और इस कहानी वाला लीक वर्ग (committed settings फ़ाइल में टोकन) लगभग ख़त्म हो जाता है, क्योंकि gitleaks को इस बात की परवाह नहीं कि फ़ाइल JSON settings फ़ाइल है। वह filenames नहीं, content स्कैन करता है। अगर आपके पास अपने internal token prefixes हैं, तो उनके लिए regex जोड़ दीजिए।
एक और scanning layer है जिसे टीमें अक्सर भूल जाती हैं: अपनी लोकल मशीन को समय-समय पर uncommitted सीक्रेट्स के लिए स्कैन करना। Repo-level hooks सिर्फ़ commit या push के समय चलते हैं। जो settings फ़ाइल कोई git add . चलाने से पहले तीन महीने डिस्क पर पड़ी रहती है, वह तीन महीने की खिड़की है जिसमें सीक्रेट एक कमांड दूर है सार्वजनिक होने से। एक scheduled job, यहाँ तक कि एक साप्ताहिक cron जो आपकी home directory की dotfiles पर gitleaks चलाए, इस खिड़की को दिनों तक सीमित कर देता है। यह भद्दा है, पर काम करता है।
पर scanning की तीन कठोर सीमाएँ हैं, जिन्हें Claude Code वाली कहानी बख़ूबी उजागर करती है। पहली, entropy-based detectors कम-entropy वाले सीक्रेट्स चूक जाते हैं। psql connection string में Winter2024! जैसा पासवर्ड entropy check को नहीं छूता, और अगर वह किसी ज्ञात provider format का नहीं है, तो कोई rule मेल नहीं खाता। शोधकर्ताओं को सिर्फ़ AWS-शैली की keys नहीं, बल्कि बहुत सारे सादे पासवर्ड मिले। दूसरी, scanning push layer पर post-hoc होता है। Push protection push को रोक देती है, जो बढ़िया है, पर अगर वह न चले, तो सीक्रेट history में है, और history हमेशा के लिए है। लीक के बाद rotate करने का मतलब है हर उस जगह को ढूँढना जहाँ credential इस्तेमाल हुआ था, और मैंने यह cleanup एक दिन से कम में होते कभी नहीं देखा। तीसरी, scanning एक झूठा पूर्णता का एहसास देता है। टीमें हरा checkmark देखती हैं और सोचना बंद कर देती हैं कि सीक्रेट्स बहते कैसे हैं। जैसा हमने AI security scanners पर अपने लेख में कहा था, scanner एक safety net है, गिरने से न बचने का विकल्प नहीं।
दूसरे बिंदु पर, यह समझना ज़रूरी है कि जब credential सचमुच सार्वजनिक repo तक पहुँच जाए तो “cleanup” में क्या शामिल है, क्योंकि टीमें इसे लगातार कम आँकती हैं। Rotation आसान हिस्सा है: टोकन revoke करो, नया जारी करो, secrets store अपडेट करो। कठिन हिस्सा है पुरातत्व। हर deploy pipeline, cron job, डेवलपर का लैपटॉप और third-party integration जो पुराना credential इस्तेमाल करता था, उसे ढूँढकर अपडेट करना होगा, और एक भी छूटने का मतलब सबसे बुरे समय पर outage है। फिर एक उल्टी समस्या भी है: अगर repo सार्वजनिक है, तो मानकर चलो कि सीक्रेट मिनटों में स्क्रैप हो गया। Credential-harvesting bots GitHub event stream को लगातार देखते हैं। जब तक आपका scanner अलर्ट करता है, सीक्रेट शायद क्लोन, इंडेक्स और आपके production endpoints पर आज़माया जा चुका होगा। Detection ने आपको जागरूकता दी। उसने आपको सुरक्षा नहीं दी।
फिर भी मैं scanning के साथ निष्पक्ष होना चाहता हूँ, क्योंकि इन बहसों में उसे बहुत आसानी से ख़ारिज कर दिया जाता है। सैकड़ों repos और हज़ारों डेवलपर्स वाले बड़े संगठनों के लिए, scanning वह अकेली परत है जो व्यवहार बदले बिना scale होती है। इतने बड़े पैमाने पर आप प्रशिक्षण से लीक से बाहर नहीं निकल सकते, पर push-protection से उसका ज़्यादातर हिस्सा ज़रूर रोक सकते हैं। अगर आप platform team हैं और अपने पहले हफ़्ते की मेहनत कहाँ लगानी है यह तय कर रहे हैं, तो जवाब scanning है: यह सस्ता है, centralized है, और उन high-entropy provider tokens को पकड़ता है जो सबसे ज़्यादा नुक़सान करते हैं। बस इसे पूरा समाधान मत समझ बैठिए।

Containment: Env Vars, Sandboxes और Short-Lived Credentials
Containment वहाँ जीतता है जहाँ सीक्रेट वरना लिखा जा चुका होता, और यही इस घटना का असल ठिकाना है। अगर credential कभी कमांड में शाब्दिक स्ट्रिंग के रूप में नहीं आता, तो allowlist के पास संग्रह करने को कुछ ख़तरनाक बचता ही नहीं। Approve हुई कमांड बन जाती है curl -H "Authorization: Bearer $DEPLOY_TOKEN" ..., और settings फ़ाइल में एक हानिरहित variable नाम रहता है। ज़्यादातर मामले दो नियमों से कवर हो जाते हैं:
- सीक्रेट्स कमांड में केवल environment variables या indirection (
$TOKEN,$(op read ...), या एक config फ़ाइल जिसे एजेंट runtime पर पढ़ता है) के ज़रिए आएँ, कभी शाब्दिक मान के रूप में नहीं। - Agent-local config directories (
.claude/,.cursor/,.aider*) को आपके मशीन-व्यापी global gitignore (~/.config/git/ignore) में डालें, सिर्फ़ per-repo नहीं, ताकि कोई project उन्हें कभी commit न कर सके।
# Global gitignore covers every repo on this machine
git config --global core.excludesFile ~/.config/git/ignore
cat >> ~/.config/git/ignore <<'EOF'
.claude/
.cursor/
.aider*
.env*
EOF
Global क्यों, per-repo क्यों नहीं? दो कारण। पहला, per-repo gitignores तभी होते हैं जब कोई हर नए repository में उन्हें जोड़ना याद रखे, और नए repositories ठीक तब बनते हैं जब किसी को security hygiene की याद नहीं होती। दूसरा, global gitignore मशीन की policy है, project की नहीं। इसे किसी pull request में “gitignore साफ़ करने” के बहाने ग़लती से नहीं हटाया जा सकता, जो मैंने सचमुच होते देखा है। Per-repo version एक repo की रक्षा करता है। Global version एक डेवलपर की रक्षा करता है, और यहाँ लीक होने की सबसे ज़्यादा संभावना वाली इकाई डेवलपर ही है।
Env-var नियम पर भी उतनी ही बारीकी से नज़र डालनी चाहिए, क्योंकि इसमें एक सूक्ष्म failure mode है: shell profiles। अगर डेवलपर env-var की ज़रूरत को .bashrc में DEPLOY_TOKEN=sk-... export करके “हल” करता है, तो आपने सीक्रेट को एक अनरिव्यू की गई dotfile से दूसरी में खिसका दिया है। नियम को किसी असली secrets backend पर ख़त्म होना चाहिए: 1Password CLI, किसी encrypted store से पढ़ने वाला direnv, या session शुरू होते समय aws ssm या op inject वाला cloud secrets manager। एजेंट को variable मिलता है; डिस्क को मान कभी नहीं मिलता। यह एक अतिरिक्त indirection है, और यही containment और दिखावे के बीच का फ़र्क है।
Containment का मज़बूत रूप है असली sandboxing: हर task के लिए एजेंट को एक ephemeral VM या container में, isolated network पर चलाओ, और बाहरी APIs के सामने एक proxy रखो। एक setup, जिसकी मैं तारीफ़ करता हूँ, एजेंट और एक god-mode SaaS key के बीच API proxy रखता है: reads गुज़र जाते हैं, writes के लिए फ़ोन पर tap चाहिए। यही defense in depth है, सही तरीक़े से। यहाँ तक कि पूरी तरह compromised एजेंट भी, --dangerously-skip-permissions के साथ भी, सिर्फ़ वही छू सकता है जो proxy अनुमति दे। व्यापक trade-off पर हमने AI एजेंट्स के लिए containment बनाम monitoring पर लिखा था; यह कहानी containment के पक्ष में एक तर्क है।
Short-lived credentials मज़बूत रूप का दूसरा हिस्सा हैं, और इन्हें कम आँका जाता है, क्योंकि ये हर दूसरी परत फ़ेल होने पर भी blast radius छोटा कर देते हैं। GitHub पर लीक हुई एक static AWS access key तब तक valid रहती है जब तक कोई उसे देख न ले। GitHub पर लीक हुई, एक घंटे के TTL वाली OIDC-issued credential बस एक log entry है। अगर आपका cloud provider workload identity federation सपोर्ट करता है, और सभी बड़े provider करते हैं, तो एजेंट के credentials इतनी जल्दी expire होने चाहिए कि आपकी incident response प्रक्रिया को मीटिंग बुलाने का भी मौक़ा न मिले।
Containment की ईमानदार कीमत है friction। Password manager CLIs का मतलब है काम के बीच fingerprint prompts। Ephemeral VMs का मतलब है हर run पर setup time और cold-start latency। Scoped proxies का मतलब है कि कोई उन्हें बनाए और चलाए। एक अकेले डेवलपर के side project के लिए full sandboxing overkill है, और global-gitignore-plus-env-vars वाला version सही फ़ैसला है। जिस टीम के एजेंट production credentials छूते हैं, उसके लिए यह friction अगला breach disclosure न बनने की कीमत है।
बीच की परत: Allowlist को ही ठीक करना
एक तीसरा विकल्प है जिसका मालिक आप नहीं, टूल vendor है: शाब्दिक कमांड को सहेजो मत। एक permission rule जो curl -H "Authorization: Bearer *" को pattern के रूप में सहेजे, argument values को redact करके, मिलान के लिए उतना ही उपयोगी है और उसमें कोई सीक्रेट नहीं रहता। Claude Code की टीम ने कहा है कि वे ठीक इसी वर्ग को रोकने पर विचार कर रहे हैं, और उनकी सुझाई दिशा एक auto permission mode है जिसमें allow/deny lists बनाए रखने की ज़रूरत ही नहीं। यह सही सहज बोध है। हर हाथ से चलाई जाने वाली allowlist एक भविष्य की घटना है, जिसका timestamp अभी आपको दिख नहीं रहा।
Pattern-matching कोई मुफ़्त का लंच नहीं है, साफ़ कहूँ तो। curl * जैसा glob सामान्य deploy कमांड और ख़तरनाक exfiltration कमांड, दोनों से बराबर मेल खाता है, तो आक्रामक redaction लीक के जोखिम को approval-breadth के जोखिम से बदल देता है। सही डिज़ाइन शायद टेक्स्ट के बजाय संरचनात्मक होगा: यह सहेजो कि कौन-सी binary और कौन-से flags approve हुए, कभी argument values नहीं। इससे मिलान सटीक रहता है (headers वाले curl को हाँ, किसी नए domain पर pipe करने वाले curl को ना), और कोई ऐसी चीज़ नहीं सहेजी जाती जिसमें credential छुप सके। Vendors वहाँ पहुँचेंगे; प्रोत्साहन अब एक हज़ार से ज़्यादा सार्वजनिक फ़ाइलों के सबूत के रूप में मौजूद है।
जब तक vendors यह नहीं भेजते, आप hygiene से इसका अनुमान लगा सकते हैं: अपनी लोकल settings फ़ाइलों पर ही समय-समय पर scanner चलाएँ। gitleaks detect --no-git --source ~/.claude .claude जैसी एक लाइन ठीक उन्हीं फ़ाइलों का ऑडिट करती है जिनके बारे में यह कहानी है, किसी repo के पास पहुँचने से पहले। इसे अपनी dotfiles setup script में जोड़ दें, तो इसकी कोई लागत नहीं।
मेरी सिफ़ारिश: डिफ़ॉल्ट रूप से Containment, और Scanning जाल के रूप में
अगर एक चुनना पड़े, तो containment चुनिए। जो लीक कभी होता ही नहीं, वह जल्दी पकड़े गए लीक से हर बार बेहतर है। Scanning वह है जिस पर आप तब भरोसा करते हैं जब containment फ़ेल हो जाए, और वह फ़ेल होगा, क्योंकि कोई रात 1 बजे चैट में connection string चिपका देगा। पर उसे अपवाद-हैंडलर होना चाहिए, नीति नहीं।
ठोस रूप से, इस तिमाही में agentic coding tools लागू करने वाली टीम के लिए, प्रयास के क्रम में:
- हर डेवलपर की मशीन पर agent config directories के लिए global gitignore: पाँच मिनट, और committed-settings वाला लीक पूरी तरह ख़त्म।
- नियम: सीक्रेट्स केवल env vars या password manager CLI के ज़रिए, कभी कमांड में inline नहीं। इसे onboarding में डालें, किसी wiki में नहीं जिसे कोई पढ़ता नहीं।
- pre-commit hook के रूप में gitleaks, और forge पर push protection: ऊपर की हर चीज़ के लिए safety net।
- एजेंट जो कुछ भी छूता है उसके लिए short-lived, scoped credentials (static keys के बजाय OIDC-issued cloud creds), ताकि लीक घंटों में expire हो जाए।
- Production access वाले एजेंट्स के लिए: ephemeral sandbox और एक API proxy जो तय करे कि एजेंट के credentials क्या कर सकते हैं।
क्रम पर ध्यान दीजिए। सबसे सस्ते दो आइटम containment के हैं, और वे पूरी घटना-श्रेणी को ख़त्म कर देते हैं, सिर्फ़ उसकी संभावना नहीं घटाते। Scanning वाले आइटम तीसरे नंबर पर आते हैं, पहले नहीं। इसलिए नहीं कि वे कम ज़रूरी हैं, बल्कि इसलिए कि वे trapeze के नीचे का जाल हैं, और जाल तभी बाँधा जाता है जब रस्सियाँ जाँच ली गई हों। चौथा और पाँचवाँ आइटम वहाँ से शुरू होते हैं जहाँ आप दुर्घटनाओं के बजाय compromise से बचाव करने लगते हैं, और agentic tools चाहे हम योजना बनाएँ या नहीं, उसी ओर जा रहे हैं।

सिर्फ़ पहले दो आइटम ही शोधकर्ताओं के डेटासेट की लगभग हर फ़ाइल को रोक देते। इस घटना का निराशाजनक हिस्सा यही है: यह कोई परिष्कृत हमला नहीं है। यह एक नए फ़ाइल प्रकार में एक पुरानी ग़लती है, और समाधान वही hygiene है जिसका हम पहली committed .env फ़ाइल के बाद से प्रचार कर रहे हैं, बस उस directory पर लागू करके जिसका किसी की policy में अभी ज़िक्र नहीं।
Policy अपडेट कीजिए। एजेंट कहीं जा नहीं रहे, और “Don't ask again” बटन भी नहीं।


