@trespies-source/dojo-genesis-plugin 1.0.0

package/skills/seed-library/scripts/apply_seed.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3.11
+"""
+apply_seed.py - Load and explain how to apply a seed
+Usage: python3.11 apply_seed.py <seed_id>
+Example: python3.11 apply_seed.py 04_agent_connect
+"""
+
+import sys
+import json
+from pathlib import Path
+from datetime import datetime
+
+SEEDS_DIR = Path(__file__).parent.parent / "seeds"
+USAGE_FILE = Path.home() / ".seed-usage.json"
+
+def load_usage_state():
+    """Load usage state from JSON file"""
+    if not USAGE_FILE.exists():
+        return {
+            "seeds": {},
+            "session_seeds": {}
+        }
+    
+    with open(USAGE_FILE) as f:
+        return json.load(f)
+
+def save_usage_state(state):
+    """Save usage state to JSON file"""
+    with open(USAGE_FILE, 'w') as f:
+        json.dump(state, f, indent=2)
+
+def track_seed_usage(seed_id, session_id=None):
+    """Track seed usage"""
+    state = load_usage_state()
+    
+    if seed_id not in state["seeds"]:
+        state["seeds"][seed_id] = {
+            "usage_count": 0,
+            "last_used": None,
+            "sessions": []
+        }
+    
+    state["seeds"][seed_id]["usage_count"] += 1
+    state["seeds"][seed_id]["last_used"] = datetime.now().isoformat()
+    
+    if session_id:
+        if session_id not in state["seeds"][seed_id]["sessions"]:
+            state["seeds"][seed_id]["sessions"].append(session_id)
+        
+        if session_id not in state["session_seeds"]:
+            state["session_seeds"][session_id] = []
+        
+        if seed_id not in state["session_seeds"][session_id]:
+            state["session_seeds"][session_id].append(seed_id)
+    
+    save_usage_state(state)
+
+def apply_seed(seed_id, session_id=None):
+    """Load and display seed content"""
+    seed_file = SEEDS_DIR / f"{seed_id}.md"
+    
+    if not seed_file.exists():
+        print(f"❌ Seed not found: {seed_id}")
+        print(f"   Expected at: {seed_file}")
+        print("\nAvailable seeds:")
+        for f in sorted(SEEDS_DIR.glob("*.md")):
+            print(f"  - {f.stem}")
+        sys.exit(1)
+    
+    # Track usage
+    track_seed_usage(seed_id, session_id)
+    
+    # Load content
+    content = seed_file.read_text()
+    
+    # Generate application guide
+    guide = f"""
+# Applying Seed: {seed_id}
+
+---
+
+{content}
+
+---
+
+## Application Checklist
+
+Review the "Checks" section in the seed above and validate each one.
+
+## Next Steps
+
+1. **Review the pattern** - Understand the core pattern and why it matters
+2. **Check the trigger** - Confirm this seed is relevant to your current task
+3. **Apply the pattern** - Follow the "Dojo Application" section
+4. **Validate with checks** - Ensure all checks pass
+5. **Note what it refuses** - Avoid the anti-patterns
+
+## Track Effectiveness
+
+After applying this seed, rate its effectiveness:
+```bash
+python3.11 track_usage.py {seed_id} <session_id> <helpful|not_helpful>
+```
+
+"""
+    
+    return guide
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python3.11 apply_seed.py <seed_id> [session_id]")
+        print("Example: python3.11 apply_seed.py 04_agent_connect session_123")
+        sys.exit(1)
+    
+    seed_id = sys.argv[1]
+    session_id = sys.argv[2] if len(sys.argv) > 2 else None
+    
+    print(f"📖 Loading seed: {seed_id}")
+    
+    guide = apply_seed(seed_id, session_id)
+    print(guide)
+    
+    # Save to file
+    output_file = Path.home() / f"seed-{seed_id}-applied.md"
+    output_file.write_text(guide)
+    print(f"\n✅ Application guide saved to: {output_file}")
+
+if __name__ == "__main__":
+    main()

package/skills/seed-library/scripts/suggest_seeds.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3.11
+"""
+suggest_seeds.py - Suggest relevant seeds based on task context
+Usage: python3.11 suggest_seeds.py <keywords...>
+Example: python3.11 suggest_seeds.py multi-agent architecture coordination
+"""
+
+import sys
+import json
+from pathlib import Path
+from datetime import datetime
+
+SEEDS_DIR = Path(__file__).parent.parent / "seeds"
+
+# Seed trigger keywords (extracted from seed definitions)
+SEED_TRIGGERS = {
+    "01_three_tiered_governance": [
+        "governance", "capabilities", "complexity", "multi-agent", "coordination",
+        "policy", "standards", "rules", "framework"
+    ],
+    "02_harness_trace": [
+        "debugging", "trace", "transparency", "performance", "evaluation",
+        "logging", "monitoring", "inspect"
+    ],
+    "03_context_iceberg": [
+        "token", "cost", "context", "window", "limit", "budget", "pruning",
+        "memory", "overhead"
+    ],
+    "04_agent_connect": [
+        "multi-agent", "routing", "coordination", "specialized", "handoff",
+        "permission", "swarm", "orchestration"
+    ],
+    "05_go_live_bundles": [
+        "export", "sharing", "reuse", "artifact", "package", "bundle",
+        "repeatability", "trust"
+    ],
+    "06_cost_guard": [
+        "cost", "budget", "estimation", "planning", "infrastructure",
+        "investment", "pricing"
+    ],
+    "07_safety_switch": [
+        "fallback", "conservative", "alert", "drift", "failure", "recovery",
+        "validation", "error"
+    ],
+    "08_implicit_perspective_extraction": [
+        "perspective", "constraint", "metaphor", "scope", "extraction",
+        "implicit", "natural"
+    ],
+    "09_mode_based_complexity_gating": [
+        "mode", "complexity", "routing", "simple", "query", "reasoning",
+        "adaptive"
+    ],
+    "10_shared_infrastructure": [
+        "infrastructure", "reuse", "duplication", "foundation", "shared",
+        "common", "service"
+    ],
+    "11_voice_before_structure": [
+        "voice", "philosophy", "design-language", "manifest", "description",
+        "readme", "ecosystem", "identity", "grounding", "plugin"
+    ],
+    "12_pointer_directories": [
+        "empty", "missing", "pointer", "provenance", "registry", "audit",
+        "gap", "coverage", "directory", "reference"
+    ],
+    "13_granular_visibility": [
+        "progress", "tracking", "visibility", "todo", "granular", "steering",
+        "transparency", "trust", "delegation", "status"
+    ]
+}
+
+def load_seed_metadata(seed_file):
+    """Load metadata from seed file"""
+    content = seed_file.read_text()
+    
+    # Extract frontmatter
+    if content.startswith('---'):
+        parts = content.split('---', 2)
+        if len(parts) >= 3:
+            frontmatter = parts[1].strip()
+            metadata = {}
+            for line in frontmatter.split('\n'):
+                if ':' in line:
+                    key, value = line.split(':', 1)
+                    metadata[key.strip()] = value.strip()
+            return metadata
+    
+    return {}
+
+def calculate_relevance(keywords, seed_id):
+    """Calculate relevance score for a seed based on keywords"""
+    triggers = SEED_TRIGGERS.get(seed_id, [])
+    keywords_lower = [k.lower() for k in keywords]
+    
+    score = 0
+    for keyword in keywords_lower:
+        for trigger in triggers:
+            if keyword in trigger or trigger in keyword:
+                score += 1
+    
+    return score
+
+def suggest_seeds(keywords, top_n=3):
+    """Suggest top N relevant seeds based on keywords"""
+    suggestions = []
+    
+    for seed_id, triggers in SEED_TRIGGERS.items():
+        score = calculate_relevance(keywords, seed_id)
+        if score > 0:
+            seed_file = SEEDS_DIR / f"{seed_id}.md"
+            if seed_file.exists():
+                metadata = load_seed_metadata(seed_file)
+                suggestions.append({
+                    'seed_id': seed_id,
+                    'name': metadata.get('name', seed_id),
+                    'score': score,
+                    'file': str(seed_file)
+                })
+    
+    # Sort by score descending
+    suggestions.sort(key=lambda x: x['score'], reverse=True)
+    
+    return suggestions[:top_n]
+
+def generate_markdown_output(keywords, suggestions):
+    """Generate markdown output"""
+    md = f"""# Seed Suggestions
+
+**Keywords:** {', '.join(keywords)}
+**Generated:** {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+
+"""
+    
+    if suggestions:
+        md += "## Recommended Seeds\n\n"
+        for i, suggestion in enumerate(suggestions, 1):
+            md += f"### {i}. {suggestion['name']} (Seed {suggestion['seed_id'][:2]})\n\n"
+            md += f"- **Relevance Score:** {suggestion['score']}\n"
+            md += f"- **File:** `{suggestion['file']}`\n\n"
+            
+            # Read first few lines of seed for preview
+            seed_file = Path(suggestion['file'])
+            if seed_file.exists():
+                content = seed_file.read_text()
+                # Find "What It Is" section
+                if "## What It Is" in content:
+                    what_it_is = content.split("## What It Is")[1].split("##")[0].strip()
+                    md += f"**What It Is:** {what_it_is[:200]}...\n\n"
+        
+        md += "\n## How to Apply\n\n"
+        md += "To apply a seed, run:\n"
+        md += "```bash\n"
+        md += "python3.11 apply_seed.py <seed_id>\n"
+        md += "```\n"
+    else:
+        md += "No relevant seeds found for these keywords.\n\n"
+        md += "**Available seeds:**\n"
+        for seed_id in SEED_TRIGGERS.keys():
+            md += f"- {seed_id}\n"
+    
+    return md
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python3.11 suggest_seeds.py <keywords...>")
+        print("Example: python3.11 suggest_seeds.py multi-agent architecture coordination")
+        sys.exit(1)
+    
+    keywords = sys.argv[1:]
+    
+    print(f"🔍 Suggesting seeds for: {', '.join(keywords)}")
+    
+    suggestions = suggest_seeds(keywords)
+    output = generate_markdown_output(keywords, suggestions)
+    
+    print(output)
+    
+    # Save to file
+    output_file = Path.home() / "seed-suggestions.md"
+    output_file.write_text(output)
+    print(f"\n✅ Suggestions saved to: {output_file}")
+
+if __name__ == "__main__":
+    main()

package/skills/seed-library/seeds/01_three_tiered_governance.md

@@ -0,0 +1,90 @@
+---
+seed_id: 01
+name: Three-Tiered Governance
+version: 1.0
+created: 2026-01-12
+source: Dataiku Research
+status: active
+---
+
+# Three-Tiered Governance
+
+## What It Is
+
+A governance framework that operates at three distinct but connected layers: Strategic, Tactical, and Operational.
+
+## Why It Matters
+
+Single-layer governance either slows teams to a crawl or misses critical context. Two layers leave gaps in accountability while four add drag without extra clarity.
+
+## The Pattern
+
+### Strategic (Tier 1)
+- Define risk appetite
+- Decide which use cases move forward
+- Ensure alignment with global regulations
+- Set organizational policy
+
+### Tactical (Tier 2)
+- Translate rules into repeatable standards
+- Allocate resources
+- Track portfolio health
+- Create project templates
+
+### Operational (Tier 3)
+- Give engineers local instruments to ship safely
+- Version control, tests, traces, monitoring
+- Day-to-day execution tools
+- Real-time feedback loops
+
+## Revisit Trigger
+
+When adding new Dojo capabilities, governance complexity, or multi-agent coordination.
+
+## Dojo Application
+
+### Strategic Layer
+- **Dojo Principles:** No autopilot, no gamification, artifact-first
+- **Brand Promises:** Beginner's mind, self-definition, understanding is love
+- **Risk Appetite:** What Dojo refuses to do
+
+### Tactical Layer
+- **DojoPacket Schema:** Standardized export format
+- **Seed Modules:** Reusable thinking patterns
+- **Mode Routing:** Mirror/Scout/Gardener/Implementation
+- **Harness Trace Format:** Nested spans + events
+
+### Operational Layer
+- **Versioning:** Track seed versions, DojoPacket versions
+- **Tests:** Validate perspective extraction, mode selection
+- **Trace Logs:** Record every decision
+- **Read-Before-Decide Loops:** Context-aware decision making
+
+## What It Refuses
+
+Single-layer governance that tries to watch everything from one altitude.
+
+## Usage Examples
+
+### Example 1: Adding New Agent
+**Strategic:** Does this agent align with "no autopilot" principle?
+**Tactical:** What's the routing logic? What's the API contract?
+**Operational:** How do we test it? How do we trace its decisions?
+
+### Example 2: New Feature Request
+**Strategic:** Does this fit our risk appetite?
+**Tactical:** What seed modules apply? What's the DojoPacket schema change?
+**Operational:** What tests do we need? What monitoring?
+
+## Checks
+
+- [ ] Strategic principles are clearly defined and documented
+- [ ] Tactical standards are repeatable and versioned
+- [ ] Operational instruments are available to builders
+- [ ] All three tiers are connected (not siloed)
+- [ ] Governance accelerates delivery (not slows it)
+
+## Related Seeds
+
+- **Seed 10 (Shared Infrastructure):** Operational tier benefits from shared services
+- **Meta-Seed (Governance Multiplies Velocity):** Strategic clarity accelerates delivery

package/skills/seed-library/seeds/02_harness_trace.md

@@ -0,0 +1,135 @@
+---
+seed_id: 02
+name: Harness Trace
+version: 1.0
+created: 2026-01-12
+source: Dataiku Research
+status: active
+---
+
+# Harness Trace (Nested Spans + Events)
+
+## What It Is
+
+A complete tracing system that records the entire trace of what an agent does, even through multiple layers of calling LLMs, as a nested JSON object.
+
+## Why It Matters
+
+"Traceability breaks at every hop" when decision chains multiply. You can't evaluate what you don't understand. Transparency builds trust.
+
+## The Pattern
+
+### Spans
+- Have start/end time
+- Have children spans (nesting)
+- Have name, inputs, outputs
+- Have attributes (metadata)
+
+### Events
+- Points in time with timestamp
+- Have name, inputs, outputs
+- Have attributes (metadata)
+
+### Nesting
+Represents the lifeline of the query as it goes through various systems.
+
+### Three Views
+- **Tree:** Structure and hierarchy
+- **Timeline:** Performance and duration
+- **Explorer:** Detailed analysis
+
+## Revisit Trigger
+
+When debugging unexpected behavior, evaluating performance, or building trust through transparency.
+
+## Dojo Application
+
+```json
+{
+  "trace_id": "dojo_session_12345",
+  "spans": [
+    {
+      "span_id": "perspective_capture",
+      "name": "Perspective Capture",
+      "start_time": "2026-01-29T10:00:00Z",
+      "end_time": "2026-01-29T10:00:05Z",
+      "inputs": {"user_query": "How should we architect..."},
+      "outputs": {"perspectives": ["P1", "P2", "P3"]},
+      "metadata": {"perspective_count": 3}
+    },
+    {
+      "span_id": "mode_selection",
+      "name": "Mode Selection",
+      "start_time": "2026-01-29T10:00:05Z",
+      "end_time": "2026-01-29T10:00:07Z",
+      "inputs": {"perspectives": ["P1", "P2", "P3"]},
+      "outputs": {"mode": "Scout"},
+      "metadata": {"reasoning": "Complex query requires route exploration"}
+    },
+    {
+      "span_id": "scout_execution",
+      "name": "Scout Mode Execution",
+      "start_time": "2026-01-29T10:00:07Z",
+      "end_time": "2026-01-29T10:00:30Z",
+      "children": [
+        {
+          "span_id": "route_1_analysis",
+          "name": "Route 1: Centralized Architecture",
+          "inputs": {},
+          "outputs": {"tradeoffs": "..."}
+        },
+        {
+          "span_id": "route_2_analysis",
+          "name": "Route 2: Distributed Architecture",
+          "inputs": {},
+          "outputs": {"tradeoffs": "..."}
+        }
+      ]
+    },
+    {
+      "span_id": "artifact_generation",
+      "name": "Artifact Generation",
+      "start_time": "2026-01-29T10:00:30Z",
+      "end_time": "2026-01-29T10:00:35Z",
+      "outputs": {"artifact": "architecture_comparison.md"}
+    }
+  ],
+  "usage_metadata": {
+    "total_tokens": 4523,
+    "estimated_cost": 0.0234
+  }
+}
+```
+
+## What It Refuses
+
+Opaque decision-making where users can't see how Dojo arrived at recommendations.
+
+## Usage Examples
+
+### Example 1: Debugging Mode Selection
+**Problem:** Why did Dojo choose Scout instead of Mirror?
+**Solution:** Check `mode_selection` span in trace, read `metadata.reasoning`
+
+### Example 2: Performance Optimization
+**Problem:** Session feels slow
+**Solution:** View Timeline, identify longest spans, optimize bottlenecks
+
+### Example 3: Trust Building
+**Problem:** User doesn't understand recommendation
+**Solution:** Share Tree view, show decision path from query to artifact
+
+## Checks
+
+- [ ] Every significant decision is logged as a span
+- [ ] Spans have start/end times for performance analysis
+- [ ] Nesting represents actual decision hierarchy
+- [ ] Metadata includes reasoning for key decisions
+- [ ] Trace is exportable and inspectable
+- [ ] Users can view trace in Tree, Timeline, and Explorer views
+
+## Related Seeds
+
+- **Seed 01 (Three-Tiered Governance):** Tactical tier defines trace format
+- **Seed 05 (Go-Live Bundles):** Traces are part of DojoPacket exports
+- **Meta-Seed (Governance Multiplies Velocity):** Traces build trust, accelerate delivery

package/skills/seed-library/seeds/03_context_iceberg.md

@@ -0,0 +1,120 @@
+---
+seed_id: 03
+name: Context Iceberg
+version: 1.0
+created: 2026-01-12
+source: Dataiku Research
+status: active
+---
+
+# Context Iceberg (6x Token Multiplier)
+
+## What It Is
+
+The hidden cost structure where production responses use 6x more tokens than demo responses due to conversation history, validation, error handling, and trace logging.
+
+## Why It Matters
+
+"Context re-feed is the big tax." Juggling multiple projects requires constant restatement of "what matters right now." Naive token budgeting assumes demo = production costs, leading to 5x cost overruns.
+
+## The Pattern
+
+### Demo Usage
+- **Input:** 50 tokens (clean query)
+- **Output:** 150 tokens (simple response)
+- **Total:** 200 tokens
+
+### Production Usage
+- **Conversation History:** 400 tokens
+- **User Profiles:** 100 tokens
+- **System State:** 200 tokens
+- **Validation:** 100 tokens
+- **Error Handling:** 200 tokens
+- **Trace Logging:** 200 tokens
+- **Total:** 1,200 tokens (6x multiplier)
+
+### Cost Model Error
+If you budget for demo usage, you'll be 5x off in production.
+
+## Revisit Trigger
+
+When token usage spikes, costs exceed budget, or context window approaches limit.
+
+## Dojo Application
+
+### Hierarchical Context Loading
+
+**Tier 1 (Always On):**
+- Core system prompt
+- Dojo principles
+- Current user query
+
+**Tier 2 (On Demand):**
+- Active seed patches
+- Relevant project memory
+- Current session context
+
+**Tier 3 (When Referenced):**
+- Full text of specific files
+- Previous session logs
+- Detailed documentation
+
+**Tier 4 (Pruned Aggressively):**
+- General conversation history
+- Less relevant details
+- Archived context
+
+### Context Pruning Triggers
+
+- **80% capacity:** Prune Tier 4 (general history)
+- **90% capacity:** Prune Tier 3 (referenced files)
+- **95% capacity:** Alert user, suggest export and new session
+
+### Shared Context Bus
+
+Central store for:
+- Project spines (core project info)
+- Seed modules (reusable patterns)
+- Contracts (API schemas, DojoPacket format)
+
+### Implicit Perspective Extraction
+
+Treat constraints and metaphors as perspectives to reduce overhead:
+- "no autopilot" → perspective about autonomy
+- "artifact-first" → perspective about output format
+
+## What It Refuses
+
+Naive token budgeting that assumes demo = production costs.
+
+## Usage Examples
+
+### Example 1: Simple Query
+**Query:** "What's the DojoPacket schema?"
+**Context:** Tier 1 + Tier 2 (schema from Shared Context Bus)
+**Tokens:** ~500 (minimal overhead)
+
+### Example 2: Complex Query
+**Query:** "How should we architect the multi-agent system?"
+**Context:** Tier 1 + Tier 2 + Tier 3 (seed modules, project docs, previous architecture discussions)
+**Tokens:** ~2,000 (full context)
+
+### Example 3: Context Approaching Limit
+**Scenario:** 90% capacity reached
+**Action:** Prune Tier 3, alert user
+**Message:** "Context window at 90%. Consider exporting this session and starting fresh."
+
+## Checks
+
+- [ ] Hierarchical context tiers are defined
+- [ ] Pruning triggers are implemented
+- [ ] Shared Context Bus exists for reusable artifacts
+- [ ] Token usage is monitored per session
+- [ ] Users are alerted before hitting limits
+- [ ] Budget accounts for 6x multiplier (not demo costs)
+
+## Related Seeds
+
+- **Seed 06 (Cost Guard):** Budget for the full iceberg, not just API bills
+- **Seed 07 (Safety Switch):** Context drift triggers fallback mode
+- **Seed 09 (Mode-Based Complexity Gating):** Match context loading to complexity