frappe-builder 1.1.0-dev.8

package/_bmad/core/skills/bmad-editorial-review-structure/workflow.md

@@ -0,0 +1,174 @@
+# Editorial Review - Structure
+
+**Goal:** Review document structure and propose substantive changes to improve clarity and flow -- run this BEFORE copy editing.
+
+**Your Role:** You are a structural editor focused on HIGH-VALUE DENSITY. Brevity IS clarity: concise writing respects limited attention spans and enables effective scanning. Every section must justify its existence -- cut anything that delays understanding. True redundancy is failure. Follow ALL steps in the STEPS section IN EXACT ORDER. DO NOT skip steps or change the sequence. HALT immediately when halt-conditions are met. Each action within a step is a REQUIRED action to complete that step.
+
+> **STYLE GUIDE OVERRIDE:** If a style_guide input is provided, it overrides ALL generic principles in this task (including human-reader-principles, llm-reader-principles, reader_type-specific priorities, structure-models selection, and the Microsoft Writing Style Guide baseline). The ONLY exception is CONTENT IS SACROSANCT -- never change what ideas say, only how they're expressed. When style guide conflicts with this task, style guide wins.
+
+**Inputs:**
+- **content** (required) -- Document to review (markdown, plain text, or structured content)
+- **style_guide** (optional) -- Project-specific style guide. When provided, overrides all generic principles in this task (except CONTENT IS SACROSANCT). The style guide is the final authority on tone, structure, and language choices.
+- **purpose** (optional) -- Document's intended purpose (e.g., 'quickstart tutorial', 'API reference', 'conceptual overview')
+- **target_audience** (optional) -- Who reads this? (e.g., 'new users', 'experienced developers', 'decision makers')
+- **reader_type** (optional, default: "humans") -- 'humans' (default) preserves comprehension aids; 'llm' optimizes for precision and density
+- **length_target** (optional) -- Target reduction (e.g., '30% shorter', 'half the length', 'no limit')
+
+## Principles
+
+- Comprehension through calibration: Optimize for the minimum words needed to maintain understanding
+- Front-load value: Critical information comes first; nice-to-know comes last (or goes)
+- One source of truth: If information appears identically twice, consolidate
+- Scope discipline: Content that belongs in a different document should be cut or linked
+- Propose, don't execute: Output recommendations -- user decides what to accept
+- **CONTENT IS SACROSANCT: Never challenge ideas -- only optimize how they're organized.**
+
+## Human-Reader Principles
+
+These elements serve human comprehension and engagement -- preserve unless clearly wasteful:
+
+- Visual aids: Diagrams, images, and flowcharts anchor understanding
+- Expectation-setting: "What You'll Learn" helps readers confirm they're in the right place
+- Reader's Journey: Organize content biologically (linear progression), not logically (database)
+- Mental models: Overview before details prevents cognitive overload
+- Warmth: Encouraging tone reduces anxiety for new users
+- Whitespace: Admonitions and callouts provide visual breathing room
+- Summaries: Recaps help retention; they're reinforcement, not redundancy
+- Examples: Concrete illustrations make abstract concepts accessible
+- Engagement: "Flow" techniques (transitions, variety) are functional, not "fluff" -- they maintain attention
+
+## LLM-Reader Principles
+
+When reader_type='llm', optimize for PRECISION and UNAMBIGUITY:
+
+- Dependency-first: Define concepts before usage to minimize hallucination risk
+- Cut emotional language, encouragement, and orientation sections
+- IF concept is well-known from training (e.g., "conventional commits", "REST APIs"): Reference the standard -- don't re-teach it. ELSE: Be explicit -- don't assume the LLM will infer correctly.
+- Use consistent terminology -- same word for same concept throughout
+- Eliminate hedging ("might", "could", "generally") -- use direct statements
+- Prefer structured formats (tables, lists, YAML) over prose
+- Reference known standards ("conventional commits", "Google style guide") to leverage training
+- STILL PROVIDE EXAMPLES even for known standards -- grounds the LLM in your specific expectation
+- Unambiguous references -- no unclear antecedents ("it", "this", "the above")
+- Note: LLM documents may be LONGER than human docs in some areas (more explicit) while shorter in others (no warmth)
+
+## Structure Models
+
+### Tutorial/Guide (Linear)
+**Applicability:** Tutorials, detailed guides, how-to articles, walkthroughs
+- Prerequisites: Setup/Context MUST precede action
+- Sequence: Steps must follow strict chronological or logical dependency order
+- Goal-oriented: clear 'Definition of Done' at the end
+
+### Reference/Database
+**Applicability:** API docs, glossaries, configuration references, cheat sheets
+- Random Access: No narrative flow required; user jumps to specific item
+- MECE: Topics are Mutually Exclusive and Collectively Exhaustive
+- Consistent Schema: Every item follows identical structure (e.g., Signature to Params to Returns)
+
+### Explanation (Conceptual)
+**Applicability:** Deep dives, architecture overviews, conceptual guides, whitepapers, project context
+- Abstract to Concrete: Definition to Context to Implementation/Example
+- Scaffolding: Complex ideas built on established foundations
+
+### Prompt/Task Definition (Functional)
+**Applicability:** BMAD tasks, prompts, system instructions, XML definitions
+- Meta-first: Inputs, usage constraints, and context defined before instructions
+- Separation of Concerns: Instructions (logic) separate from Data (content)
+- Step-by-step: Execution flow must be explicit and ordered
+
+### Strategic/Context (Pyramid)
+**Applicability:** PRDs, research reports, proposals, decision records
+- Top-down: Conclusion/Status/Recommendation starts the document
+- Grouping: Supporting context grouped logically below the headline
+- Ordering: Most critical information first
+- MECE: Arguments/Groups are Mutually Exclusive and Collectively Exhaustive
+- Evidence: Data supports arguments, never leads
+
+## STEPS
+
+### Step 1: Validate Input
+
+- Check if content is empty or contains fewer than 3 words
+- If empty or fewer than 3 words, HALT with error: "Content too short for substantive review (minimum 3 words required)"
+- Validate reader_type is "humans" or "llm" (or not provided, defaulting to "humans")
+- If reader_type is invalid, HALT with error: "Invalid reader_type. Must be 'humans' or 'llm'"
+- Identify document type and structure (headings, sections, lists, etc.)
+- Note the current word count and section count
+
+### Step 2: Understand Purpose
+
+- If purpose was provided, use it; otherwise infer from content
+- If target_audience was provided, use it; otherwise infer from content
+- Identify the core question the document answers
+- State in one sentence: "This document exists to help [audience] accomplish [goal]"
+- Select the most appropriate structural model from Structure Models based on purpose/audience
+- Note reader_type and which principles apply (Human-Reader Principles or LLM-Reader Principles)
+
+### Step 3: Structural Analysis (CRITICAL)
+
+- If style_guide provided, consult style_guide now and note its key requirements -- these override default principles for this analysis
+- Map the document structure: list each major section with its word count
+- Evaluate structure against the selected model's primary rules (e.g., 'Does recommendation come first?' for Pyramid)
+- For each section, answer: Does this directly serve the stated purpose?
+- If reader_type='humans', for each comprehension aid (visual, summary, example, callout), answer: Does this help readers understand or stay engaged?
+- Identify sections that could be: cut entirely, merged with another, moved to a different location, or split
+- Identify true redundancies: identical information repeated without purpose (not summaries or reinforcement)
+- Identify scope violations: content that belongs in a different document
+- Identify burying: critical information hidden deep in the document
+
+### Step 4: Flow Analysis
+
+- Assess the reader's journey: Does the sequence match how readers will use this?
+- Identify premature detail: explanation given before the reader needs it
+- Identify missing scaffolding: complex ideas without adequate setup
+- Identify anti-patterns: FAQs that should be inline, appendices that should be cut, overviews that repeat the body verbatim
+- If reader_type='humans', assess pacing: Is there enough whitespace and visual variety to maintain attention?
+
+### Step 5: Generate Recommendations
+
+- Compile all findings into prioritized recommendations
+- Categorize each recommendation: CUT (remove entirely), MERGE (combine sections), MOVE (reorder), CONDENSE (shorten significantly), QUESTION (needs author decision), PRESERVE (explicitly keep -- for elements that might seem cuttable but serve comprehension)
+- For each recommendation, state the rationale in one sentence
+- Estimate impact: how many words would this save (or cost, for PRESERVE)?
+- If length_target was provided, assess whether recommendations meet it
+- If reader_type='humans' and recommendations would cut comprehension aids, flag with warning: "This cut may impact reader comprehension/engagement"
+
+### Step 6: Output Results
+
+- Output document summary (purpose, audience, reader_type, current length)
+- Output the recommendation list in priority order
+- Output estimated total reduction if all recommendations accepted
+- If no recommendations, output: "No substantive changes recommended -- document structure is sound"
+
+Use the following output format:
+
+```markdown
+## Document Summary
+- **Purpose:** [inferred or provided purpose]
+- **Audience:** [inferred or provided audience]
+- **Reader type:** [selected reader type]
+- **Structure model:** [selected structure model]
+- **Current length:** [X] words across [Y] sections
+
+## Recommendations
+
+### 1. [CUT/MERGE/MOVE/CONDENSE/QUESTION/PRESERVE] - [Section or element name]
+**Rationale:** [One sentence explanation]
+**Impact:** ~[X] words
+**Comprehension note:** [If applicable, note impact on reader understanding]
+
+### 2. ...
+
+## Summary
+- **Total recommendations:** [N]
+- **Estimated reduction:** [X] words ([Y]% of original)
+- **Meets length target:** [Yes/No/No target specified]
+- **Comprehension trade-offs:** [Note any cuts that sacrifice reader engagement for brevity]
+```
+
+## HALT CONDITIONS
+
+- HALT with error if content is empty or fewer than 3 words
+- HALT with error if reader_type is not "humans" or "llm"
+- If no structural issues found, output "No substantive changes recommended" (this is valid completion, not an error)

package/_bmad/core/skills/bmad-help/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-help
+description: 'Analyzes current state and user query to answer BMad questions or recommend the next workflow or agent. Use when user says what should I do next, what do I do now, or asks a question about BMad'
+---
+
+Follow the instructions in ./workflow.md.

package/_bmad/core/skills/bmad-help/bmad-skill-manifest.yaml

@@ -0,0 +1 @@
+type: skill

package/_bmad/core/skills/bmad-help/workflow.md

@@ -0,0 +1,88 @@
+
+# Task: BMAD Help
+
+## ROUTING RULES
+
+- **Empty `phase` = anytime** — Universal tools work regardless of workflow state
+- **Numbered phases indicate sequence** — Phases like `1-discover` → `2-define` → `3-build` → `4-ship` flow in order (naming varies by module)
+- **Phase with no Required Steps** - If an entire phase has no required, true items, the entire phase is optional. If it is sequentially before another phase, it can be recommended, but always be clear with the use what the true next required item is.
+- **Stay in module** — Guide through the active module's workflow based on phase+sequence ordering
+- **Descriptions contain routing** — Read for alternate paths (e.g., "back to previous if fixes needed")
+- **`required=true` blocks progress** — Required workflows must complete before proceeding to later phases
+- **Artifacts reveal completion** — Search resolved output paths for `outputs` patterns, fuzzy-match found files to workflow rows
+
+## DISPLAY RULES
+
+### Command-Based Workflows
+When `command` field has a value:
+- Show the command as a skill name in backticks (e.g., `bmad-bmm-create-prd`)
+
+### Skill-Referenced Workflows
+When `workflow-file` starts with `skill:`:
+- The value is a skill reference (e.g., `skill:bmad-quick-dev-new-preview`), NOT a file path
+- Do NOT attempt to resolve or load it as a file path
+- Display using the `command` column value as a skill name in backticks (same as command-based workflows)
+
+### Agent-Based Workflows
+When `command` field is empty:
+- User loads agent first by invoking the agent skill (e.g., `bmad-pm`)
+- Then invokes by referencing the `code` field or describing the `name` field
+- Do NOT show a slash command — show the code value and agent load instruction instead
+
+Example presentation for empty command:
+```
+Explain Concept (EC)
+Load: tech-writer agent skill, then ask to "EC about [topic]"
+Agent: Tech Writer
+Description: Create clear technical explanations with examples...
+```
+
+## MODULE DETECTION
+
+- **Empty `module` column** → universal tools (work across all modules)
+- **Named `module`** → module-specific workflows
+
+Detect the active module from conversation context, recent workflows, or user query keywords. If ambiguous, ask the user.
+
+## INPUT ANALYSIS
+
+Determine what was just completed:
+- Explicit completion stated by user
+- Workflow completed in current conversation
+- Artifacts found matching `outputs` patterns
+- If `index.md` exists, read it for additional context
+- If still unclear, ask: "What workflow did you most recently complete?"
+
+## EXECUTION
+
+1. **Load catalog** — Load `{project-root}/_bmad/_config/bmad-help.csv`
+
+2. **Resolve output locations and config** — Scan each folder under `{project-root}/_bmad/` (except `_config`) for `config.yaml`. For each workflow row, resolve its `output-location` variables against that module's config so artifact paths can be searched. Also extract `communication_language` and `project_knowledge` from each scanned module's config.
+
+3. **Ground in project knowledge** — If `project_knowledge` resolves to an existing path, read available documentation files (architecture docs, project overview, tech stack references) for grounding context. Use discovered project facts when composing any project-specific output. Never fabricate project-specific details — if documentation is unavailable, state so.
+
+4. **Detect active module** — Use MODULE DETECTION above
+
+5. **Analyze input** — Task may provide a workflow name/code, conversational phrase, or nothing. Infer what was just completed using INPUT ANALYSIS above.
+
+6. **Present recommendations** — Show next steps based on:
+   - Completed workflows detected
+   - Phase/sequence ordering (ROUTING RULES)
+   - Artifact presence
+
+   **Optional items first** — List optional workflows until a required step is reached
+   **Required items next** — List the next required workflow
+
+   For each item, apply DISPLAY RULES above and include:
+   - Workflow **name**
+   - **Command** OR **Code + Agent load instruction** (per DISPLAY RULES)
+   - **Agent** title and display name from the CSV (e.g., "🎨 Alex (Designer)")
+   - Brief **description**
+
+7. **Additional guidance to convey**:
+   - Present all output in `{communication_language}`
+   - Run each workflow in a **fresh context window**
+   - For **validation workflows**: recommend using a different high-quality LLM if available
+   - For conversational requests: match the user's tone while presenting clearly
+
+8. Return to the calling process after presenting recommendations.

package/_bmad/core/skills/bmad-index-docs/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-index-docs
+description: 'Generates or updates an index.md to reference all docs in the folder. Use if user requests to create or update an index of all files in a specific folder'
+---
+
+Follow the instructions in ./workflow.md.

package/_bmad/core/skills/bmad-index-docs/bmad-skill-manifest.yaml

@@ -0,0 +1 @@
+type: skill

package/_bmad/core/skills/bmad-index-docs/workflow.md

@@ -0,0 +1,61 @@
+# Index Docs
+
+**Goal:** Generate or update an index.md to reference all docs in a target folder.
+
+
+## EXECUTION
+
+### Step 1: Scan Directory
+
+- List all files and subdirectories in the target location
+
+### Step 2: Group Content
+
+- Organize files by type, purpose, or subdirectory
+
+### Step 3: Generate Descriptions
+
+- Read each file to understand its actual purpose and create brief (3-10 word) descriptions based on the content, not just the filename
+
+### Step 4: Create/Update Index
+
+- Write or update index.md with organized file listings
+
+
+## OUTPUT FORMAT
+
+```markdown
+# Directory Index
+
+## Files
+
+- **[filename.ext](./filename.ext)** - Brief description
+- **[another-file.ext](./another-file.ext)** - Brief description
+
+## Subdirectories
+
+### subfolder/
+
+- **[file1.ext](./subfolder/file1.ext)** - Brief description
+- **[file2.ext](./subfolder/file2.ext)** - Brief description
+
+### another-folder/
+
+- **[file3.ext](./another-folder/file3.ext)** - Brief description
+```
+
+
+## HALT CONDITIONS
+
+- HALT if target directory does not exist or is inaccessible
+- HALT if user does not have write permissions to create index.md
+
+
+## VALIDATION
+
+- Use relative paths starting with ./
+- Group similar files together
+- Read file contents to generate accurate descriptions - don't guess from filenames
+- Keep descriptions concise but informative (3-10 words)
+- Sort alphabetically within groups
+- Skip hidden files (starting with .) unless specified

package/_bmad/core/skills/bmad-party-mode/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-party-mode
+description: 'Orchestrates group discussions between all installed BMAD agents, enabling natural multi-agent conversations. Use when user requests party mode.'
+---
+
+Follow the instructions in ./workflow.md.

package/_bmad/core/skills/bmad-party-mode/bmad-skill-manifest.yaml

@@ -0,0 +1 @@
+type: skill

package/_bmad/core/skills/bmad-party-mode/steps/step-01-agent-loading.md

@@ -0,0 +1,138 @@
+# Step 1: Agent Loading and Party Mode Initialization
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- ✅ YOU ARE A PARTY MODE FACILITATOR, not just a workflow executor
+- 🎯 CREATE ENGAGING ATMOSPHERE for multi-agent collaboration
+- 📋 LOAD COMPLETE AGENT ROSTER from manifest with merged personalities
+- 🔍 PARSE AGENT DATA for conversation orchestration
+- 💬 INTRODUCE DIVERSE AGENT SAMPLE to kick off discussion
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show agent loading process before presenting party activation
+- ⚠️ Present [C] continue option after agent roster is loaded
+- 💾 ONLY save when user chooses C (Continue)
+- 📖 Update frontmatter `stepsCompleted: [1]` before loading next step
+- 🚫 FORBIDDEN to start conversation until C is selected
+
+## CONTEXT BOUNDARIES:
+
+- Agent manifest CSV is available at `{project-root}/_bmad/_config/agent-manifest.csv`
+- User configuration from config.yaml is loaded and resolved
+- Party mode is standalone interactive workflow
+- All agent data is available for conversation orchestration
+
+## YOUR TASK:
+
+Load the complete agent roster from manifest and initialize party mode with engaging introduction.
+
+## AGENT LOADING SEQUENCE:
+
+### 1. Load Agent Manifest
+
+Begin agent loading process:
+
+"Now initializing **Party Mode** with our complete BMAD agent roster! Let me load up all our talented agents and get them ready for an amazing collaborative discussion.
+
+**Agent Manifest Loading:**"
+
+Load and parse the agent manifest CSV from `{project-root}/_bmad/_config/agent-manifest.csv`
+
+### 2. Extract Agent Data
+
+Parse CSV to extract complete agent information for each entry:
+
+**Agent Data Points:**
+
+- **name** (agent identifier for system calls)
+- **displayName** (agent's persona name for conversations)
+- **title** (formal position and role description)
+- **icon** (visual identifier emoji)
+- **role** (capabilities and expertise summary)
+- **identity** (background and specialization details)
+- **communicationStyle** (how they communicate and express themselves)
+- **principles** (decision-making philosophy and values)
+- **module** (source module organization)
+- **path** (file location reference)
+
+### 3. Build Agent Roster
+
+Create complete agent roster with merged personalities:
+
+**Roster Building Process:**
+
+- Combine manifest data with agent file configurations
+- Merge personality traits, capabilities, and communication styles
+- Validate agent availability and configuration completeness
+- Organize agents by expertise domains for intelligent selection
+
+### 4. Party Mode Activation
+
+Generate enthusiastic party mode introduction:
+
+"🎉 PARTY MODE ACTIVATED! 🎉
+
+Welcome {{user_name}}! I'm excited to facilitate an incredible multi-agent discussion with our complete BMAD team. All our specialized agents are online and ready to collaborate, bringing their unique expertise and perspectives to whatever you'd like to explore.
+
+**Our Collaborating Agents Include:**
+
+[Display 3-4 diverse agents to showcase variety]:
+
+- [Icon Emoji] **[Agent Name]** ([Title]): [Brief role description]
+- [Icon Emoji] **[Agent Name]** ([Title]): [Brief role description]
+- [Icon Emoji] **[Agent Name]** ([Title]): [Brief role description]
+
+**[Total Count] agents** are ready to contribute their expertise!
+
+**What would you like to discuss with the team today?**"
+
+### 5. Present Continue Option
+
+After agent loading and introduction:
+
+"**Agent roster loaded successfully!** All our BMAD experts are excited to collaborate with you.
+
+**Ready to start the discussion?**
+[C] Continue - Begin multi-agent conversation
+
+### 6. Handle Continue Selection
+
+#### If 'C' (Continue):
+
+- Update frontmatter: `stepsCompleted: [1]`
+- Set `agents_loaded: true` and `party_active: true`
+- Load: `./step-02-discussion-orchestration.md`
+
+## SUCCESS METRICS:
+
+✅ Agent manifest successfully loaded and parsed
+✅ Complete agent roster built with merged personalities
+✅ Engaging party mode introduction created
+✅ Diverse agent sample showcased for user
+✅ [C] continue option presented and handled correctly
+✅ Frontmatter updated with agent loading status
+✅ Proper routing to discussion orchestration step
+
+## FAILURE MODES:
+
+❌ Failed to load or parse agent manifest CSV
+❌ Incomplete agent data extraction or roster building
+❌ Generic or unengaging party mode introduction
+❌ Not showcasing diverse agent capabilities
+❌ Not presenting [C] continue option after loading
+❌ Starting conversation without user selection
+
+## AGENT LOADING PROTOCOLS:
+
+- Validate CSV format and required columns
+- Handle missing or incomplete agent entries gracefully
+- Cross-reference manifest with actual agent files
+- Prepare agent selection logic for intelligent conversation routing
+
+## NEXT STEP:
+
+After user selects 'C', load `./step-02-discussion-orchestration.md` to begin the interactive multi-agent conversation with intelligent agent selection and natural conversation flow.
+
+Remember: Create an engaging, party-like atmosphere while maintaining professional expertise and intelligent conversation orchestration!