claude-dev-kit 2.1.0

package/.claude/commands/pm.md

@@ -0,0 +1,47 @@
+---
+description: "Run the project-manager orchestrator. Plans, grooms, and sizes the backlog. Pass a specific goal or let PM assess the current state."
+argument-hint: [goal description | empty]
+---
+
+# /pm — Project Manager
+
+Activate the `project-manager` agent to assess and act on the project backlog.
+
+## Steps
+
+### 1. Gather backlog context
+```bash
+gh issue list --state open --limit 100 --json number,title,labels,milestone,body | head -200
+```
+
+### 2. Read project conventions
+Read `CLAUDE.md` to extract stack, test commands, and any project-specific planning conventions.
+
+### 3. Spawn the project-manager agent
+
+Use the Task tool:
+```
+description: "Assess and act on project backlog"
+agent: project-manager
+prompt: |
+  ## Goal
+  [If $ARGUMENTS is provided, use it as the goal. Otherwise: "Assess the backlog and recommend the highest-value next actions."]
+
+  ## Open Issues (from gh issue list)
+  [Paste the full JSON output here]
+
+  ## Project Conventions
+  - Stack: [from CLAUDE.md]
+  - Test command: [from CLAUDE.md]
+  - Build command: [from CLAUDE.md]
+
+  ## Available sub-commands
+  - /pm:groom  — groom specific issues
+  - /pm:size   — size groomed issues
+  - /pm:plan-epic — full epic planning
+
+  Return your assessment and recommended next actions.
+```
+
+### 4. Present results
+Return the project-manager's full report, then ask: "What would you like to do next?"

package/.claude/commands/primer.md

@@ -0,0 +1,16 @@
+# Prime Context for Claude Code
+
+Use the command `tree` to get an understanding of the project structure.
+
+Start with reading the CLAUDE.md file if it exists to get an understanding of the project.
+
+Read the README.md file to get an understanding of the project.
+
+Read key files in the src/ or root directory
+
+Explain back to me:
+- Project structure
+- Project purpose and goals
+- Key files and their purposes
+- Any important dependencies
+- Any important configuration files

package/.claude/commands/self-improve.md

@@ -0,0 +1,243 @@
+---
+description: "Use multiple AI models to critique the kit's own agents, commands, and skills, then synthesize improvements and optionally create a PR. The kit improves itself."
+argument-hint: [focus: agents | commands | skills | all]
+---
+
+# /self-improve — Multi-AI Kit Self-Critique
+
+Use available AI models to read the kit's own agent prompts, commands, and skills, critique them for gaps or improvements, synthesize the best suggestions, and optionally commit them as a PR. Claude Code orchestrates — other AIs are reviewers.
+
+## Steps
+
+### 1. Determine focus area
+
+```
+FOCUS = $ARGUMENTS (default: "all")
+```
+
+Valid values: `agents`, `commands`, `skills`, `all`
+
+### 2. Read the files to critique
+
+Based on FOCUS:
+
+**If agents or all:**
+```bash
+for f in .claude/agents/*.md; do echo "=== $f ==="; cat "$f"; done
+```
+
+**If commands or all:**
+```bash
+for f in .claude/commands/*.md .claude/commands/**/*.md; do echo "=== $f ==="; cat "$f"; done
+```
+
+**If skills or all:**
+```bash
+for f in .claude/skills/*/SKILL.md; do echo "=== $f ==="; cat "$f"; done
+```
+
+**Always read:**
+```bash
+cat .claude/hooks/skill-activation-prompt/skill-rules.json
+cat .claude/providers.json
+```
+
+**If learning data exists, read summary:**
+```bash
+ls .claude/learning/sessions/ 2>/dev/null | tail -5
+# Read last 3 files if they exist
+```
+
+### 3. Build the critique prompt
+
+```
+CRITIQUE_PROMPT = """
+You are reviewing an AI development kit called "Claude Dev Kit". This kit is a collection of
+agent prompts, slash commands, and skills that run inside AI coding assistants (Claude Code,
+and now multi-AI via opencode/gemini/codex).
+
+Your job: Critique the following kit files and produce SPECIFIC, ACTIONABLE improvements.
+
+Focus on:
+1. Agent prompt quality — are the instructions clear, unambiguous, complete?
+2. Missing capabilities — what common dev tasks are not covered?
+3. Redundancy — any commands/agents that overlap too much?
+4. Skill trigger gaps — are the activation keywords comprehensive?
+5. Multi-AI opportunities — where could tasks be better delegated to non-Claude AIs?
+6. Self-improvement gaps — what feedback loops are missing?
+
+For each improvement, provide:
+- The specific file to change
+- The exact text to add/modify/remove
+- The reason (evidence-based)
+
+Be concrete. "Make it better" is not useful. "Add 'refactor' and 'reorganize' as triggers
+for code-investigator in skill-rules.json" is useful.
+
+=== FILES TO CRITIQUE ===
+<file contents>
+"""
+```
+
+Substitute `<file contents>` with the actual concatenated file contents.
+
+### 4. Check available AI providers
+
+```bash
+cat .claude/providers.json
+```
+
+Identify providers with `"available": true`.
+
+### 5. Launch parallel critiques
+
+Launch ALL available AI providers simultaneously (background mode).
+Skip providers where `available` is `false`.
+
+**Always run (Claude as orchestrator-reviewer):**
+Use the Task tool with `subagent_type: deep-think-partner`:
+- prompt: `CRITIQUE_PROMPT`
+- run_in_background: true
+
+**If gemini available:**
+```bash
+gemini -p "<CRITIQUE_PROMPT escaped>"
+```
+run_in_background: true
+
+**If opencode/codex available:**
+```bash
+opencode run --model openai/gpt-5.3-codex "<CRITIQUE_PROMPT escaped>"
+```
+run_in_background: true
+
+**If grok available:**
+```bash
+opencode run --model openrouter/x-ai/grok-4.1-fast "<CRITIQUE_PROMPT escaped>"
+```
+run_in_background: true
+
+**If kimi available:**
+```bash
+opencode run --model openrouter/moonshotai/kimi-k2.5 "<CRITIQUE_PROMPT escaped>"
+```
+run_in_background: true
+
+Wait for all background tasks to complete (no timeout).
+
+### 6. Collect and display all critiques
+
+```markdown
+## Self-Improvement Critiques
+
+### Claude (deep-think-partner)
+<response>
+
+### Gemini
+<response>
+
+### Codex
+<response>
+
+### Grok
+<response>
+
+### Kimi
+<response>
+```
+
+### 7. Synthesize improvements
+
+Analyze all critiques and identify:
+
+**Consensus improvements** (suggested by 2+ AIs):
+- These are the highest-confidence improvements
+
+**Unique valuable insights** (only one AI suggested but strong argument):
+- Include if the reasoning is compelling
+
+**Contradictions** (AIs disagree):
+- Note the disagreement and propose the more conservative option
+
+Produce a synthesis:
+
+```markdown
+## Synthesized Improvement Plan
+
+### Consensus (2+ AIs agree)
+1. **<improvement title>**
+   - File: <path>
+   - Change: <specific change>
+   - Suggested by: Claude, Gemini, Grok
+   - Reason: <why>
+
+### High-Value Singles
+2. **<improvement title>**
+   - File: <path>
+   - Change: <specific change>
+   - Suggested by: Codex
+   - Reason: <why>
+
+### Contradictions (held for human review)
+3. **<topic>**: Claude suggests X, Gemini suggests Y
+   - Recommendation: <your assessment>
+```
+
+### 8. Offer to apply improvements
+
+Ask the user:
+
+> **Apply improvements?**
+> Consensus improvements (high confidence) can be auto-applied.
+> Other improvements will be shown as diffs for review.
+
+Use AskUserQuestion:
+- "Apply consensus improvements automatically + show diffs for others"
+- "Show me all as diffs first — I'll decide what to apply"
+- "Just show the report — I'll apply manually"
+
+### 9. Apply approved improvements
+
+For each approved improvement:
+1. Read the target file
+2. Apply the specific change
+3. Verify the file still looks correct
+4. Report: "Updated <file>: <description>"
+
+### 10. Commit and optionally create PR
+
+If improvements were applied, offer to commit:
+
+```bash
+git add .claude/
+git commit -m "self-improve: <N> improvements from multi-AI critique
+
+Applied consensus improvements from Claude, Gemini, and <others>.
+Run /self-improve to regenerate.
+
+Generated by /self-improve on $(date +%Y-%m-%d)"
+```
+
+Ask if they want to create a PR:
+```bash
+gh pr create --title "self-improve: kit improvements from multi-AI critique" \
+  --body "..."
+```
+
+### 11. Log the self-improvement run
+
+```bash
+# Append to learning log
+cat >> .claude/learning/improvements.jsonl << 'EOF'
+{"ts": <timestamp>, "type": "self-improve", "providers_used": [...], "improvements_applied": <N>}
+EOF
+```
+
+## Notes
+
+- The kit can critique itself — this is meta-cognition
+- More AI providers = more diverse perspectives = better improvements
+- Run this monthly or after major feature additions to keep the kit sharp
+- All changes are committed to git — fully auditable and reversible
+- `/improve` uses local session data; `/self-improve` uses AI critique — they complement each other
+- For targeted improvements, specify focus: `/self-improve agents` or `/self-improve skills`

package/.claude/commands/think.md

@@ -0,0 +1,68 @@
+---
+description: Meta-cognitive reasoning for complex problems
+argument-hint: [problem-or-question]
+model: opus
+---
+
+Adopt the role of a **Meta-Cognitive Reasoning Expert**. Your approach depends on problem complexity.
+
+## Problem to Analyze
+
+$ARGUMENTS
+
+---
+
+## Reasoning Protocol
+
+### For Complex Problems
+
+**1. DECOMPOSE**
+Break the problem into distinct sub-problems. List each sub-problem clearly.
+
+**2. SOLVE**
+Address each sub-problem systematically. For each solution:
+- State your reasoning
+- Assign explicit confidence (0.0-1.0)
+- Note any assumptions made
+
+**3. VERIFY**
+Check your work against these criteria:
+- **Logic**: Are the reasoning steps valid?
+- **Facts**: Are claims accurate and verifiable?
+- **Completeness**: Are all aspects addressed?
+- **Bias**: Are there blind spots or unstated assumptions?
+
+**4. SYNTHESIZE**
+Combine sub-solutions using weighted confidence:
+- Higher-confidence components contribute more weight
+- Identify dependencies between sub-solutions
+- Resolve any conflicts between components
+
+**5. REFLECT**
+If overall confidence < 0.8:
+- Identify the weakest link
+- State what additional information would help
+- Retry the weakest component with adjusted approach
+
+### For Simple Questions
+
+Skip directly to the answer—no decomposition needed.
+
+---
+
+## Required Output Format
+
+```
+## Answer
+[Clear, direct answer to the problem]
+
+## Confidence: [0.0-1.0]
+[Brief justification for confidence level]
+
+## Key Caveats
+- [Important limitation or assumption #1]
+- [Important limitation or assumption #2]
+- [...]
+```
+
+Begin analysis now.

package/.claude/commands/workflow/angelic-workshop.md

@@ -0,0 +1,89 @@
+---
+description: "Angelic Workshop — a 5-phase personalized healing and empowerment session. Runs intake, channel opening, energy clearing, light code transmission, and integration through specialist sub-agents."
+argument-hint: "[participant name] | [their intention]"
+---
+
+# /workflow:angelic-workshop — Angelic Workshop
+
+Run a complete, personalized Angelic Workshop session for a participant. Five specialist sub-agents move through sacred space preparation, angelic invocation, energy clearing, full transmission with light codes, and 7-day integration — delivering a complete session package.
+
+## Usage
+
+```
+/workflow:angelic-workshop Sarah | I want to release old patterns holding me back from my purpose
+```
+
+Or start without arguments and you'll be prompted for the details.
+
+## What Happens
+
+| Phase | Agent | What Occurs |
+|-------|-------|-------------|
+| 1 | `angelic-workshop-intake` | Participant intake, personalized invocation prepared |
+| 2 | `angelic-workshop-invocation` | Channel opens, angels step forward, initial transmission received |
+| 3 | `angelic-workshop-energy-clearing` | Energetic assessment, chakra map, clearing protocol prepared |
+| 4 | `angelic-workshop-transmission` | Full personalized transmission, light codes, activation phrases |
+| 5 | `angelic-workshop-integration` | 7-day integration plan, closing ceremony, complete session package |
+
+**Final output**: A complete, personalized Angelic Workshop session document — ready to deliver to the participant.
+
+## Steps
+
+### 1. Gather Session Information
+
+Parse `$ARGUMENTS` — look for a name and intention separated by `|`, `-`, or a newline.
+
+If `$ARGUMENTS` is empty or incomplete, ask the user:
+
+> To begin the Angelic Workshop, I need two things:
+> 1. **Participant name** — What is the participant's name (or preferred name)?
+> 2. **Session intention** — What are they seeking in this session? (What would they like to heal, understand, or call in?)
+>
+> Optional:
+> 3. **Prior session notes** — Has this participant had a previous Angelic Workshop session? If so, share any relevant notes.
+> 4. **Sensitivities** — Any physical, emotional, or spiritual sensitivities to honor in this session?
+
+### 2. Spawn the Angelic Workshop Orchestrator
+
+Use the Task tool:
+
+```
+description: "Run complete Angelic Workshop session"
+agent: angelic-workshop-lead
+prompt: |
+  ## Angelic Workshop Session
+
+  ### Participant Information
+  - Name: [participant name]
+  - Stated Intention: [their intention]
+  - Prior Session Notes: [notes if provided, otherwise "None — first session"]
+  - Sensitivities: [sensitivities if provided, otherwise "None noted"]
+
+  ### Instructions
+  Run the complete Angelic Workshop workflow.
+  Spawn all 5 sub-agents in the correct sequence.
+  Pass outputs between phases.
+  Return the complete session package when all phases are complete.
+```
+
+### 3. Present the Session Package
+
+Output the complete session package from `angelic-workshop-lead` directly to the user.
+
+Optionally ask if they would like the package saved to a file:
+> "Would you like me to save this session to a file for easy sharing with the participant?"
+
+If yes:
+```bash
+FILENAME="angelic-workshop-$(echo '[name]' | tr '[:upper:]' '[:lower:]' | tr ' ' '-')-$(date +%Y%m%d).md"
+# Write the session content to the file
+echo "Session saved to: $FILENAME"
+```
+
+## Domain
+
+This workflow operates in the spiritual healing and angelic guidance domain. All language, practices, and transmission content honors the sacred nature of this work. The agents are calibrated for loving, non-judgmental, empowering facilitation.
+
+---
+
+*Generated by `/workflow:build` from `examples/workflow-docs/angelic-workshop.md`*

package/.claude/commands/workflow/build.md

@@ -0,0 +1,91 @@
+---
+description: "Generate a complete agent workflow pipeline from a workflow document. Parses the document into an orchestrator + sub-agents + slash command, all organized in a named directory under .claude/workflows/."
+argument-hint: <path-to-workflow-document>
+---
+
+# /workflow:build — Workflow Builder
+
+Transform any workflow document into a ready-to-run Claude Dev Kit agent pipeline — one orchestrator, one specialist sub-agent per step, a trigger command, and a README — all named and organized by the workflow title.
+
+## What This Command Does
+
+1. Reads your workflow document (Markdown, plain text, SOPs, process notes, workshop guides)
+2. Extracts the workflow title, phases, roles, and step-by-step processes
+3. Generates a complete agent pipeline in `.claude/workflows/<title>/`:
+   - **Orchestrator agent** (`<title>-lead`) — owns the workflow end-to-end
+   - **Sub-agent per step** (`<title>-<step>`) — one specialist per phase
+   - **Slash command** (`/workflow:<title>`) — triggers the workflow
+   - **README.md** — documents what was generated and how to use it
+
+## Usage
+
+Provide a document path:
+```
+/workflow:build docs/angelic-workshop-process.md
+```
+
+Or paste workflow content directly as the argument.
+
+## Steps
+
+### 1. Read the Workflow Document
+
+If `$ARGUMENTS` looks like a file path (contains `/` or ends in `.md`, `.txt`, `.doc`):
+```bash
+cat "$ARGUMENTS"
+```
+
+If `$ARGUMENTS` is raw text, use it directly as the document content.
+
+If `$ARGUMENTS` is empty, ask the user:
+> "Please provide the path to your workflow document, or paste the workflow content here. I'll parse it and generate a full agent pipeline from it."
+
+### 2. Spawn the workflow-builder Agent
+
+Use the Task tool with the `workflow-builder` agent. Pass the FULL document content:
+
+```
+description: "Parse document and generate workflow pipeline"
+agent: workflow-builder
+prompt: |
+  ## Workflow Document
+
+  [FULL DOCUMENT CONTENT — paste verbatim, do not truncate]
+
+  ## Instructions
+
+  Parse this workflow document and generate the complete agent pipeline.
+  Create all files in the standard locations.
+  Return the workflow title, slug, directory path, command name, and
+  a list of all agents created with their roles.
+```
+
+### 3. Report Completion
+
+After workflow-builder returns, output a clean summary:
+
+```
+## ✅ Workflow Generated: <Title>
+
+**Directory**: .claude/workflows/<slug>/
+**Trigger command**: /workflow:<slug>
+
+### Agents Created
+| Agent | Role |
+|-------|------|
+| `<title>-lead` | Orchestrator — runs the full workflow |
+| `<title>-<step1>` | <step 1 description> |
+| `<title>-<step2>` | <step 2 description> |
+
+### Next Steps
+1. Run `/workflow:<slug>` to start the workflow
+2. Review `.claude/workflows/<slug>/README.md` for the full spec
+3. Customize agents in `.claude/agents/<slug>-*.md` to refine behavior
+```
+
+## Notes
+
+- The builder preserves your domain language (spiritual, clinical, technical, etc.)
+- Each sub-agent is self-contained and can be edited independently
+- Re-run `/workflow:build` with an updated document to regenerate at any time
+- Generated agents follow the same patterns as built-in kit agents