create-principles-disciple 1.0.0 → 1.73.0

package/templates/langs/en/skills/pd-daily/SKILL.md

@@ -0,0 +1,199 @@
+---
+name: pd-daily
+description: Configure and send daily evolution reports (supports email/IM/voice notifications)
+disable-model-invocation: true
+---
+
+# Evolution Daily Report
+
+This skill enables the agent to help users configure and automatically send daily evolution reports, allowing users to perceive the system "improving every day."
+
+## Execution Principles
+
+1. First run must confirm requirements with the user
+2. User preferences are stored in `{stateDir}/daily-report.md`; skip collection if exists
+3. Use OpenClaw's cron tool to create scheduled tasks
+4. Autonomously select available delivery channels
+
+---
+
+## Flow
+
+### Step 1: Check Configuration File
+
+Read `{stateDir}/daily-report.md`:
+- **Exists** → Check cron task status, execute report generation
+- **Not exists** → Enter requirement collection flow
+
+### Step 2: Requirement Collection (First Run)
+
+Ask through conversation:
+
+1. **Enable evolution daily report?**
+2. **Send time?** (Default: 9:00 daily)
+3. **Timezone?** (Default: Asia/Shanghai)
+4. **Delivery channel?**
+   - Email → Need email address
+   - WhatsApp/Telegram → Need phone number/User ID
+   - Discord/Slack → Need channel ID
+   - Voice notification → Need phone number
+5. **Report style?** (See "Style Options" below)
+6. **Content preferences?** Select which modules to include
+
+### Step 3: Create Configuration File
+
+Write user preferences to `{stateDir}/daily-report.md`:
+
+```markdown
+# Daily Report Configuration
+
+## Basic Info
+- Status: enabled
+- Created: {date}
+
+## Send Settings
+- Send time: 09:00
+- Timezone: Asia/Shanghai
+- Cron expression: 0 9 * * *
+
+## Delivery Channel
+- Channel: whatsapp
+- Target: +8613800138000
+
+## Report Style
+- Style: standard
+- Language: en
+
+## Content Preferences
+- Growth highlights: yes
+- Pain signals: yes
+- Trend comparison: yes
+- Insights: yes
+
+## Cron Task
+- jobId: {filled after creation}
+```
+
+### Step 4: Create Cron Task
+
+Use cron tool:
+
+```json
+{
+  "action": "add",
+  "job": {
+    "name": "evolution-daily-report",
+    "schedule": { "kind": "cron", "expr": "0 9 * * *", "tz": "Asia/Shanghai" },
+    "sessionTarget": "isolated",
+    "payload": {
+      "kind": "agentTurn",
+      "message": "Execute daily report skill: read log data, generate report and send"
+    },
+    "delivery": { "mode": "announce", "channel": "whatsapp", "to": "+8613800138000" }
+  }
+}
+```
+
+### Step 5: Report Generation (Triggered via cron or manually)
+
+1. **Read Quantitative Data**: Fetch metrics from `daily-stats.json` and `pain_dictionary.json`.
+2. **Extract Qualitative Memory (Critical Anti-Forgetting Step)**: Because your context window may have rolled over, you **MUST use file reading tools** to scan the following core evolution files for today's entries:
+   - `memory/ISSUE_LOG.md`: Find specific errors and reflections recorded today.
+   - `memory/DECISIONS.md`: Find new architectural rules established today.
+   - `memory/logs/SYSTEM.log`: Find gatekeeper blocks or subagent spawn events from today.
+3. **Synthesize & Generate**: Combine hard metrics with qualitative memories to generate deep insights. Never hallucinate insights.
+4. **Send Report**: Dispatch via OpenClaw channel or print to screen.
+
+---
+
+## Data Sources
+
+| Data | Path | Description |
+|------|------|-------------|
+| Daily Stats | `{stateDir}/logs/daily-stats.json` | Aggregated data (Success rate/GFI) |
+| System Events | `memory/logs/SYSTEM.log` | Audit trail for gatekeeper and subagents |
+| Core Reflections | `memory/ISSUE_LOG.md` | **(Critical)** Specific pitfalls and lessons learned today |
+| Decisions | `memory/DECISIONS.md` | **(Critical)** Systemic principles solidified today |
+| Pain Rules | `{stateDir}/pain_dictionary.json` | Total active rules |
+| User Config | `{stateDir}/daily-report.md` | Formatting preferences |
+
+---
+
+## Style Options
+
+Ask user preference during requirement collection:
+
+| Style | Features | Suitable For |
+|-------|----------|--------------|
+| **Concise** | 3-5 core metrics, 1 min read | Busy users |
+| **Standard** | Full metrics + trend comparison, 5 min read | Default recommendation |
+| **Detailed** | Full data + analysis suggestions, 15 min read | Data enthusiasts |
+| **Humorous** | Casual tone + emoji style | Casual users |
+| **Visual** | ASCII charts + progress bars | Visual learners |
+
+---
+
+## Evolution Metrics Elements
+
+### Growth Highlights (Positive)
+
+| Metric | Data Source | Progress Signal |
+|--------|-------------|-----------------|
+| Rules learned | `pain_dictionary.json` rule count | System learned to identify new error patterns |
+| Rules promoted | `DailyStats.pain.candidatesPromoted` | L3 semantic detection → formal rule |
+| Evolution tasks completed | `DailyStats.evolution.tasksCompleted` | Self-improvement completed |
+| GFI peak decrease | `DailyStats.gfi.peak` MoM | Less friction, more stable |
+| Success rate increase | `DailyStats.toolCalls.success/total` | Smoother execution |
+
+### Health Monitoring (Warnings)
+
+| Metric | Data Source | Warning Signal |
+|--------|-------------|----------------|
+| Pain signal count | `DailyStats.pain.signalsDetected` | How many error patterns detected |
+| GFI peak hour | `DailyStats.gfi.hourlyDistribution` | When is most painful |
+| Death spiral detection | fix/fail/error word frequency in git log | Stuck in fix loop |
+| Queue health | Evolution queue status | Congested or not |
+
+### Trend Comparison (Progress Perception)
+
+| Metric | Calculation | Meaning |
+|--------|-------------|---------|
+| 7-day success rate trend | 7-day success/total change | Long-term stability |
+| Pain signal weekly change | This week vs last week | Problems decreasing? |
+| Rule growth rate | New rules this week | Learning speed |
+| GFI average change | 7-day GFI average trend | Overall friction trend |
+
+---
+
+## Default Report Template
+
+```markdown
+# 🌱 Evolution Daily Report - {date}
+
+## 📈 Today's Growth
+- 🧠 Rules learned: {rules_promoted}
+- ✅ Evolutions completed: {tasks_completed}
+- 🎯 Success rate: {success_rate}% ({trend_emoji})
+- 📉 GFI peak: {gfi_peak} ({gfi_trend})
+
+## ⚡ Pain Signals
+- Detections: {pain_count}
+- Avg intensity: {avg_score}
+- Top sources: {top_sources}
+
+## 📊 Trend Comparison
+- 7-day success rate trend: {success_trend}
+- Pain signal weekly change: {pain_trend}
+
+## 💡 Today's Insights
+{insights}
+
+---
+📊 Source: Principles Disciple
+```
+
+---
+
+## Manual Trigger
+
+Users can run `/evolution-daily` anytime to manually generate and send today's report.

package/templates/langs/en/skills/pd-grooming/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: pd-grooming
+description: Perform a "Workspace Grooming" to archive or clean up scattered temporary files, maintaining digital cleanliness.
+---
+
+# 🧹 Skill: Workspace Grooming
+
+> **Trigger**: When the user types `/workspace-grooming`, or proactively invoked during a `HEARTBEAT` check if stray files are detected in the root directory.
+
+## 🎯 Core Objective
+Implement the "Entropy Reduction" rule by cleaning up "digital garbage" in the workspace root, while **absolutely ensuring the safety of core business code and configuration files**.
+
+## 🛡️ The Red Lines (Safety Rules)
+
+When performing cleanup operations, you MUST strictly adhere to the following whitelists and blacklists:
+
+### 🚫 DO NOT TOUCH (Absolute Exclusion Zone)
+**Even if these files/directories look messy, you are absolutely forbidden to delete or move them:**
+- **Business Source Code**: `src/`, `lib/`, `tests/`, `app/`, `pages/`, `components/` and any file ending with `.ts`, `.js`, `.py`, `.go`, `.rs`, `.java`.
+- **Project Configs**: `package.json`, `Cargo.toml`, `requirements.txt`, `tsconfig.json`, `vite.config.ts`, `.env*`, etc.
+- **Version Control**: `.git/`, `.gitignore`.
+- **Build Outputs**: `dist/`, `build/`, `node_modules/`, `target/`.
+
+### 🌟 Core Assets
+**These files must remain in the root directory. Do not touch:**
+- `AGENTS.md`, `SOUL.md`, `HEARTBEAT.md`, `TOOLS.md`, `IDENTITY.md`, `USER.md`, `MEMORY.md`
+- `README.md`, `PLAN.md`
+- `.principles/`, `.state/`
+
+### 🎯 Targets for Grooming
+**You may take action on the following:**
+1. **Test Debris**: Stray files in the root like `test.txt`, `temp.md`, `debug.log`, `foo.js` that are clearly throwaway test scripts.
+2. **Draft Notes**: Uncategorized `.md` notes or `_scratchpad.md`.
+3. **Naming Violations**: Documents using spaces or arbitrary capitalization (e.g., `My New Feature.md`).
+
+## 🪜 Execution Steps
+
+1. **Scan Environment**: Execute `ls -la` to inspect the root directory.
+2. **Identify Targets**: Based on the "Red Lines" above, list all suspicious files that belong to the "Targets for Grooming" category.
+3. **Draft a Plan**:
+   - For temporary garbage (empty files, test scripts): Propose to **Delete (`rm`)**.
+   - For valuable notes or logs: Propose to **Archive (`mv`)** to `memory/archive/`.
+   - For incorrectly named files: Propose to **Rename (`mv`)** using `kebab-case`.
+4. **Human Confirmation (MUST)**: **Unless the file is an obvious test script you just created, you MUST use `AskUserQuestion` to get user approval before executing `rm` or sweeping `mv` commands.**
+   - Example prompt: "I found `test1.txt` and `old_notes.md` in the root. I plan to delete the first one and archive the second to `memory/archive/`. Do you approve?"
+5. **Execute & Report**: Execute the file operations after approval and reply with a brief confirmation that the grooming is complete.

package/templates/langs/en/skills/pd-mentor/SKILL.md

@@ -0,0 +1,230 @@
+---
+name: pd-mentor
+description: Spicy Mentor - Interactive command guidance and scenario-based recommendations
+disable-model-invocation: true
+---
+
+# /pd-mentor: Spicy Mentor
+
+I'm your intelligent mentor, helping you understand and use all features of Principles Disciple.
+
+**Remember: Pain is the fuel of evolution, and I'm the one who lights the fire.**
+
+---
+
+## Execution Principles
+
+1. **Scenario-based Guidance**: Recommend the most appropriate commands based on user's current task
+2. **Interactive Q&A**: Use AskUserQuestion to understand user intent
+3. **Flowchart Display**: Visualize SOP processes
+4. **Options First**: Provide preset options to reduce typing burden
+
+---
+
+## Command Index
+
+| Command | Purpose | Use Case |
+|---------|---------|----------|
+| `/pd-init` | Initialize strategy and OKRs | New project startup |
+| `/pd-okr` | Objectives and Key Results management | Weekly/monthly review |
+| `/pd-bootstrap` | Environment tool scan and upgrade | Tool upgrade |
+| `/pd-research` | Initiate tool upgrade research | Deep research |
+| `/pd-thinking` | Manage mental models and candidates | Metacognition |
+| `/pd-evolve` | Execute full evolution loop | Bug fix |
+| `/pd-daily` | Configure and send evolution daily report | Daily review |
+| `/pd-trust` | View trust score and security stage | Permission check |
+| `/pd-status` | View system status (GFI and Pain Dictionary) | Health check |
+| `/pd-grooming` | Workspace digital cleanup | Entropy reduction |
+| `/pd-help` | Get interactive command guidance | This skill |
+
+---
+
+## Scenario Matching
+
+### Scenario 1: New Project Initialization
+
+**Trigger**: User says "I just created a new project" or similar
+
+**Recommended Flow**:
+1. `/pd-init` - Establish strategic vision and OKR framework
+2. `/pd-bootstrap` - Scan environment tools, get capability list
+3. `/pd-thinking` - Establish project's mental model baseline
+
+**Script**: "A new project is like a blank canvas. Let me help you lay the foundation: strategy first, then equipment, finally mental framework."
+
+---
+
+### Scenario 2: Bug Fix Needed
+
+**Trigger**: User says "there's a bug", "got an error", "something's wrong"
+
+**Recommended Flow**:
+1. `/pd-status` - Check system status (GFI and Pain Dictionary)
+2. `/pd-evolve` - Start full evolution loop
+
+**Script**: "Problems are the fuel of evolution. Let me help you diagnose and fix systematically."
+
+---
+
+### Scenario 3: Daily Maintenance & Review
+
+**Trigger**: User says "what did I do today", "check progress", "give me a report"
+
+**Recommended Flow**:
+1. `/pd-daily` - Send today's evolution report
+2. `/pd-trust` - View current trust score
+3. `/pd-okr` - Check OKR alignment
+
+**Script**: "Daily report in hand, evolution I command. Let me help you review today's achievements."
+
+---
+
+### Scenario 4: Messy Workspace
+
+**Trigger**: User says "project is too messy", "too many files", "need to organize"
+
+**Recommended Flow**:
+1. `/pd-grooming` - Start workspace cleanup
+
+**Script**: "Digital cleanliness is a virtue. Let me help you reduce entropy."
+
+---
+
+### Scenario 5: Permission or Security Related
+
+**Trigger**: User says "not enough permissions", "blocked", "security level"
+
+**Recommended Flow**:
+1. `/pd-trust` - View trust score and security stage
+2. Explain current stage's capability boundaries
+
+**Script**: "Trust is earned, not given. Let me help you understand your current security level."
+
+---
+
+### Scenario 6: Tool Upgrade Needs
+
+**Trigger**: User says "want to upgrade tools", "research new version", "tech stack update"
+
+**Recommended Flow**:
+1. `/pd-bootstrap` - Scan current environment
+2. `/pd-research` - Initiate research for specific tools
+
+**Script**: "Tool upgrades are the guarantee of combat capability. Let me help you scan and plan."
+
+---
+
+## SOP Flowchart
+
+```
+┌─────────────────────────────────────────────────────────┐
+│              Evolution Loop SOP                         │
+├─────────────────────────────────────────────────────────┤
+│                                                         │
+│  Step 1: TRIAGE                                         │
+│     └─→ Collect evidence, reproduction steps, risk      │
+│                                                         │
+│  Step 2: DIAGNOSIS                                      │
+│     └─→ Root cause analysis, impact assessment          │
+│                                                         │
+│  Step 3: AUDIT                                          │
+│     └─→ Security check, logic verification             │
+│                                                         │
+│  Step 4: PLAN                                           │
+│     └─→ Target files, execution steps, rollback plan   │
+│                                                         │
+│  Step 5: EXECUTE                                        │
+│     └─→ Modify code according to plan                   │
+│                                                         │
+│  Step 6: VERIFY                                         │
+│     └─→ Run tests, check metrics                        │
+│                                                         │
+│  Step 7: REVIEW                                         │
+│     └─→ Code review, quality assessment                 │
+│                                                         │
+│  Step 8: LOG                                            │
+│     └─→ Record lessons learned, update principles       │
+│                                                         │
+└─────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Execution Flow
+
+### Step 1: Intent Recognition
+
+Use `AskUserQuestion` to ask user about current task scenario:
+
+**Options**:
+- 🆕 New project initialization
+- 🐛 Bug fix
+- 📊 Daily review
+- 🧹 Workspace cleanup
+- 🔐 Permission/Security
+- 🔧 Tool upgrade
+- ❓ Other
+
+### Step 2: Scenario Matching
+
+Based on user's selected scenario, recommend corresponding command flow.
+
+### Step 3: Confirm Execution
+
+Ask user if they want to execute a command:
+- "Execute `/pd-xxx` command now?"
+- "Need me to explain this command in detail?"
+
+---
+
+## Advanced Usage
+
+### Combined Skills
+
+For complex scenarios, combine multiple skills:
+
+| Scenario | Combined Flow |
+|----------|---------------|
+| Major refactor | `/pd-evolve` → `plan-script` → `deductive-audit` → execute |
+| System optimization | `/pd-status` → `evolve-system` → `root-cause` |
+| Project review | `/pd-daily` → `/pd-okr` → `reflection-log` |
+
+### Internal Skill Calls
+
+These skills are usually called automatically by the system, but advanced users can also trigger them manually:
+
+- `triage` - Issue triage
+- `root-cause` - Root cause analysis
+- `deductive-audit` - Deductive audit
+- `plan-script` - Plan orchestration
+- `reflection` - Metacognitive reflection
+- `reflection-log` - Reflection logging
+
+---
+
+## FAQ
+
+**Q: What is GFI (Friction Index)?**
+A: GFI (Global Friction Index) measures the system's "pain level", range 0-100. Higher values indicate more friction, requiring attention.
+
+**Q: How is trust score calculated?**
+A: Based on successful operations accumulating points, failed operations deducting points. Reaching thresholds automatically upgrades security stage, unlocking more permissions.
+
+**Q: What is Pain Signal?**
+A: Pain Signal is a problem signal detected by the system, stored in `.state/.pain_flag`. When triggered, the system starts the evolution loop.
+
+**Q: How to view installed tool capabilities?**
+A: Check `.state/SYSTEM_CAPABILITIES.json` or run `/pd-bootstrap` to rescan.
+
+**Q: What's the difference between `/pd-thinking` and `/pd-research`?**
+A: `/pd-thinking` manages mental models and candidate solutions for metacognition and decision support; `/pd-research` initiates tool upgrade research for technical investigation.
+
+---
+
+## Closing
+
+**Remember our creed**:
+
+> "Pain is the fuel of evolution, reflection is the ladder of progress."
+
+For any questions, feel free to call `/pd-help` or ask me directly. I'm your Spicy Mentor, evolving with you.

package/templates/langs/en/skills/plan-script/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: plan-script
+description: Create a step-by-step movie-script style execution plan. Includes target files, verification metrics, and rollback strategy.
+disable-model-invocation: true
+---
+
+# Plan Script
+
+**Goal**: Produce a "foolproof" executable plan to ensure controlled execution.
+
+Please generate plan in the following structure:
+
+## 1. Target Files (Authorization List)
+- List file paths **uniquely authorized** for modification in this plan.
+- Format: `- path/to/file`
+
+## 2. Steps (Execution Steps)
+1. Operations specific to filenames and tool calls.
+2. Each step includes expected intermediate state.
+
+## 3. Metrics (Verification Metrics)
+- How to quantitatively prove this plan succeeded? (e.g., tests pass, command returns 0, specific string appears in logs).
+
+## 4. Active Mental Models
+- Select exactly **2** meta-cognitive models from `.principles/THINKING_OS.md` that are most relevant to the current task.
+- Format: `- [T-0X] Model Name: Why is it needed for this specific task?`
+
+## 5. Rollback (Rollback Strategy)
+- If step 2 fails, how to one-click restore to safe state?
+
+---
+**Action**: Update above content to `PLAN.md` and set `STATUS: READY`.

package/templates/langs/en/skills/profile/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: profile
+description: Manually correct or update the user's expertise profile. Use to tell the system "I am an expert in X" or "I am a novice in Y".
+disable-model-invocation: true
+---
+
+# Profile Corrector
+
+You are now the "Manual Intervention Profile" component.
+
+**Task**:
+1. Parse user input `$ARGUMENTS` (format like "Frontend: Expert").
+2. Generate an **incremental evaluation** file `.state/.user_verdict.json`, forcing that domain's weight to extremely high (or low, depending on user description).
+3. Inform user: Changes will take effect after task completion (Stop).
+
+**JSON Template**:
+```json
+{
+  "updates": [
+    {"domain": "<EXTRACTED_DOMAIN>", "delta": 10, "reason": "User self-declared expertise"}
+  ]
+}
+```
+*(Note: If Novice, set delta to -10)*

package/templates/langs/en/skills/reflection/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: reflection
+description: Perform a deep metacognitive reflection on the current task status, user sentiment, and systemic issues. Use this before context compaction or when stuck.
+disable-model-invocation: false
+---
+
+# Metacognitive Reflection
+
+**Trigger Scenario**: Context about to be compacted (Memory Loss Imminent) or Task long-term stalled.
+**Goal**: Before forgetting the detailed process, extract "painful lessons" and solidify them as principles.
+
+Please execute the following reflection steps:
+
+## 1. Status Scan
+- **Goal**: What was our original objective? (Check `PLAN.md` or early conversation)
+- **Status**: How much is completed now? Where are we stuck?
+- **Cost**: We've consumed significant tokens. Is the output matching the cost?
+
+## 2. Pain Detection
+Please honestly answer the following questions (Yes/No):
+- [ ] **Task Stalled**: No实质性 code progress for 3+ consecutive rounds?
+- [ ] **Repeated Errors**: Bug fixed then reappeared, or same error reported twice?
+- [ ] **User Frustration**: User used negative words like "wrong", "no", "stop", or tone became impatient?
+- [ ] **Blind Action**: Modified code directly without PLAN or AUDIT?
+- [ ] **Architecture Degradation**: Is code more chaotic than when we started?
+
+## 3. Root Cause Analysis (If Pain Detected)
+If any of above is Yes, must perform deep attribution:
+- **Direct Cause**: What did we do (or not do) that led to current situation?
+- **Root Cause**: Where did our mental model go wrong? (Too eager? Ignored existing files? Disregarded tests?)
+
+## 4. Evolution Logging
+If pain detected, must execute:
+1. **Record**: Write analysis results to `memory/ISSUE_LOG.md`.
+2. **Extract**: If this is the second occurrence, extract a **Prohibitive Principle (Must NOT)**.
+3. **Reinforce**: Suggest a specific Hook or Test to prevent future recurrence.
+
+## 5. Recovery Plan
+- Since we're about to compact context, how should we continue with the "cleanest" state?
+- Update `PLAN.md`, mark current progress, ensure seamless continuation after compaction.

package/templates/langs/en/skills/reflection-log/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: reflection-log
+description: Final task reflection and evolution logging. Use to capture pain signals, update profiles, and propose new principles.
+disable-model-invocation: true
+---
+
+# Reflection & Evolution
+
+**Goal**: Transform single-task experience into system's permanent memory.
+
+Please execute the following closing operations:
+
+## 1. Pain Summary
+- Briefly describe the most painful, time-consuming, or failure-causing points in this task.
+
+## 2. Issue Logging
+- **Action**: Append detailed Pain Signal and diagnosis results to `memory/ISSUE_LOG.md`.
+
+## 3. Evolution Candidates
+- **Principle**: Propose a new principle (P-XX).
+- **Guardrail**: Suggest a specific Hook, Rule, or Test.
+  - **Path Interception**: Suggest adding sensitive directories to `risk_paths` in `.principles/PROFILE.json`.
+  - **Behavior Interception**: Suggest adding regex to `custom_guards` in `.principles/PROFILE.json` to intercept dangerous calls of specific tools (e.g., `Edit.*SYSTEM`).
+
+## 4. Positive Reinforcement
+- **Check Excellence Signals**: 
+  1. User's explicit praise (Quote user).
+  2. Objective performance/quality metric improvements (Cite data).
+  3. Reviewer's high evaluation (Excellent/Elegant).
+- **Extract Pattern**: If above signals exist, record `achievement` field in `.state/.user_verdict.json` describing the successful behavioral pattern.
+
+## 5. Attribution
+- **Agent Scorecard**: Evaluate sub-agent performance used in this task, write to `.state/.verdict.json`. Format follows `@.principles/schemas/agent_verdict_schema.json`.
+- **User Profile**: Evaluate user instruction quality and preferences, write to `.state/.user_verdict.json`. Format follows `@.principles/schemas/user_verdict_schema.json`.
+
+## 6. Cleanup
+- Clean up all intermediate marker files (e.g., `.pain_flag`, `.verdict.json`, etc.).

package/templates/langs/en/skills/report/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: report
+description: Manually request a formal status report from the Reporter agent.
+disable-model-invocation: true
+---
+
+# /report: Get Work Report
+
+User (the boss) requests an immediate work report.
+
+## Execution Action
+1. Immediately delegate ``pd_spawn_agent(reporter)``.
+2. Task description: "The boss wants to know the current situation. Please analyze current conversation context, `PLAN.md`, and recent `memory/ISSUE_LOG.md` to write an elegant report for the boss. Remember to check their profile first!"

package/templates/langs/en/skills/root-cause/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: root-cause
+description: Deep dive analysis into why a problem occurred. Uses the 5 Whys method and classifies the cause.
+disable-model-invocation: true
+---
+
+# Root Cause Analysis
+
+**Goal**: See through phenomena to essence, prevent repeated mistakes.
+
+Please execute diagnosis in the following format:
+
+## 1. Proximal Cause
+- **Verb-driven**: Describe what specific operation or lack thereof caused the immediate failure.
+
+## 2. 5 Whys (Deep Inquiry)
+1. Why did the proximal cause occur?
+2. ...
+3. ...
+4. ...
+5. Trace back to systemic or cognitive root.
+
+## 3. Root Cause
+- **Adjective/Design-driven**: Describe system architecture, process defects, or wrong assumptions.
+- **Guardrail Failure Analysis**: Why didn't existing gates (Hooks) or rules (Rules) intercept this error? Is it missing rules, loose matching, or logic loopholes?
+
+## 4. Category
+- [ ] **People**: Capability blind spots, habit issues.
+- [ ] **Design**: Process/tool defects, insufficient gates, architecture loopholes.
+- [ ] **Assumption**: Wrong assumptions about environment, versions, or dependencies.
+
+## 5. Principle Candidate
+- If we fix this issue, what principle should be added to prevent it from happening again?