claude-all-hands 1.0.1 → 1.0.3

package/.claude/commands/continue.md

@@ -0,0 +1,122 @@
+---
+description: Continue implementation of current plan prompts
+---
+
+<objective>
+Loop through plan prompts, delegate to specialists for implementation, extract documentation, and complete when all prompts done. Handles parallel execution for independent prompts and variants.
+</objective>
+
+<context>
+Plan status: !`envoy plan check`
+</context>
+
+<process>
+<step name="get_next_prompts">
+Call `envoy plan next [-n <count>]`
+
+Returns next available prompts respecting dependencies:
+- If count > 1: returns independent prompts that can run in parallel
+- Variants of same prompt MUST all be returned together for parallel execution
+
+Each prompt includes:
+- prompt_num, variant (if applicable)
+- description
+- relevant files
+- is_debug flag
+</step>
+
+<step name="delegate_implementation">
+For each prompt from next:
+
+1. **Determine specialist**:
+   - If no suitable specialist found:
+     * AskUserQuestion: "No specialist for [domain]. Create one? (/create-specialist)"
+     * If user declines: use "worker" agent
+
+2. **Delegate based on type**:
+   - If prompt is debug type:
+     * "Run `envoy plan protocol debugging` and follow the steps. INPUTS: `{ prompt_num: <N>, variant: <V>, feature_branch: <current_branch> }`"
+   - Otherwise:
+     * "Run `envoy plan protocol implementation` and follow the steps. INPUTS: `{ prompt_num: <N>, variant: <V>, feature_branch: <current_branch> }`"
+
+3. **Parallel execution**: If multiple prompts/variants returned, delegate all in parallel
+</step>
+
+<step name="extract_documentation">
+After each specialist returns (prompt merged):
+
+Call `/docs adjust --diff` to update documentation based on changes.
+* Uses taxonomy-based approach to identify changed areas
+* Writers update relevant documentation with symbol references
+* Returns: `{ success: true }`
+</step>
+
+<step name="loop">
+Repeat steps 1-3 until:
+- No more prompts returned from next
+- No prompts in_progress status
+</step>
+
+<step name="full_review">
+Call `envoy gemini review --full`
+
+Returns: `{ verdict, thoughts?, answered_questions?, suggested_fixes? }`
+
+Full review examines:
+- All prompts
+- curator.md
+- user_input.md
+- Feature branch git diff
+</step>
+
+<step name="handle_review_failure">
+If verdict = "failed" OR suggested_fixes exist:
+
+1. Parse suggested_fixes for affected areas
+2. Delegate to relevant specialists:
+   * Pass `thoughts` and `answered_questions` as context
+   * Use implementation protocol
+3. Commit changes
+4. Rerun full review (repeat until passes)
+</step>
+
+<step name="mandatory_doc_audit">
+Call `/docs audit` to validate all documentation symbol references.
+* Checks for stale (hash changed) and invalid (symbol deleted) references
+* If issues found: fix automatically or present to user
+* Returns: `{ success: true }`
+</step>
+
+<step name="complete_plan">
+Call `envoy plan complete`
+
+This:
+- Generates summary.md
+- Creates PR
+- Marks plan as completed
+</step>
+
+<step name="handoff">
+Call /whats-next command
+</step>
+</process>
+
+<success_criteria>
+- All prompts implemented via specialist delegation
+- Variants executed in parallel
+- Documentation extracted for each prompt
+- Full review passes
+- Documentation audit completed
+- Plan marked complete with PR created
+- Control passed to /whats-next
+</success_criteria>
+
+<constraints>
+- MUST respect prompt dependencies (use envoy next)
+- MUST run all variants in parallel
+- MUST extract documentation after each prompt
+- MUST loop until no prompts remain
+- MUST pass full review before completing
+- MUST run doc audit before completion
+- All delegations MUST follow INPUTS/OUTPUTS format
+</constraints>

package/.claude/commands/create-skill.md

@@ -0,0 +1,107 @@
+---
+description: Create a new skill for agent capabilities
+argument-hint: [user prompt]
+---
+
+<objective>
+Create a new skill that provides domain expertise or workflow capabilities to agents. Gathers requirements via input gate, delegates to curator for implementation, runs audit, and manages testing/merge workflow.
+</objective>
+
+<context>
+Current branch: !`git branch --show-current`
+Existing skills: !`ls -la .claude/skills/`
+</context>
+
+<process>
+<step name="setup_branch">
+Create curator branch on top of current branch:
+- Infer name from user prompt (e.g., `curator/create-api-patterns-skill`)
+- This branch will NOT follow any planning material
+</step>
+
+<step name="input_gate">
+Gather skill requirements:
+
+1. **Goals**:
+   AskUserQuestion: "What are the goals of this skill? What should agents be able to do with it?"
+
+2. **Users**:
+   AskUserQuestion: "Which agents will use this skill? (Important for understanding use case)"
+
+3. **Reference URLs**:
+   AskUserQuestion: "Any URLs to store as references? (documentation, examples, patterns)"
+
+4. **Directory scope**:
+   AskUserQuestion: "Which codebase directory should this skill serve as documentation for? (optional)"
+</step>
+
+<step name="curator_create">
+Delegate to **curator agent** with curation-workflow:
+* INPUTS: `{ mode: 'create', artifact_type: 'skill', initial_context: '<input_gate_summary>' }`
+* OUTPUTS: `{ success: true, clarifying_questions?: [string] }`
+
+If clarifying_questions returned:
+- Present each question to user via AskUserQuestion
+- Gather answers and re-delegate with additional context
+</step>
+
+<step name="commit_creation">
+Commit changes with descriptive message
+</step>
+
+<step name="curator_audit">
+Delegate to **curator agent** with curation-audit-workflow:
+* INPUTS: `{ mode: 'audit', branch_name: '<current_branch>' }`
+* OUTPUTS: `{ success: true, amendments_made: boolean }`
+</step>
+
+<step name="testing">
+AskUserQuestion: "How would you like to test this skill?"
+Options: ["Invoke from an agent", "Read through content", "Skip testing", "Custom test"]
+
+Based on selection:
+- If invoke: guide user through having an agent use the skill
+- If read: display skill content for review
+- If custom: let user describe and run test
+- If skip: proceed to feedback
+</step>
+
+<step name="feedback_loop">
+AskUserQuestion: "Testing complete. How to proceed?"
+Options: ["Good to merge", "Need changes", "Abandon"]
+
+If "Need changes":
+- Gather feedback
+- Re-delegate to curator with amendments
+- Commit and repeat testing
+</step>
+
+<step name="commit_and_merge">
+Commit any final changes.
+
+Check branch status:
+- Call `envoy git is-base-branch` on parent branch
+- If parent is base branch: Create PR via `envoy git create-pr --title "<title>" --body "<body>"`
+- If parent has plan matter: Merge back to parent, add updates to curator.md
+
+Report completion with next steps.
+</step>
+</process>
+
+<success_criteria>
+- Curator branch created
+- Skill requirements gathered via input gate
+- Curator agent created skill directory and SKILL.md
+- Audit completed with any amendments
+- User testing completed
+- Changes committed and merged/PR created
+</success_criteria>
+
+<constraints>
+- MUST create curator/ branch (not follow planning material)
+- MUST gather which agents will use the skill
+- MUST run curator audit after creation
+- MUST allow user testing before merge
+- MUST handle both base branch and feature branch parents
+- All delegations MUST follow INPUTS/OUTPUTS format
+</constraints>

package/.claude/commands/create-specialist.md

@@ -0,0 +1,111 @@
+---
+description: Create a new specialist agent for domain expertise
+argument-hint: [initial context]
+---
+
+<objective>
+Create a new specialist agent tailored to a specific domain. Gathers requirements via input gate, delegates to curator for implementation, runs audit, and manages testing/merge workflow.
+</objective>
+
+<context>
+Current branch: !`git branch --show-current`
+Available envoy commands: !`envoy --help`
+Existing agents: !`ls -la .claude/agents/`
+</context>
+
+<process>
+<step name="setup_branch">
+Create curator branch on top of current branch:
+- Infer name from initial context (e.g., `curator/create-auth-specialist`)
+- This branch will NOT follow any planning material
+</step>
+
+<step name="input_gate">
+Gather specialist requirements:
+
+1. **Responsibility**:
+   AskUserQuestion: "What is this agent's primary responsibility? (This infers which skills it uses)"
+
+2. **Area of expertise**:
+   AskUserQuestion: "Which codebase files/areas does this agent specialize in?"
+
+3. **Existing skills**:
+   Show available skills, ask: "Which existing skills should this agent have access to?"
+
+4. **New skills needed**:
+   AskUserQuestion: "Any new skills needed? If yes, provide: skill name, purpose, reference URLs"
+   - If new skills: will need to run /create-skill after specialist creation
+
+5. **Envoy usage**:
+   Show envoy commands (from context), ask: "Which envoy commands should this agent use?"
+</step>
+
+<step name="curator_create">
+Delegate to **curator agent** with curation-workflow:
+* INPUTS: `{ mode: 'create', artifact_type: 'specialist', initial_context: '<input_gate_summary>' }`
+* OUTPUTS: `{ success: true, clarifying_questions?: [string] }`
+
+If clarifying_questions returned:
+- Present each question to user via AskUserQuestion
+- Gather answers and re-delegate with additional context
+</step>
+
+<step name="commit_creation">
+Commit changes with descriptive message
+</step>
+
+<step name="curator_audit">
+Delegate to **curator agent** with curation-audit-workflow:
+* INPUTS: `{ mode: 'audit', branch_name: '<current_branch>' }`
+* OUTPUTS: `{ success: true, amendments_made: boolean }`
+</step>
+
+<step name="testing">
+AskUserQuestion: "How would you like to test this agent?"
+Options: ["Run a sample task", "Skip testing", "Custom test"]
+
+Based on selection:
+- If sample task: guide user through invoking the agent
+- If custom: let user describe and run test
+- If skip: proceed to feedback
+</step>
+
+<step name="feedback_loop">
+AskUserQuestion: "Testing complete. How to proceed?"
+Options: ["Good to merge", "Need changes", "Abandon"]
+
+If "Need changes":
+- Gather feedback
+- Re-delegate to curator with amendments
+- Commit and repeat testing
+</step>
+
+<step name="commit_and_merge">
+Commit any final changes.
+
+Check branch status:
+- Call `envoy git is-base-branch` on parent branch
+- If parent is base branch: Create PR via `envoy git create-pr --title "<title>" --body "<body>"`
+- If parent has plan matter: Merge back to parent, add updates to curator.md
+
+Report completion with next steps.
+</step>
+</process>
+
+<success_criteria>
+- Curator branch created
+- Specialist requirements gathered via input gate
+- Curator agent created specialist file
+- Audit completed with any amendments
+- User testing completed
+- Changes committed and merged/PR created
+</success_criteria>
+
+<constraints>
+- MUST create curator/ branch (not follow planning material)
+- MUST show available skills and envoy commands during input gate
+- MUST run curator audit after creation
+- MUST allow user testing before merge
+- MUST handle both base branch and feature branch parents
+- All delegations MUST follow INPUTS/OUTPUTS format
+</constraints>

package/.claude/commands/curator-audit.md

@@ -0,0 +1,4 @@
+---
+description: Run an audit with the curator sub-agent (placeholder - not yet implemented)
+---
+**NOT YET IMPLEMENTED**

package/.claude/commands/debug.md

@@ -0,0 +1,183 @@
+---
+description: Debug workflow for bug investigation and fix
+argument-hint: [bug-description] [--quick | --create | --refine]
+---
+
+<objective>
+Orchestrate the debugging workflow: gather bug context, delegate to specialists for investigation, create fix plan with observability, and hand off to /continue.
+
+Modes:
+- `--quick`: No questions, no observability prompt, direct to planner
+- `--create`: New debugging session (default if no existing plan)
+- `--refine`: Add bug fix to existing plan
+</objective>
+
+<context>
+Plan status: !`envoy plan check`
+</context>
+
+<process>
+<step name="parse_mode">
+Parse $ARGUMENTS for mode flags and bug description:
+- If `--quick` present: quick_mode = true
+- If `--create` present: mode = "create"
+- If `--refine` present: mode = "refine"
+- Everything else = bug_description
+</step>
+
+<step name="quick_mode" condition="quick_mode = true">
+**Quick Mode - No questions, no observability**
+
+1. Call `envoy plan check` to get status
+2. If no plan: Create branch from bug description (infer name)
+3. Append bug description: `envoy plan append-user-input "<bug_description>"`
+4. Delegate to **planner agent**:
+   * "Run the planning-workflow. INPUTS: `{ mode: 'quick', workflow_type: 'debug', feature_branch: <current_branch>, plan_status: <status> }`"
+   * OUTPUTS: `{ success: true }`
+5. Call /continue command
+6. **Exit** - quick mode complete
+</step>
+
+<step name="check_status" condition="quick_mode = false">
+Call `envoy plan check` and determine mode:
+
+| Condition | Action |
+|-----------|--------|
+| No plan, user_input.md has content | Read user_input.md, continue to input_gate |
+| No plan, fresh start | Create branch (infer name from bug), set mode = "create" |
+| Plan exists, bug unrelated | AskUserQuestion: "Existing plan found. Continue with it or start fresh?" |
+| Plan exists, bug likely from current work | Set mode = "refine" |
+
+If user chooses "start fresh": create new branch off base, set mode = "create"
+</step>
+
+<step name="input_gate">
+**Progressive disclosure for debugging**
+
+1. **Observability** (always ask - critical for debug):
+   AskUserQuestion: "How should we monitor for this bug recurring once fixed?"
+   Options: ["Add logging", "Add metrics/alerts", "Add test coverage only", "Skip observability"]
+
+2. **Error details** (if not in description):
+   AskUserQuestion: "Can you share the exact error message and steps to reproduce?"
+
+3. **Timeline** (if not clear):
+   AskUserQuestion: "When did this start? (recent deploy, always, after specific change)"
+
+4. **Suspected area** (if not inferred):
+   AskUserQuestion: "Any suspected code area or recent changes?"
+
+5. **Severity**:
+   AskUserQuestion: "What's the severity?"
+   Options: ["Blocks release", "Can workaround", "Nice to fix"]
+
+6. **Domain-specific questions** (progressive):
+   Build questions from Debugging Knowledge Bank below. Ask 3 at a time, offer "continue with current context" option.
+</step>
+
+<step name="write_user_input">
+Append all gathered context to user_input.md:
+`envoy plan append-user-input "<all_gathered_context>"`
+</step>
+
+<step name="specialist_delegation">
+1. Extract bug symptoms, suspected areas, reproduction context
+2. Cluster by primary domain
+3. For each cluster, determine specialist:
+   - If confidence lacking: AskUserQuestion: "Should I create a new specialist for [domain]? (/create-specialist)"
+   - If no specialist and user declines: use "surveyor" agent
+4. Delegate to specialists:
+   * "Run `envoy plan protocol bug-discovery` and follow the steps. INPUTS: `{ agent_name: '<specialist_name>[_N]', segment_context: '<bug_context_for_segment>' }`"
+   * Add `_N` suffix if multiple segments for same specialist
+   * OUTPUTS: `{ success: true }`
+</step>
+
+<step name="get_findings">
+Call `envoy plan get-findings` to get bug hypotheses/approaches
+</step>
+
+<step name="research_delegation">
+For each research objective (known library issues, similar errors, anti-patterns):
+* Delegate to **researcher agent**:
+  * "Run `envoy plan protocol bug-discovery` and follow the steps. INPUTS: `{ agent_name: 'researcher[_N]', segment_context: '<research_objectives_with_approach_references>' }`"
+  * OUTPUTS: `{ success: true }`
+</step>
+
+<step name="findings_gate">
+1. Present all clarifying questions from approach documents (bug hypotheses) to user
+2. AskUserQuestion: "Want to redirect investigation with specific requirements? (clears all findings)"
+   - If yes: clear findings, return to specialist_delegation step
+3. Call `envoy plan block-findings-gate`
+   - Returns: `{ thoughts, affected_approaches: [{ specialist_name, approach_number }] }`
+4. If affected_approaches exist:
+   - Re-delegate to affected specialists with thoughts context
+   - Rerun findings gate
+</step>
+
+<step name="planner_delegation">
+Delegate to **planner agent**:
+* "Run the planning-workflow. INPUTS: `{ mode: '<create|refine>', workflow_type: 'debug', feature_branch: '<current_branch>' }`"
+* OUTPUTS: `{ success: true }`
+
+Note: Planner creates debug prompts (use debugging protocol) and observability prompt (use implementation protocol) based on input_gate answers.
+</step>
+
+<step name="handoff">
+Call /continue command
+</step>
+</process>
+
+<knowledge_bank name="debugging_input_gate">
+**Bug characterization:**
+- Exact observed behavior (error messages, incorrect output, crash)
+- Expected behavior
+- Reproduction steps (numbered)
+- Frequency (always, sometimes, specific conditions)
+- When it started (recent deploy, always, after specific change)
+- Environment details (device, browser, OS, app version, user type)
+
+**Investigation context:**
+- Any logs, errors, or stack traces already captured
+- Suspected area of code (if any)
+- Recent changes to related areas
+- Related features that DO work correctly
+- Data conditions that trigger it (specific user, specific input)
+
+**Constraints:**
+- Severity/urgency (blocks release, can workaround, nice to fix)
+- Areas of code that CANNOT be changed
+- Deadline pressure (quick patch vs proper fix)
+
+**Observability planning:**
+- How should we monitor for this bug recurring?
+- What signals would indicate the fix worked?
+- Any existing monitoring that should have caught this?
+
+**Informational context for LLM:**
+- Reproduction steps are critical - push for specifics
+- "When did it start" often reveals the cause
+- Stack traces/error messages are gold - ask if user has them
+- Frequency hints at race conditions vs logic errors
+- If user has a hypothesis, capture it even if uncertain
+- For --refine, only ask about NEW information
+- Combine related bullets into single questions
+</knowledge_bank>
+
+<success_criteria>
+- Mode correctly determined from arguments and context
+- Bug context gathered via progressive disclosure
+- Observability approach determined (except in quick mode)
+- Specialists delegated with bug-discovery protocol
+- Findings gate reviewed with user
+- Debug plan created with fix + observability prompts
+- Control passed to /continue
+</success_criteria>
+
+<constraints>
+- MUST ask observability question (except quick mode)
+- MUST use bug-discovery protocol for specialists
+- MUST NOT proceed without user confirmation at gates
+- MUST append all user context to user_input.md via envoy
+- Quick mode MUST skip all questions and observability
+- All delegations MUST follow INPUTS/OUTPUTS format
+</constraints>