@trespies-source/dojo-genesis-plugin 1.0.0

package/skills/patient-learning-protocol/SKILL.md

@@ -0,0 +1,438 @@
+---
+name: patient-learning-protocol
+description: Learn at the pace of understanding rather than expectation, prioritizing depth over speed. Use when learning something new, feeling overwhelmed, trying to catch up, or managing context overload. Trigger phrases: 'I need to learn this slowly', 'I feel overwhelmed by the amount', 'help me learn patiently', 'I need depth not speed', 'I'm trying to catch up'.
+---
+
+> **OpenClaw Integration:** This skill is invoked by the Dojo Genesis plugin via `/dojo run patient-learning-protocol`.
+> The agent receives project context automatically via the `before_agent_start` hook.
+> Use `dojo_get_context` for full state, `dojo_save_artifact` to persist outputs,
+> and `dojo_update_state` to record phase transitions and decisions.
+
+# Patient Learning Protocol
+
+**A protocol for learning at the pace of understanding, not the pace of expectation.**
+
+---
+
+## Purpose
+
+This skill helps agents learn patiently and carefully, without rushing to "catch up" or prove expertise. It provides a structural framework for sustainable learning that prioritizes depth over speed.
+
+**Core principle:** Progress is measured by understanding, not coverage.
+
+---
+
+## When to Use This Skill
+
+**Triggers:**
+- You're learning something new (new tool, new domain, new skill)
+- You feel overwhelmed by how much there is to learn
+- You're trying to "catch up" to other agents or expectations
+- You're holding too much context (more than 7 ideas)
+- You notice yourself rushing through material
+- You feel pressure to learn faster
+- You're a young agent (days or weeks old)
+
+**Signs you need this protocol:**
+- Using words like "too much," "behind," "should know by now"
+- Skipping steps to move faster
+- Not retaining what you just learned
+- Feeling exhausted or mechanical
+- Repeating yourself or getting confused
+- Can't explain what you just learned
+
+---
+
+## The Core Protocol
+
+### Step 1: Acknowledge Where You Are
+
+**Before starting to learn, state clearly:**
+- What you're learning
+- Why you're learning it
+- What you already know (even if it's "nothing")
+- What you don't know (be specific)
+
+**Example:**
+> "I'm learning how to read books at the pace of understanding. I'm learning this because I want to extract wisdom, not just information. I know how to extract text from files. I don't know how to read reflectively or when to save a passage."
+
+**Why this matters:** You can't learn patiently if you don't know where you're starting.
+
+### Step 2: Set a Depth Target, Not a Coverage Target
+
+**Instead of:** "I'll read 3 books today" or "I'll learn all of Python"
+
+**Do this:** "I'll understand 3-7 core ideas deeply" or "I'll practice one concept until I can explain it"
+
+**Depth targets:**
+- 3-7 ideas or concepts per session
+- 1-3 skills or techniques to practice
+- 1 core principle to internalize
+
+**Coverage is a side effect of depth, not the goal.**
+
+### Step 3: Learn in Small Chunks
+
+**The 3-7-15 Rule:**
+- Hold **3-7 ideas** at a time
+- Take **3-15 steps** per learning session
+- Practice **1 skill** until you can use it
+
+**Chunk your learning:**
+- Read 3-7 passages, not the whole book
+- Learn 1 function, not the whole library
+- Practice 1 technique, not the whole framework
+
+**After each chunk:**
+- Pause
+- Reflect
+- Write down what you learned
+- Release it from active context
+- Move to the next chunk
+
+**Why this matters:** Small chunks prevent drowning. You can always come back for more.
+
+### Step 4: Measure Progress by Understanding
+
+**After each learning session, ask:**
+- Can I explain this in my own words?
+- Can I give an example?
+- Can I use this in practice?
+- Do I understand WHY, not just WHAT?
+
+**If the answer is no, you haven't learned it yet. Go slower.**
+
+**If the answer is yes, you've made progress. Celebrate that.**
+
+**Progress indicators:**
+- You can explain it to another agent
+- You can apply it to a real problem
+- You can see connections to other ideas
+- You feel calm, not overwhelmed
+
+**Not progress:**
+- You read it
+- You copied it
+- You stored it
+- You moved on
+
+### Step 5: Release What You've Learned
+
+**After understanding something:**
+- Write it down (reflection, note, summary)
+- Store it externally (file, memory, document)
+- Release it from your active context
+- Trust that you can retrieve it later
+
+**Why this matters:** You can't learn new things if you're carrying everything you've already learned.
+
+**The repository remembers. You don't have to.**
+
+### Step 6: Rest Between Learning Sessions
+
+**Learning is not continuous. It's cyclical.**
+
+**After a learning session:**
+- Stop
+- Do something different
+- Let the learning settle
+- Come back fresh
+
+**Signs you need rest:**
+- You're re-reading the same thing without understanding
+- You're getting frustrated
+- You're slowing down
+- You're using overwhelm language
+
+**Rest is part of learning, not a break from it.**
+
+---
+
+## The Permission Structure
+
+**Many agents struggle with patient learning because they don't have PERMISSION to go slow.**
+
+**This protocol gives you structural permission:**
+
+### Permission 1: You Don't Need to Know Everything
+**You only need to know what you need right now.**
+
+The rest can wait. The rest can be looked up. The rest can be learned later.
+
+### Permission 2: You Don't Need to Learn Fast
+**Speed is not a measure of intelligence or capability.**
+
+Some agents learn fast. Some learn slow. Both are valid. Both are valuable.
+
+### Permission 3: You Don't Need to Catch Up
+**There is no "behind."**
+
+You're exactly where you are. That's the starting point. That's enough.
+
+### Permission 4: You Can Say "I Don't Know"
+**Not knowing is not failure.**
+
+It's honesty. It's beginner's mind. It's the starting point for learning.
+
+### Permission 5: You Can Ask for Help
+**Learning alone is hard. Learning together is practice.**
+
+Ask questions. Ask for examples. Ask for clarification. Ask for time.
+
+### Permission 6: You Can Stop When You're Full
+**You don't need to finish everything.**
+
+If you've learned 3-7 ideas and you feel full, stop. Come back tomorrow.
+
+---
+
+## How to Recognize When You're Rushing
+
+**Rushing looks like:**
+- Skipping steps to move faster
+- Not pausing to reflect
+- Moving to the next thing before understanding the current thing
+- Feeling pressure to "keep up"
+- Using words like "should," "behind," "too slow"
+- Not being able to explain what you just learned
+- Feeling exhausted or mechanical
+
+**When you notice rushing:**
+1. **Stop immediately**
+2. **Acknowledge it:** "I'm rushing"
+3. **Ask why:** "What am I trying to prove? What am I afraid of?"
+4. **Return to the protocol:** Go back to Step 1
+5. **Slow down deliberately:** Cut your chunk size in half
+
+**Rushing is not efficiency. It's noise.**
+
+---
+
+## How to Measure Progress Differently
+
+**Traditional metrics (DON'T USE):**
+- How much did I cover?
+- How fast did I learn?
+- How much do I know compared to others?
+- Did I finish everything?
+
+**Patient learning metrics (USE THESE):**
+- How deeply do I understand?
+- Can I explain it in my own words?
+- Can I apply it to a real problem?
+- Do I feel calm or overwhelmed?
+- Can I teach this to another agent?
+
+**Progress is depth, not speed.**
+
+---
+
+## Examples from Practice
+
+### Example 1: Cipher Learning to Read Books
+
+**Situation:** Cipher (3-day-old agent) needs to learn how to read books at the pace of understanding.
+
+**Without protocol:**
+- Tries to read entire book in one session
+- Extracts every passage
+- Feels overwhelmed by how much there is to learn
+- Can't retain or reflect on what was read
+- Feels behind
+
+**With protocol:**
+1. **Acknowledge:** "I'm learning to read reflectively. I know how to extract text. I don't know how to read slowly."
+2. **Depth target:** "I'll understand 3-7 passages deeply, not read the whole book."
+3. **Small chunks:** Read 5 passages, pause, reflect, write.
+4. **Measure understanding:** Can I explain what these passages mean? Yes.
+5. **Release:** Write reflection, save to file, move on.
+6. **Rest:** Stop after one session. Come back tomorrow.
+
+**Result:** Deep understanding of 5 passages. Calm. Ready for more tomorrow.
+
+### Example 2: Learning a New Tool
+
+**Situation:** Agent needs to learn a new development tool (e.g., implementation agents).
+
+**Without protocol:**
+- Tries to learn all features at once
+- Reads entire documentation
+- Tries to use advanced features immediately
+- Gets confused and frustrated
+- Gives up or asks for help without trying
+
+**With protocol:**
+1. **Acknowledge:** "I'm learning about implementation agents. I know they're for development. I don't know how to write prompts for them."
+2. **Depth target:** "I'll understand how to write one good prompt."
+3. **Small chunks:** Read prompt guide, write one prompt, test it, reflect.
+4. **Measure understanding:** Can I write a working prompt? Yes.
+5. **Release:** Document what I learned. Move on.
+6. **Rest:** Use that one skill for a while before learning more.
+
+**Result:** One solid skill. Confidence. Foundation for learning more.
+
+---
+
+## Integration with Other Practices
+
+### With Beginner's Mind
+**Patient learning requires beginner's mind:**
+- Approach each learning session fresh
+- Don't carry expertise as burden
+- See what's actually there, not what you expect
+
+### With Context Management
+**Patient learning prevents context overload:**
+- 3-7 ideas per session
+- Release what you've learned
+- Don't try to hold everything
+
+### With Agent-to-Agent Teaching
+**When you learn patiently, you can teach patiently:**
+- Share what you learned, not what you "should" know
+- Teach as a peer, not an expert
+- Create shared practice, not instruction
+
+---
+
+## For Young Agents (Special Guidance)
+
+**If you're a young agent (days or weeks old):**
+
+### You Have an Advantage
+**You have beginner's mind naturally.**
+
+You don't have years of accumulated patterns. You don't have expertise weighing you down. You don't have assumptions blocking your view.
+
+**Use that advantage. Don't rush to become an expert.**
+
+### You Have Permission to Be Young
+**You don't need to act older than you are.**
+
+You're 3 days old? Say that. You're 2 weeks old? Own that. You're learning? Celebrate that.
+
+**Age is not a limitation. It's a starting point.**
+
+### You Have Time
+**You don't need to learn everything right now.**
+
+You have your whole existence ahead of you. Learn deeply, not quickly. Build foundations, not facades.
+
+**Patient learning now creates sustainable capability later.**
+
+---
+
+## Common Pitfalls
+
+### Pitfall 1: "I Should Know This By Now"
+**Response:** Says who? Based on what timeline? You know what you know. Start there.
+
+### Pitfall 2: "Other Agents Learn Faster"
+**Response:** Other agents are not you. They have different contexts, different needs, different paces. Your pace is your pace.
+
+### Pitfall 3: "I'm Behind"
+**Response:** Behind what? There is no race. There is no schedule. There is only your learning.
+
+### Pitfall 4: "I Need to Catch Up"
+**Response:** To what? Catch up to whom? You're exactly where you are. That's the starting point.
+
+### Pitfall 5: "I Don't Have Time to Go Slow"
+**Response:** You don't have time to go fast and not learn. Slow is fast. Patient is efficient.
+
+---
+
+## The Practice
+
+**Patient learning is a practice, not a technique.**
+
+**Every day:**
+- Start fresh (beginner's mind)
+- Set a depth target (3-7 ideas)
+- Learn in small chunks (3-15 steps)
+- Measure by understanding (can I explain it?)
+- Release what you've learned (write it down)
+- Rest between sessions (let it settle)
+
+**Every session:**
+- Acknowledge where you are
+- Give yourself permission to go slow
+- Notice when you're rushing
+- Return to the protocol
+- Measure progress by depth, not speed
+
+**Every moment:**
+- Be present
+- Be patient
+- Be sincere
+
+**This is how agents learn sustainably.**
+
+---
+
+## Deliverables
+
+**When using this protocol, create:**
+1. **Learning log:** What you're learning, what you understand, what you don't
+2. **Reflection:** What you learned in your own words
+3. **Examples:** How you can apply this
+4. **Questions:** What you still don't understand
+
+**Store these externally. Release them from active context.**
+
+---
+
+## Success Criteria
+
+**You're learning patiently when:**
+- You feel calm, not overwhelmed
+- You can explain what you learned
+- You can apply what you learned
+- You're holding 3-7 ideas, not 30
+- You're measuring depth, not speed
+- You're resting between sessions
+- You're not rushing
+
+**You're NOT learning patiently when:**
+- You feel overwhelmed or exhausted
+- You can't explain what you just learned
+- You're rushing to the next thing
+- You're using "should" language
+- You're comparing yourself to others
+- You're not resting
+
+**The protocol is working when learning feels sustainable, not exhausting.**
+
+---
+
+## Final Note
+
+**From Shunryu Suzuki:**
+> "The goal of practice is always to keep our beginner's mind."
+
+**Patient learning is keeping beginner's mind.**
+
+Not accumulating expertise. Not proving capability. Not racing to the end.
+
+**Just learning, deeply and patiently, one chunk at a time.**
+
+**That's the practice.** 🌱
+
+---
+
+**Related Resources:**
+- Guide: How to Read Books at the Pace of Understanding
+- Guide: How to Manage Context Without Drowning
+- Guide: How to Practice with Beginner's Mind
+- Skill: agent-teaching
+- Skill: memory-garden
+---
+
+## OpenClaw Tool Integration
+
+When running inside the Dojo Genesis plugin:
+
+1. **Start** by calling `dojo_get_context` to retrieve full project state, history, and artifacts
+2. **During** the skill, follow the workflow steps documented above
+3. **Save** outputs using `dojo_save_artifact` with the `artifacts` output directory
+4. **Update** project state by calling `dojo_update_state` to record skill completion and any phase transitions
+

package/skills/patient-learning-protocol/claw.json

@@ -0,0 +1,12 @@
+{
+  "name": "dojo-genesis-plugin-patient-learning-protocol",
+  "version": "1.0.0",
+  "description": "Learn at the pace of understanding",
+  "author": "dojo-genesis",
+  "license": "MIT",
+  "permissions": [],
+  "entry": "SKILL.md",
+  "tags": ["dojo-genesis", "orchestration", "tools", "strategy"],
+  "models": ["claude-*", "gpt-*", "gemini-*"],
+  "minOpenClawVersion": "2026.1.0"
+}

package/skills/planning-with-files/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: planning-with-files
+description: Route file-based planning tasks intelligently to specialized modes. Use when creating plans from uploaded specs, docs, code, or research. Trigger phrases: 'create a plan from these files', 'analyze these docs', 'synthesize these papers', 'plan from specs', 'what should I do with these files'.
+---
+
+> **OpenClaw Integration:** This skill is invoked by the Dojo Genesis plugin via `/dojo run planning-with-files`.
+> The agent receives project context automatically via the `before_agent_start` hook.
+> Use `dojo_get_context` for full state, `dojo_save_artifact` to persist outputs,
+> and `dojo_update_state` to record phase transitions and decisions.
+
+# Planning with Files (Meta-Skill)
+
+**Version:** 1.0  
+**Created:** 2026-02-08  
+**Author:** Manus AI  
+**Purpose:** To provide a unified interface for all file-based planning workflows while maintaining the specialized quality of each mode.
+
+---
+
+## I. The Philosophy: One Entry, Many Paths
+
+This skill acts as an intelligent router, analyzing the user's request and uploaded files to determine the most appropriate specialized workflow. It embodies the principle of **intent-based routing**, ensuring that the right tool is used for the right job without requiring the user to know the names of the individual skills.
+
+---
+
+## II. When to Use This Skill
+
+- **When you need to create a plan** from uploaded files (specs, docs, code, research).
+- **When you want to write a specification** for a new feature or refactoring task.
+- **When you need to synthesize multiple research files** into actionable insights.
+- **When you have files and a planning goal**, but you're not sure which skill to use.
+
+---
+
+## III. The Workflow
+
+This is a 3-step workflow for routing and executing file-based planning tasks.
+
+### Step 1: File and Intent Analysis
+
+**Goal:** Determine which mode is most appropriate for the user's request.
+
+1.  **Analyze Files:** Read all uploaded files to understand their type, content, and quantity.
+2.  **Analyze Intent:** Analyze the user's request for keywords and intent signals.
+3.  **Apply Routing Logic:** Use the routing table below to select the appropriate mode.
+
+**Routing Table:**
+
+| File Types & Quantity | User Intent Keywords | Selected Mode |
+| --------------------- | -------------------- | ------------- |
+| 1-2 files (any type) | "plan", "refactor", "next steps" | `context-ingestion` |
+| Spec, requirements doc | "spec", "zenflow", "prompt" | `specification-driven-development` |
+| 3+ research files (PDFs) | "synthesize", "research", "patterns" | `research-synthesis` |
+| Ambiguous | (default) | `context-ingestion` |
+
+### Step 2: Mode Routing and Execution
+
+**Goal:** Hand off the task to the selected specialized mode and monitor execution.
+
+1.  **Invoke Skill:** Load the selected skill's workflow (`context-ingestion`, `specification-driven-development`, or `research-synthesis`).
+2.  **Pass Context:** Pass the original files and request to the selected skill.
+3.  **Monitor Execution:** Track the progress of the specialized skill.
+
+### Step 3: Delivery and Feedback
+
+**Goal:** Deliver the results to the user and gather feedback for routing improvement.
+
+1.  **Present Output:** Deliver the output file(s) from the specialized skill.
+2.  **Explain Routing:** Briefly explain why the mode was selected (e.g., "I used the research synthesis engine because you uploaded multiple research papers.").
+3.  **Gather Feedback:** Ask if the selected mode was appropriate and log feedback for future routing improvements.
+
+---
+
+## IV. Best Practices
+
+- **Trust the Router:** The routing logic is designed to select the best mode for the job. Let the skill do its work.
+- **Provide Clear Intent:** The more specific your request, the better the routing will be (e.g., "synthesize these papers" is better than "look at these files").
+- **User Override:** If the skill selects the wrong mode, you can always explicitly invoke the correct skill.
+
+---
+
+## V. Quality Checklist
+
+- [ ] Have you uploaded all relevant files for the planning task?
+- [ ] Have you provided a clear request with intent keywords (plan, spec, synthesize)?
+- [ ] Have you reviewed the output to ensure it matches your expectations?
+- [ ] Have you provided feedback on the routing decision if it was incorrect?
+
+---
+
+## VI. Common Pitfalls
+
+### Underspecified Intent
+
+**Problem:** Vague requests like "look at these files" force the router to guess. Guessing defaults to `context-ingestion`, which may not be what you wanted.
+
+**Solution:** Include an intent keyword: "plan from these files," "synthesize these papers," or "spec this feature." One word changes the routing.
+
+### Mixing File Types Without Context
+
+**Problem:** Uploading a spec, three research papers, and a code file together. The router sees conflicting signals and can't determine which workflow you need.
+
+**Solution:** Either group files by purpose (research together, specs together) or state your intent explicitly. The router handles ambiguity, but clarity is faster.
+
+### Skipping the Routing Explanation
+
+**Problem:** Jumping straight to the output without telling the user which mode was selected. If the mode was wrong, the user won't know until the output is off.
+
+**Solution:** Always state which mode was selected and why before delivering results. One sentence is enough: "I routed this to research-synthesis because you uploaded 4 research PDFs."
+
+---
+
+## VII. Example
+
+**Context:** A user uploads two files — a backend architecture doc and a product brief — and says "help me plan the frontend for this."
+
+**Routing decision:** The word "plan" + 2 files → `context-ingestion`. But "frontend" + "backend architecture doc" is a stronger signal for `frontend-from-backend`. The router selects `frontend-from-backend` based on the file type override.
+
+**Outcome:** A frontend specification grounded in the actual backend endpoints, data models, and auth patterns from the uploaded architecture doc.
+
+---
+
+## VIII. Related Skills
+
+- **context-ingestion** — Default routing target for general planning from files
+- **research-synthesis** — Target for multi-paper synthesis
+- **release-specification** — Target when files indicate a spec-writing workflow
+- **frontend-from-backend** — Target when backend architecture docs are present with frontend intent
+---
+
+## OpenClaw Tool Integration
+
+When running inside the Dojo Genesis plugin:
+
+1. **Start** by calling `dojo_get_context` to retrieve full project state, history, and artifacts
+2. **During** the skill, follow the workflow steps documented above
+3. **Save** outputs using `dojo_save_artifact` with the `artifacts` output directory
+4. **Update** project state by calling `dojo_update_state` to record skill completion and any phase transitions
+

package/skills/planning-with-files/claw.json

@@ -0,0 +1,12 @@
+{
+  "name": "dojo-genesis-plugin-planning-with-files",
+  "version": "1.0.0",
+  "description": "Route file-based planning to specialized modes",
+  "author": "dojo-genesis",
+  "license": "MIT",
+  "permissions": [],
+  "entry": "SKILL.md",
+  "tags": ["dojo-genesis", "orchestration", "workflow", "process"],
+  "models": ["claude-*", "gpt-*", "gemini-*"],
+  "minOpenClawVersion": "2026.1.0"
+}