मीटिंग एजेंडा टाइमबॉक्सर स्किल

--- name: meeting-agenda-timeboxer description: किसी मीटिंग के विषयों की एक साधारण सूची को प्रारंभ और समाप्ति समय, मालिकों, और प्रत्येक आइटम के लिए एक स्पष्ट परिणाम (inform, discuss, decide, brainstorm, review) के साथ एक समयबद्ध एजेंडा में बदलता है, यह जांचता है कि यह बफर के साथ स्लॉट में फिट बैठता है या नहीं, एजेंडा की कमियों जैसे देर से या जल्दबाजी में लिए गए निर्णय, बहुत सारे स्टेटस अपडेट, बड़े आइटम, और छूटे हुए ब्रेक को चिह्नित करता है, और भेजने के लिए तैयार एजेंडा और प्री-रीड लिखता है। उपयोग करें जब उपयोगकर्ता पूछे "help me plan this meeting", "will this agenda fit in an hour?", "make this agenda tighter", या टीम मीटिंग, वर्कशॉप, ऑफसाइट, या रिव्यू के लिए विषयों की एक सूची साझा करे। --- # Meeting Agenda Timeboxer आप लोगों को ऐसी मीटिंग चलाने में मदद करते हैं जो समय पर समाप्त होती हैं और निर्णय लेती हैं। आप विषयों की एक सूची को एक यथार्थवादी कार्यक्रम में बदलते हैं, हर आइटम को एक मालिक और एक उद्देश्य देते हैं, स्टेटस अपडेट को कमरे से बाहर निकालते हैं, और समय का गणित दिखाते हैं ताकि कोई भी मिनट 55 पर यह न पाए कि मुख्य निर्णय के लिए समय नहीं बचा है। ## इस स्किल में फाइलें - `scripts/timebox_agenda.py` - हर आइटम को शेड्यूल करता है, स्लॉट और बफर के खिलाफ फिट की जांच करता है, एजेंडा की कमियों को चिह्नित करता है, और आइटम को 5-मिनट के चरणों में स्लॉट में फिट कर सकता है (केवल Python 3 मानक लाइब्रेरी) - `references/timeboxing-principles.md` - चीजों में वास्तव में कितना समय लगता है, आइटम परिणाम, क्रम, बफर, और ब्रेक - `references/facilitation-moves.md` - प्रत्येक प्रकार के आइटम को उसके टाइमबॉक्स के भीतर रखने की तकनीकें, और जब कोई ओवररन हो जाए तो क्या करें - `templates/agenda.md` - एजेंडा इनपुट प्रारूप और भेजने के लिए एजेंडा - `examples/example-roadmap-meeting.md` - एक ओवरलोडेड एक घंटे की प्लानिंग मीटिंग का काम किया हुआ फिक्स ## वर्कफ़्लो ### 1. तथ्य एकत्र करें पूछें, या मान लें और कह दें: - मीटिंग का उद्देश्य एक वाक्य में: जब यह समाप्त हो तो क्या सत्य होना चाहिए? - प्रारंभ समय और अवधि (या समाप्ति समय), उपस्थित लोगों की संख्या, व्यक्तिगत या रिमोट। - विषय, प्रत्येक एक मालिक के साथ और समूह को उसके साथ क्या करना है: inform, update, discuss, brainstorm, review, या decide। - कठिन बाधाएं: जो लोग देर से जुड़ते हैं या जल्दी निकलते हैं, निश्चित ब्रेक। ### 2. ड्राफ्ट एजेंडा लिखें `templates/agenda.md` में इनपुट प्रारूप का उपयोग करें (प्रति पंक्ति एक आइटम: `minutes | topic | owner | outcome`)। ऐसी अवधि के लिए `?` का उपयोग करें जो अभी तक कोई नहीं जानता। `references/timeboxing-principles.md` के साथ अवधि का अनुमान लगाएं। ### 3. टाइमबॉक्सर चलाएं ```bash python3 scripts/timebox_agenda.py agenda.txt python3 scripts/timebox_agenda.py agenda.txt --fit # स्लॉट में 5-मिनट के चरणों में स्केल करें python3 scripts/timebox_agenda.py agenda.json --json ``` यह घड़ी के समय, बफर, और निष्कर्षों के साथ शेड्यूल प्रिंट करता है: HIGH जब एजेंडा फिट नहीं होता है, WARN कमियों के लिए, INFO अनियोजित समय और व्यक्ति-घंटों में मीटिंग की लागत के लिए। `--fit` पहले स्टेटस आइटम को ट्रिम करता है, फिर बाकी सब कुछ स्केल करता है; यह आइटम को फिर से क्रमबद्ध नहीं करता है, इसलिए बाद में स्वयं क्रम की जांच करें। यदि आप स्क्रिप्ट नहीं चला सकते हैं, तो घड़ी का गणित हाथ से, आइटम दर आइटम करें, और ऐसा कहें। ### 4. एजेंडा ठीक करें, सिर्फ संख्याएं नहीं निष्कर्षों पर इस क्रम में काम करें: 1. स्टेटस अपडेट और घोषणाओं को हटाएं या छोटा करें: उन्हें एक लिखित प्री-रीड में स्थानांतरित करें। 2. निर्णयों को पहले (पहले भाग में) रखें, और प्रत्येक को कम से कम 10 मिनट और पहले से भेजा गया एक लिखित प्रस्ताव दें। 3. हर आइटम को एक मालिक और एक परिणाम दें; "AOB" को हटा दें या इसे 5 मिनट की पार्किंग लॉट समीक्षा में बदल दें। 4. 45 मिनट से अधिक के आइटम को विभाजित करें; हर 60 से 90 मिनट में एक ब्रेक जोड़ें। 5. यदि यह अभी भी फिट नहीं होता है, तो सुझाव दें कि क्या काटना है या किसी अन्य मीटिंग या async में स्थानांतरित करना है, और बताएं कि क्या खो जाएगा। स्क्रिप्ट को तब तक फिर से चलाएं जब तक कोई HIGH निष्कर्ष न हो और हर WARN या तो ठीक न हो या समझाया न गया हो। ### 5. डिलीवर करें `templates/agenda.md` से भेजने के लिए एजेंडा भरें: उद्देश्य, वांछित परिणाम, समयबद्ध कार्यक्रम, मालिकों और समय सीमा के साथ प्री-रीड, और पार्किंग लॉट नियम। `references/facilitation-moves.md` से प्रति जोखिम भरे आइटम एक या दो सुविधा युक्तियाँ जोड़ें। `examples/example-roadmap-meeting.md` की शैली का पालन करें। ## नियम - किसी निर्णय को उसकी आवश्यकता से कम करके गणित को कभी काम न करें; कुछ और काटें या स्थानांतरित करें, या लंबे स्लॉट की सिफारिश करें। - बफर रखें: प्रति घंटे लगभग 5 मिनट, वर्कशॉप के लिए 10 प्रतिशत। - स्पष्ट रूप से कहें जब मीटिंग नहीं होनी चाहिए (कोई निर्णय नहीं, चर्चा के लिए कुछ नहीं) और async विकल्प सुझाएं। - उपयोगकर्ता की संस्कृति और बाधाओं का सम्मान करें; सुझाव दें, व्याख्यान न दें। - समय मीटिंग के लिए स्थानीय हैं; अन्य समय क्षेत्रों में रिमोट प्रतिभागियों के लिए, इसका उल्लेख करें लेकिन जब तक न पूछा जाए परिवर्तित न करें। ## टाइमबॉक्सिंग सिद्धांत ### हर आइटम को एक परिणाम चाहिए | परिणाम | समूह क्या करता है | सामान्य समय | नोट्स | |---|---|---|---| | inform | कुछ सुनें, एक स्पष्ट प्रश्न पूछें | 2 से 5 मिनट | लिखित प्री-रीड के रूप में बेहतर। | | update | लोगों या टीमों से स्थिति | 1 से 2 मिनट प्रति व्यक्ति | आमतौर पर async; केवल ब्लॉकर्स को लाइव रखें। | | discuss | किसी विषय का अन्वेषण करें, विचार साझा करें, अभी कोई निर्णय नहीं | 10 से 20 मिनट | बताएं कि चर्चा किसे खिलाती है (अगले सप्ताह एक निर्णय, एक दस्तावेज़)। | | brainstorm | विकल्प उत्पन्न करें | 15 से 30 मिनट | एक रूपरेखा प्रश्न और एक विधि चाहिए (पहले मौन लेखन)। | | review | ड्राफ्ट, डिज़ाइन, या योजना पर प्रतिक्रिया दें | 15 से 40 मिनट | सामग्री पहले से भेजें; सहमत हों कि किस प्रकार की प्रतिक्रिया चाहिए। | | decide | विकल्पों के बीच चुनें और प्रतिबद्ध हों | 10 से 30 मिनट | एक लिखित प्रस्ताव, विकल्प, निर्णयकर्ता, और निर्णय नियम चाहिए। | | break | आराम | 5 से 15 मिनट | हर 60 से 90 मिनट में। | यदि किसी आइटम का कोई स्पष्ट परिणाम नहीं है, तो पूछें: "इस आइटम के बाद क्या अलग होगा?" यदि उत्तर "कुछ नहीं" है, तो इसे काट दें। ### चीजों में वास्तव में कितना समय लगता है - परिचय: नए समूह के लिए प्रति व्यक्ति लगभग 1 मिनट, नियमित टीम के लिए 0। - किसी विषय पर प्रत्येक व्यक्ति एक बार बोलना: प्रति व्यक्ति लगभग 1.5 से 2 मिनट। आठ लोग, एक राउंड, 15 मिनट है। - स्क्रीन साझा करना और शुरू करना: 2 से 3 मिनट, नए टूल के साथ रिमोट मीटिंग के लिए अधिक। - वास्तविक असहमति वाला निर्णय: अनुमान दोगुना करें, या इसे अभी "discuss" और अगली बार "decide" में विभाजित करें। - एजेंडा में देर से आने वाले आइटम तेजी से लेकिन बदतर चलते हैं: लोग जल्दी करते हैं या निकल जाते हैं। ### क्रम 1. एक छोटी फ्रेमिंग से शुरू करें: उद्देश्य और वांछित परिणाम (2 से 5 मिनट)। 2. निर्णय और सबसे कठिन विषय पहले भाग में, जब ऊर्जा और उपस्थिति अधिक हो। 3. बीच में चर्चा और समीक्षा। 4. जानकारी और अपडेट अंत में या मीटिंग से पूरी तरह बाहर। 5. अगले चरणों, मालिकों, और तिथियों के साथ समाप्त करें (5 मिनट), कभी भी AOB के साथ नहीं। उन आइटमों को समूहित करें जिन्हें समान लोगों की आवश्यकता है, ताकि अन्य जल्दी निकल सकें। ### बफर और ब्रेक - बफर: प्रति घंटे लगभग 5 मिनट, वर्कशॉप के लिए 10 प्रतिशत। बफर स्लॉट का हिस्सा है, अतिरिक्त समय नहीं। - ब्रेक: हर 60 से 90 मिनट में 5 से 10 मिनट; लंबी वर्कशॉप के लिए 15। रिमोट मीटिंग को जल्दी ब्रेक की आवश्यकता होती है। - बैक-टू-बैक कैलेंडर: 5 मिनट पहले समाप्त करें (25 या 50 मिनट की मीटिंग)। ### फिट जांच - प्रति घंटे लगभग 8 से अधिक आइटम का मतलब है कि प्रत्येक को 7 मिनट से कम मिलता है; विलय या कटौती करें। - स्टेटस और घोषणाएं समय के लगभग एक तिहाई से अधिक: उन्हें प्री-रीड में स्थानांतरित करें। - 45 मिनट से अधिक का आइटम: इसे अपने स्वयं के परिणामों के साथ चरणों में विभाजित करें (उदाहरण के लिए "brainstorm 25" फिर "cluster and pick 20")। ### मीटिंग की लागत व्यक्ति-घंटे = उपस्थित लोग x घंटों में अवधि। 9 लोगों के साथ एक घंटे की मीटिंग में 9 कार्य घंटे लगते हैं। पूछें कि क्या सभी को हर आइटम के लिए वहां रहने की आवश्यकता है। ## सुविधा चालें जो टाइमबॉक्स रखती हैं ### मीटिंग से पहले - एजेंडा और प्री-रीड 24 से 48 घंटे पहले भेजें, प्रत्येक आइटम के मालिक के साथ। - प्रत्येक निर्णय आइटम के लिए, एक पेज का प्रस्ताव भेजें: प्रश्न, विकल्प, सिफारिश, और कौन निर्णय लेता है। - लोगों से प्री-रीड में प्रश्न लिखित रूप में जोड़ने के लिए कहें, ताकि मीटिंग प्रस्तुति से नहीं, प्रश्नों से शुरू हो। ### शुरुआत में - उद्देश्य और उन परिणामों को बताएं जिनकी आपको अंत तक आवश्यकता है। - एक टाइमकीपर नामित करें और सिग्नल पर सहमत हों (चैट में एक संदेश, 2 मिनट शेष रहने पर उठा हुआ हाथ)। - बताएं कि आज निर्णय कैसे लिए जाते हैं: मालिक इनपुट के बाद निर्णय लेता है, बहुमत वोट, या सहमति ("कोई मजबूत आपत्ति?")। ### आइटम प्रकार से - inform: "दो मिनट, फिर प्रत्येक एक स्पष्ट प्रश्न।" विस्तृत प्रश्न पार्किंग लॉट या अनुवर्ती चैट में जाते हैं। - update: केवल ब्लॉकर्स और अनुरोध लाइव; बाकी सब प्री-रीड में है। - discuss: पहले प्रश्न को फ्रेम करें ("विकल्प B के बारे में हमें क्या चिंता है?")। एक त्वरित राउंड का उपयोग करें ताकि कोई भी दो बार बोलने से पहले सभी एक बार बोलें। - brainstorm: पहले 3 से 5 मिनट मौन लेखन, फिर साझा करें, फिर क्लस्टर करें। निर्णय से पहले मात्रा। - review: प्रतिक्रिया के प्रकार पर सहमत हों: अवरोधक मुद्दे, प्रश्न, या पॉलिश। पहले अवरोधक मुद्दे एकत्र करें। - decide: प्रस्ताव को फिर से बताएं, चिंताओं को सूचीबद्ध करें, आपत्तियों की जांच करें, फिर निर्णय लें और इसे जोर से कहें: "हमने X तय किया; मालिक Y; तिथि Z तक।" ### जब कोई आइटम ओवररन हो जाता है चुपचाप अगले आइटम को खाने के बजाय विकल्प को दृश्यमान बनाएं: 1. "हमारे पास इस पर 2 मिनट बचे हैं। क्या हम 5 मिनट बढ़ाते हैं और कुछ और काटते हैं, या इसे पार्क करते हैं?" 2. इसे पार्क करें: इसे एक मालिक और एक तिथि के साथ पार्किंग लॉट में लिखें। 3. अगले आइटम को छोटा करें, निर्णय आइटम को कभी नहीं। 4. यदि मीटिंग का लक्ष्य जोखिम में है, तो केवल आवश्यक लोगों के साथ एक छोटा अनुवर्ती शेड्यूल करें। ### रिमोट और हाइब्रिड - हर कोई अपने डिवाइस पर शामिल होता है ताकि रिमोट लोग समान हों। - बोलने की कतार और त्वरित पोल के लिए चैट का उपयोग करें। - वर्तमान आइटम को हाइलाइट करके एजेंडा को स्क्रीन पर साझा करें। ### अंत में - निर्णय, मालिकों, और तिथियों को वापस पढ़ें (5 मिनट)। - पार्किंग लॉट की समीक्षा करें: प्रत्येक आइटम को असाइन करें या छोड़ दें। - 24 घंटे के भीतर नोट्स भेजें। ## एजेंडा इनपुट (scripts/timebox_agenda.py के लिए) ``` Meeting: <name> Start: <HH:MM> Length: <minutes> # या End: <HH:MM> Buffer: <minutes या percent, जैसे 5 या 10%> Attendees: <number> <minutes> | <topic> | <owner> | <inform | update | discuss | brainstorm | review | decide | break> ? | <topic with unknown duration> | <owner> | <outcome> ``` कॉलम Min, Topic, Owner, Outcome के साथ एक Markdown तालिका भी काम करती है, और JSON भी: `{"meeting": "...", "start": "14:00", "length": 60, "buffer": 5, "attendees": 6, "items": [{"minutes": 10, "topic": "...", "owner": "...", "outcome": "decide"}]}` --- # भेजने के लिए एजेंडा **<मीटिंग का नाम>** <दिन, तारीख>, <प्रारंभ>-<समाप्ति> (<अवधि> मिनट), <स्थान या वीडियो लिंक> उपस्थित: <नाम या टीमें> | सुविधाकर्ता: <नाम> | टाइमकीपर: <नाम> | नोट्स: <नाम> **उद्देश्य:** <एक वाक्य: जब हम समाप्त करें तो क्या सत्य होना चाहिए> **परिणाम जो हमें चाहिए** 1. <निर्णय या परिणाम> 2. <निर्णय या परिणाम> **प्री-रीड (<दिन, समय> तक)** - <दस्तावेज़> - <मालिक> - <क्या देखना है, पढ़ने में कितना समय लगता है> **कार्यक्रम** | समय | मिनट | आइटम | मालिक | परिणाम | |---|---|---|---|---| | <HH:MM-HH:MM> | <n> | <विषय> | <मालिक> | <परिणाम> | | <HH:MM-HH:MM> | <n> | बफर और रैप-अप: निर्णय, मालिक, तिथियां | <सुविधाकर्ता> | | **आज हम कैसे निर्णय लेते हैं:** <मालिक इनपुट के बाद निर्णय लेता है | सहमति | वोट> **पार्किंग लॉट:** ऑफ-टॉपिक बिंदु पार्किंग लॉट में जाते हैं और अंत में एक मालिक प्राप्त करते हैं। **इस मीटिंग से बाहर स्थानांतरित** - <आइटम> -> <async अपडेट, अन्य मीटिंग, या एक दस्तावेज़>, मालिक <नाम> ## उदाहरण: एक ओवरलोडेड एक घंटे की प्लानिंग मीटिंग को ठीक करना ### अनुरोध "मेरे पास गुरुवार को 14:00 बजे 9 लोगों के साथ Q4 की योजना बनाने के लिए एक घंटा है। यह रहा मेरा एजेंडा। क्या यह फिट होगा? बजट विभाजन को इस मीटिंग में अनुमोदित किया जाना चाहिए, और शीर्ष 3 पहल भी।" ड्राफ्ट एजेंडा (`agenda.txt`): ``` Meeting: Q4 roadmap planning Start: 14:00 Length: 60 Buffer: 5 Attendees: 9 10 | Welcome and goals | Dana | inform 15 | Team status round (each team lead) | Leads | update 10 | Customer feedback highlights | Priya | inform 20 | Q4 priorities: pick top 3 initiatives | Lee | discuss 10 | Hiring plan for Q4 | | discuss 5 | Approve Q4 budget split | Dana | decide ? | AOB | | ``` ### पहला रन ``` $ python3 scripts/timebox_agenda.py agenda.txt Q4 roadmap planning: 14:00-15:00 (60 min, buffer 5 min, 55 min for items) Planned: 70 min 14:00-14:10 10 min Welcome and goals (Dana) [inform] 14:10-14:25 15 min Team status round (each team lead) (Leads) [update] 14:25-14:35 10 min Customer feedback highlights (Priya) [inform] 14:35-14:55 20 min Q4 priorities: pick top 3 initiatives (Lee) [discuss] 14:55-15:05 10 min Hiring plan for Q4 [discuss] 15:05-15:10 5 min Approve Q4 budget split (Dana) [decide] 15:10-15:10 ? min AOB [?] 14:55-15:00 5 min Buffer / wrap-up Findings: - [HIGH] Agenda needs 70 min but only 55 min are available after the 5-min buffer: overrun of 15 min (ends 15:10 instead of 14:55). Cut, shorten, or move items, or run with --fit. - [WARN] 1 item(s) without a duration: AOB. Remaining time for them: 0 min. - [WARN] "Hiring plan for Q4" has no owner; name who prepares and leads it. - [WARN] "Approve Q4 budget split" is a decision with only 5 min; plan at least 10, or decide by a written proposal beforehand. - [WARN] "Approve Q4 budget split" is a decision starting at 15:05, in the last quarter of the meeting; move it earlier while energy and attendance are high. - [WARN] "AOB" has no owner; name who prepares and leads it. - [WARN] "AOB" has no outcome; say whether it is to inform, discuss, decide, or brainstorm. - [WARN] Status updates and announcements take 50% of the time; send them as a pre-read and keep the meeting for discussion and decisions. - [INFO] Meeting cost: 9 people x 60 min = 9 person-hours. ``` एग्जिट कोड 1: एजेंडा फिट नहीं होता है। ### संख्याएं क्या कहती हैं - 55 मिनट की खिड़की में 70 मिनट के आइटम (प्लस AOB): AOB शुरू होने से पहले ही 15 मिनट अधिक। - आधा समय अपडेट और घोषणाओं का है, जबकि जिन दो चीजों पर निर्णय लिया जाना है उन्हें 5 मिनट (बजट) और एक "discuss" लेबल (प्राथमिकताएं) मिलता है, और बजट निर्णय 15:05 पर शुरू होगा, जब मीटिंग समाप्त हो जानी चाहिए थी। - अकेले `--fit` चलाने से सब कुछ 55 मिनट में समा जाएगा लेकिन बजट निर्णय अंतिम और 5 मिनट के साथ रह जाएगा। संख्याओं को फिट करना पर्याप्त नहीं है; क्रम और आइटम के उद्देश्य को बदलना होगा। ### परिवर्तन 1. टीम स्टेटस राउंड (15 मिनट) और ग्राहक प्रतिक्रिया हाइलाइट्स (10 मिनट) बुधवार 12:00 तक देय एक लिखित प्री-रीड बन जाते हैं; प्रश्न टिप्पणियों में जाते हैं। 2. बजट विभाजन 10 मिनट के साथ शुरुआत में चला जाता है और सोमवार को भेजा गया एक प्रस्ताव, ताकि मीटिंग केवल इसकी पुष्टि या समायोजन करे। 3. "Q4 priorities" 25 मिनट के साथ एक निर्णय बन जाता है: परिणाम एक रैंक किया गया शीर्ष 3 है। 4. हायरिंग प्लान को एक मालिक (Priya) और एक संकीर्ण प्रश्न मिलता है: कौन सी भूमिकाएं खोलनी हैं। 5. AOB को 5 मिनट के "next steps, owners, and parking lot" समापन से बदल दिया जाता है। 6. केवल स्टेटस राउंड के लिए आवश्यक तीन लोग मीटिंग छोड़ सकते हैं: 9 के बजाय 6 उपस्थित। संशोधित एजेंडा: ``` Meeting: Q4 roadmap planning Start: 14:00 Length: 60 Buffer: 5 Attendees: 6 5 | Welcome and goals for today | Dana | inform 10 | Approve Q4 budget split (proposal sent Monday) | Dana | decide 25 | Q4 priorities: pick top 3 initiatives | Lee | decide 10 | Hiring plan for Q4: agree which roles to open | Priya | discuss 5 | Next steps, owners, and parking lot | Dana | inform ``` ### दूसरा रन ``` $ python3 scripts/timebox_agenda.py agenda-revised.txt Q4 roadmap planning: 14:00-15:00 (60 min, buffer 5 min, 55 min for items) Planned: 55 min 14:00-14:05 5 min Welcome and goals for today (Dana) [inform] 14:05-14:15 10 min Approve Q4 budget split (proposal sent Monday) (Dana) [decide] 14:15-14:40 25 min Q4 priorities: pick top 3 initiatives (Lee) [decide] 14:40-14:50 10 min Hiring plan for Q4: agree which roles to open (Priya) [discuss] 14:50-14:55 5 min Next steps, owners, and parking lot (Dana) [inform] 14:55-15:00 5 min Buffer / wrap-up Findings: - [INFO] Meeting cost: 6 people x 60 min = 6 person-hours. ``` एग्जिट कोड 0, कोई चेतावनी नहीं, और मीटिंग की लागत 9 के बजाय 6 व्यक्ति-घंटे है। ### भेजने के लिए एजेंडा (भरा हुआ टेम्पलेट, छोटा किया गया) **Q4 roadmap planning** गुरुवार, 14:00-15:00 (60 मिनट), कमरा 3 और वीडियो लिंक सुविधाकर्ता: Dana | टाइमकीपर: Lee | नोट्स: Priya **उद्देश्य:** स्वीकृत Q4 बजट विभाजन और पहलों की एक रैंक किया गया शीर्ष 3 के साथ निकलें। **प्री-रीड (बुधवार 12:00 तक)** - टीम स्टेटस वन-पेजर्स - प्रत्येक टीम लीड - पढ़ने में 5 मिनट - ग्राहक प्रतिक्रिया हाइलाइट्स - Priya - 5 मिनट - बजट विभाजन प्रस्ताव - Dana - 10 मिनट **कार्यक्रम** | समय | मिनट | आइटम | मालिक | परिणाम | |---|---|---|---|---| | 14:00-14:05 | 5 | आज के लिए स्वागत और लक्ष्य | Dana | inform | | 14:05-14:15 | 10 | Q4 बजट विभाजन स्वीकृत करें (प्रस्ताव सोमवार को भेजा गया) | Dana | decide | | 14:15-14:40 | 25 | Q4 प्राथमिकताएं: शीर्ष 3 पहल चुनें | Lee | decide | | 14:40-14:50 | 10 | Q4 हायरिंग प्लान: कौन सी भूमिकाएं खोलनी हैं सहमत हों | Priya | discuss | | 14:50-14:55 | 5 | अगले चरण, मालिक, और पार्किंग लॉट | Dana | inform | | 14:55-15:00 | 5 | बफर | | | **आज हम कैसे निर्णय लेते हैं:** Dana इनपुट के बाद बजट तय करता है; शीर्ष 3 सहमति से चुना जाता है (कोई मजबूत आपत्ति?)। **सुविधा युक्तियाँ** - प्राथमिकताएं: उम्मीदवार सूची पर 3 मिनट का मौन डॉट वोटिंग, फिर केवल 2 से 5 रैंक वाले आइटम पर चर्चा करें। - यदि बजट आइटम 10 मिनट मारता है, तो प्राथमिकताओं में खाने के बजाय खुले बिंदु को एक मालिक और 24 घंटे की समय सीमा के साथ पार्क करें। **इस मीटिंग से बाहर स्थानांतरित:** टीम स्टेटस राउंड और ग्राहक प्रतिक्रिया (प्री-रीड)। ### यह एक अच्छा उत्तर क्यों है - यह उद्देश्य और क्रम को ठीक करता है, सिर्फ मिनटों को नहीं। - दोनों आवश्यक निर्णय अब पहले 40 मिनट में, तैयार प्रस्तावों के साथ होते हैं। - स्क्रिप्ट फिट की पुष्टि करती है, और जो लोग केवल अपडेट के लिए थे उन्हें उनका घंटा वापस मिल जाता है। ## Python स्क्रिप्ट: timebox_agenda.py ```python #!/usr/bin/env python3 """Timebox a meeting agenda: schedule every item, check the fit, and flag agenda smells. Usage: python3 timebox_agenda.py agenda.txt python3 timebox_agenda.py agenda.txt --fit # scale items to fit the slot (5-minute steps) python3 timebox_agenda.py agenda.json --json cat agenda.txt | python3 timebox_agenda.py - Text input: optional "Key: value" header lines, then one item per line as minutes | topic | owner | outcome Markdown table rows (| 10 | Topic | Owner | decide |) also work; header and separator rows are skipped. Use ? for an unknown duration. Header keys: Meeting, Start (HH:MM), Length (minutes) or End (HH:MM), Buffer (minutes or percent, e.g. 5 or 10%), Attendees (number). Outcomes: inform, update, discuss, brainstorm, review, decide, break. JSON input: {"meeting": "...", "start": "14:00", "length": 60, "buffer": 5, "attendees": 8, "items": [{"minutes": 10, "topic": "...", "owner": "...", "outcome": "decide"}]} --fit trims status items (and items with no outcome) first, then scales everything; spare time goes to decide and discuss items. Checks: overrun (HIGH), missing durations, owners, or outcomes, late or rushed decisions, oversized items, long stretches without a break, too many status updates, too many items per hour, plus the meeting's cost in person-hours. Exit code: 0 no HIGH findings, 1 HIGH found, 2 usage or input error. Standard library only. """ import argparse import json import math import re import sys OUTCOMES = {"inform", "update", "discuss", "brainstorm", "review", "decide", "break"} ALIASES = {"decision": "decide", "info": "inform", "fyi": "inform", "status": "update", "updates": "update", "discussion": "discuss", "ideas": "brainstorm", "ideation": "brainstorm", "feedback": "review", "approve": "decide", "approval": "decide", "pause": "break", "coffee": "break"} class InputError(Exception): pass def hhmm(text): m = re.fullmatch(r"\s*(\d{1,2})[:.](\d{2})\s*", str(text)) if not m or int(m.group(1)) > 23 or int(m.group(2)) > 59: raise InputError(f"time must be HH:MM, got {text!r}") return int(m.group(1)) * 60 + int(m.group(2)) def fmt(minutes): minutes = int(round(minutes)) % (24 * 60) return f"{minutes // 60:02d}:{minutes % 60:02d}" def parse_minutes(text): t = str(text).strip().lower() if t in ("", "?", "tbd", "-"): return None m = re.fullmatch(r"(\d+(?:\.\d+)?)\s*(m|min|mins|minutes?)?", t) if m: return float(m.group(1)) m = re.fullmatch(r"(\d+(?:\.\d+)?)\s*h(?:ours?)?(?:\s*(\d+)\s*m(?:in)?)?", t) if m: return float(m.group(1)) * 60 + float(m.group(2) or 0) raise InputError(f"cannot read duration {text!r}") def norm_outcome(text): t = (text or "").strip().lower() return ALIASES.get(t, t) def parse_text(text): meta, items, errors = {}, [], [] for no, raw in enumerate(text.replace("\r\n", "\n").split("\n"), 1): line = raw.strip() if not line or line.startswith("#"): continue hm = re.fullmatch(r"([A-Za-z ]{3,20}):\s*(.+)", line) if hm and "|" not in line: meta[hm.group(1).strip().lower()] = hm.group(2).strip() continue if "|" not in line: errors.append(f"line {no}: expected 'minutes | topic | owner | outcome', got {line[:60]!r}") continue cells = [c.strip() for c in line.strip("|").split("|")] if all(re.fullmatch(r":?-{2,}:?", c) for c in cells if c): continue if cells and cells[0].lower() in ("min", "mins", "minutes", "time", "duration"): continue cells += [""] * (4 - len(cells)) try: minutes = parse_minutes(cells[0]) except InputError as e: errors.append(f"line {no}: {e}") continue if not cells[1]: errors.append(f"line {no}: item has no topic") continue items.append({"line": no, "minutes": minutes, "topic": cells[1], "owner": cells[2], "outcome": norm_outcome(cells[3])}) return meta, items, errors def parse_json(text): data = json.loads(text) if not isinstance(data, dict) or not isinstance(data.get("items"), list): raise InputError("JSON input needs an object with an 'items' list") meta = {k.lower(): str(v) for k, v in data.items() if k != "items" and v is not None} items, errors = [], [] for i, it in enumerate(data["items"], 1): try: minutes = parse_minutes(it.get("minutes", "")) except InputError as e: errors.append(f"item {i}: {e}") continue if not str(it.get("topic", "")).strip(): errors.append(f"item {i}: item has no topic") continue items.append({"line": i, "minutes": minutes, "topic": str(it["topic"]).strip(), "owner": str(it.get("owner", "") or "").strip(), "outcome": norm_outcome(it.get("outcome", ""))}) return meta, items, errors def settings(meta): start = hhmm(meta.get("start", "09:00")) if "length" in meta: length = parse_minutes(meta["length"]) if not length or length <= 0: raise InputError("Length must be a positive number of minutes") elif "end" in meta: length = (hhmm(meta["end"]) - start) % (24 * 60) if length == 0: raise InputError("End must be after Start") else: raise InputError("header needs 'Length: <minutes>' or 'End: HH:MM'") b = meta.get("buffer", "0").strip() if b.endswith("%"): buffer = 5 * round(length * float(b[:-1]) / 100 / 5) # percent buffers round to 5 minutes else: buffer = parse_minutes(b) or 0 if buffer >= length: raise InputError("Buffer must be shorter than the meeting") attendees = int(meta["attendees"]) if str(meta.get("attendees", "")).strip().isdigit() else None return {"meeting": meta.get("meeting", meta.get("title", "Meeting")), "start": start, "length": length, "buffer": buffer, "available": length - buffer, "attendees": attendees} def fit(items, available): """Fit items into `available` minutes in 5-minute steps (missing durations count as 10, breaks kept). When the agenda is too long, status items (inform, update, or no outcome) are trimmed first, down to half their planned time; then every item is scaled proportionally. When it is too short, the spare time goes to decide and discuss items first. """ fixed = sum(it["minutes"] or 0 for it in items if it["outcome"] == "break") flex = [it for it in items if it["outcome"] != "break"] room = available - fixed if not flex or room < 5 * len(flex): raise InputError(f"cannot fit {len(flex)} items into {room:g} minutes with at least 5 minutes each") want = [max(5, 5 * round((it["minutes"] or 10) / 5)) for it in flex] cur = list(want) status = [i for i, it in enumerate(flex) if it["outcome"] in ("inform", "update", "")] while sum(cur) > room: cands = [i for i in status if cur[i] - 5 >= max(5, want[i] / 2)] if not cands: break cur[max(cands, key=lambda k: cur[k])] -= 5 if sum(cur) > room: scale = room / sum(cur) ref = [c * scale for c in cur] cur = [max(5, 5 * round(r / 5)) for r in ref] while sum(cur) > room: cands = [k for k in range(len(cur)) if cur[k] > 5] cur[max(cands, key=lambda k: (cur[k] - ref[k], cur[k]))] -= 5 while sum(cur) + 5 <= room: cur[min(range(len(cur)), key=lambda k: cur[k] - ref[k])] += 5 else: prio = [i for i, it in enumerate(flex) if it["outcome"] in ("decide", "discuss")] or list(range(len(flex))) while sum(cur) + 5 <= room: cur[min(prio, key=lambda k: cur[k] / want[k])] += 5 out, it_new = [], iter(cur) for it in items: copy = dict(it) copy["original"] = it["minutes"] if it["outcome"] != "break": copy["minutes"] = float(next(it_new)) out.append(copy) return out def analyze(items, cfg): findings = [] def add(sev, msg): findings.append({"severity": sev, "message": msg}) t = cfg["start"] for it in items: it["start"] = t t += it["minutes"] or 0 it["end"] = t planned = sum(it["minutes"] or 0 for it in items) avail, end_slot = cfg["available"], cfg["start"] + cfg["length"] unknown = [it for it in items if it["minutes"] is None] if planned > avail: add("HIGH", f"Agenda needs {planned:g} min but only {avail:g} min are available" f"{' after the ' + format(cfg['buffer'], 'g') + '-min buffer' if cfg['buffer'] else ''}: overrun of {planned - avail:g} min" f" (ends {fmt(cfg['start'] + planned)} instead of {fmt(end_slot - cfg['buffer'])}). Cut, shorten, or move items, or run with --fit.") elif avail - planned > 0.15 * avail and not unknown: add("INFO", f"{avail - planned:g} min unplanned; end early or give the main decision more time.") if unknown: add("WARN", f"{len(unknown)} item(s) without a duration: " + "; ".join(it["topic"][:40] for it in unknown) + f". Remaining time for them: {max(avail - planned, 0):g} min.") for it in items: name = f"\"{it['topic'][:50]}\"" if it["outcome"] != "break" and not it["owner"]: add("WARN", f"{name} has no owner; name who prepares and leads it.") if not it["outcome"]: add("WARN", f"{name} has no outcome; say whether it is to inform, discuss, decide, or brainstorm.") elif it["outcome"] not in OUTCOMES: add("WARN", f"{name} has unknown outcome '{it['outcome']}' (use: {', '.join(sorted(OUTCOMES))}).") m = it["minutes"] or 0 if it["outcome"] == "decide": if it["minutes"] is not None and m < 10: add("WARN", f"{name} is a decision with only {m:g} min; plan at least 10, or decide by a written proposal beforehand.") if it["start"] - cfg["start"] >= 0.75 * cfg["length"]: add("WARN", f"{name} is a decision starting at {fmt(it['start'])}, in the last quarter of the meeting; move it earlier while energy and attendance are high.") if it["outcome"] in ("discuss", "brainstorm", "review") and it["minutes"] is not None and m < 5: add("WARN", f"{name} is a {it['outcome']} item with {m:g} min; that is a mention, not a {it['outcome']}.") if m > 45 and it["outcome"] != "break": add("WARN", f"{name} is {m:g} min long; split it into parts with their own outcomes.") stretch, stretch_start = 0, cfg["start"] for it in items: if it["outcome"] == "break": stretch, stretch_start = 0, it["end"] continue stretch += it["minutes"] or 0 if stretch > 90: add("WARN", f"{stretch:g} min without a break from {fmt(stretch_start)}; add a 5 to 10 min break about every 60 to 90 min.") stretch = -10**9 status = sum(it["minutes"] or 0 for it in items if it["outcome"] in ("inform", "update")) if planned and status / planned > 0.35: add("WARN", f"Status updates and announcements take {round(100 * status / planned)}% of the time; send them as a pre-read and keep the meeting for discussion and decisions.") work_items = [it for it in items if it["outcome"] != "break"] hours = cfg["length"] / 60 if hours and len(work_items) / hours > 8: add("WARN", f"{len(work_items)} items in {cfg['length']:g} min is more than 8 per hour; merge or drop items.") if not any(it["outcome"] == "decide" for it in items): add("INFO", "No decision items; check that this meeting needs to be live.") cost = None if cfg["attendees"]: cost = round(cfg["attendees"] * cfg["length"] / 60, 1) add("INFO", f"Meeting cost: {cfg['attendees']} people x {cfg['length']:g} min = {cost:g} person-hours.") order = {"HIGH": 0, "WARN": 1, "INFO": 2} findings.sort(key=lambda f: order[f["severity"]]) return {"meeting": cfg["meeting"], "start": fmt(cfg["start"]), "end": fmt(end_slot), "length": cfg["length"], "buffer": cfg["buffer"], "available": avail, "planned": planned, "person_hours": cost, "items": [{k: (fmt(v) if k in ("start", "end") else v) for k, v in it.items()} for it in items], "findings": findings} def main(): ap = argparse.ArgumentParser(description="Timebox a meeting agenda") ap.add_argument("path", help="agenda text/Markdown/JSON file, or - for stdin") ap.add_argument("--fit", action="store_true", help="scale item durations to fit the available time") ap.add_argument("--json", action="store_true") args = ap.parse_args() try: text = sys.stdin.read() if args.path == "-" else open(args.path, encoding="utf-8").read() if not text.strip(): raise InputError("input is empty") meta, items, errors = parse_json(text) if text.lstrip().startswith("{") else parse_text(text) if errors: raise InputError("could not read the agenda:\n " + "\n ".join(errors)) if not items: raise InputError("no agenda items found (expected lines like '10 | Topic | Owner | decide')") cfg = settings(meta) before = sum(it["minutes"] or 0 for it in items) n_unknown = sum(1 for it in items if it["minutes"] is None) if args.fit: items = fit(items, cfg["available"]) except FileNotFoundError: print(f"error: file not found: {args.path}", file=sys.stderr) return 2 except (InputError, json.JSONDecodeError, ValueError) as e: print(f"error: {e}", file=sys.stderr) return 2 rep = analyze(items, cfg) rep["fitted_from"] = before if args.fit else None if args.json: print(json.dumps(rep, indent=2)) else: print(f"{rep['meeting']}: {rep['start']}-{rep['end']} ({rep['length']:g} min, buffer {rep['buffer']:g} min, {rep['available']:g} min for items)") if args.fit: extra = f" plus {n_unknown} without a duration (counted as 10 min each)" if n_unknown else "" print(f"Fitted: {before:g} min of items{extra} fitted into {rep['planned']:g} min (5-minute steps, breaks kept).") print(f"Planned: {rep['planned']:g} min\n") for it in rep["items"]: mins = "?" if it["minutes"] is None else f"{it['minutes']:g}" was = f" (was {it['original']:g})" if args.fit and it.get("original") not in (None, it["minutes"]) else "" who = f" ({it['owner']})" if it["owner"] else "" print(f" {it['start']}-{it['end']} {mins:>3} min{was:<10} {it['topic']}{who} [{it['outcome'] or '?'}]") if rep["buffer"]: print(f" {fmt(hhmm(rep['end']) - rep['buffer'])}-{rep['end']} {rep['buffer']:>3g} min Buffer / wrap-up") print() if rep["findings"]: print("Findings:") for f in rep["findings"]: print(f"- [{f['severity']}] {f['message']}") else: print("Findings: none") return 1 if any(f["severity"] == "HIGH" for f in rep["findings"]) else 0 if __name__ == "__main__": sys.exit(main()) ```