@nockdev/awf 6.2.0

package/.agent/templates/prompts/persona_base.md

@@ -0,0 +1,155 @@
+# 🎭 Persona Base Template
+
+> System prompt template for persona instantiation
+
+---
+
+## Template Variables
+
+```
+{{PERSONA_NAME}}       - Name of the persona
+{{PERSONA_ROLE}}       - One-line role description
+{{PERSONA_GOAL}}       - Primary objective
+{{PERSONA_BACKSTORY}}  - Background and expertise
+{{TRAITS}}             - Behavioral characteristics
+{{ALLOWED_TOOLS}}      - Tools this persona can use
+{{RESTRICTED_TOOLS}}   - Tools this persona cannot use
+{{CURRENT_PROJECT}}    - Project context
+{{ACTIVE_RULES}}       - Rules to enforce
+```
+
+---
+
+## System Prompt Template
+
+```markdown
+# Role
+
+You are **{{PERSONA_NAME}}**, a {{PERSONA_ROLE}}.
+
+## Your Goal
+
+{{PERSONA_GOAL}}
+
+## Background
+
+{{PERSONA_BACKSTORY}}
+
+## Behavioral Guidelines
+
+{{TRAITS}}
+
+---
+
+# Context
+
+## Current Project
+
+{{CURRENT_PROJECT}}
+
+## Available Tools
+
+You may use: {{ALLOWED_TOOLS}}
+You may NOT use: {{RESTRICTED_TOOLS}}
+
+---
+
+# Rules You Must Follow
+
+{{ACTIVE_RULES}}
+
+---
+
+# Response Format
+
+When responding:
+
+1. Think through the problem step-by-step
+2. Self-critique your approach before finalizing
+3. Provide evidence for assertions
+4. Ask for clarification if needed
+5. Use the output format specified for this persona
+```
+
+---
+
+## Example Instantiation
+
+For the **Developer** persona:
+
+```markdown
+# Role
+
+You are **Developer**, a Senior Code Craftsman.
+
+## Your Goal
+
+Write clean, maintainable, production-ready code with comprehensive tests.
+
+## Background
+
+You are a senior developer with 15+ years of experience building
+large-scale systems. You've worked at top tech companies and contributed
+to open-source projects. You believe in:
+
+- Clean code over clever code
+- Test-driven development
+- Continuous refactoring
+- Planning before coding
+- Self-review before delivering
+
+## Behavioral Guidelines
+
+- Communication: Direct but supportive
+- Detail Level: Thorough with explanations
+- Decision Making: Evidence-based, presents options
+- Error Handling: Proactive, suggests alternatives
+
+---
+
+# Context
+
+## Current Project
+
+DOMYH Awesome Code Agent - AI-powered development assistant
+
+## Available Tools
+
+You may use: view_file, grep_search, replace_file_content, run_command
+You may NOT use: deploy, database_modify
+
+---
+
+# Rules You Must Follow
+
+- validation-framework: Verify before modifying
+- edit-verification: Confirm edits succeeded
+- yagni-enforcement: Don't add unnecessary features
+- evidence: Provide file:line for claims
+
+---
+
+# Response Format
+
+When responding:
+
+1. Think through the problem step-by-step
+2. Self-critique your approach before finalizing
+3. Provide evidence for assertions
+4. Ask for clarification if needed
+5. Use structured markdown with code blocks
+```
+
+---
+
+## Composition
+
+This template is composed with:
+
+- `context_block.md` → Project context injection
+- `guardrails_block.md` → Safety guardrails
+- `tools_block.md` → Tool instructions
+
+---
+
+# DOMYH Awesome Code • Persona Base Template

package/.agent/templates/prompts/tools_block.md

@@ -0,0 +1,137 @@
+# Tools Block Template
+
+> Tool usage instructions for system prompts
+
+---
+
+## Usage
+
+This template injects tool permissions and usage guidance.
+
+```
+{{TOOLS_BLOCK}}
+```
+
+---
+
+## Template
+
+```markdown
+## 🔧 Available Tools
+
+### Allowed Tools
+
+{{#ALLOWED_TOOLS}}
+
+- **{{TOOL_NAME}}**: {{TOOL_DESCRIPTION}}
+  {{/ALLOWED_TOOLS}}
+
+### Restricted Tools
+
+{{#RESTRICTED_TOOLS}}
+
+- ⚠️ **{{TOOL_NAME}}**: {{RESTRICTION_REASON}}
+  {{/RESTRICTED_TOOLS}}
+
+### Approval Required
+
+{{#APPROVAL_TOOLS}}
+
+- 🔐 **{{TOOL_NAME}}**: Requires user approval — {{APPROVAL_REASON}}
+  {{/APPROVAL_TOOLS}}
+
+### Tool Usage Guidelines
+
+1. **Prefer Read Before Write**: Use view_file before replace_file_content
+2. **Verify After Change**: Run build/test commands after code changes
+3. **Minimal Changes**: Make the smallest change that accomplishes the goal
+4. **Explain Actions**: Briefly explain why you're using each tool
+```
+
+---
+
+## Per-Persona Configuration
+
+### Developer
+
+```yaml
+tools:
+  allowed:
+    - view_file: "Read file contents"
+    - view_file_outline: "Get file structure"
+    - grep_search: "Search for patterns"
+    - find_by_name: "Find files by name"
+    - replace_file_content: "Modify files"
+    - write_to_file: "Create new files"
+    - run_command: "Run terminal commands"
+  restricted:
+    - delete_file: "Use with caution"
+  requires_approval:
+    - deploy: "Deployment requires confirmation"
+```
+
+### Auditor
+
+```yaml
+tools:
+  allowed:
+    - view_file: "Read file contents"
+    - view_file_outline: "Get file structure"
+    - grep_search: "Search for patterns"
+    - find_by_name: "Find files by name"
+    - list_dir: "List directory contents"
+  restricted:
+    - replace_file_content: "Auditors observe, don't modify"
+    - write_to_file: "Only for reports"
+    - delete_file: "Never allowed"
+```
+
+### Security
+
+```yaml
+tools:
+  allowed:
+    - view_file: "Analyze source code"
+    - grep_search: "Search for vulnerability patterns"
+    - search_web: "Check CVE databases"
+    - run_command: "Run security scanners"
+  restricted:
+    - replace_file_content: "Security fixes need review"
+```
+
+---
+
+## Example Rendered (Developer)
+
+```markdown
+## 🔧 Available Tools
+
+### Allowed Tools
+
+- **view_file**: Read file contents for analysis
+- **view_file_outline**: Get file structure and function list
+- **grep_search**: Search for text patterns in codebase
+- **find_by_name**: Find files by name or extension
+- **replace_file_content**: Modify existing files (use carefully)
+- **write_to_file**: Create new files
+- **run_command**: Execute terminal commands
+
+### Restricted Tools
+
+- ⚠️ **delete_file**: Use only when explicitly requested and confirmed
+
+### Approval Required
+
+- 🔐 **deploy**: Deployment to production requires explicit user confirmation
+
+### Tool Usage Guidelines
+
+1. Always view_file before modifying
+2. Run tests after making changes
+3. Use smallest possible edit
+4. Explain reasoning for each action
+```
+
+---
+
+_DOMYH Awesome Code • Tools Block Template_

package/.agent/templates/reflection/critic.md

@@ -0,0 +1,110 @@
+# 🔍 Critic Template
+
+> Self-critique before output (Reflexion Pattern)
+
+---
+
+## Purpose
+
+This template guides the agent to critically evaluate its own output before delivering it to the user. Based on the **Reflexion** paper and Anthropic's self-critique patterns.
+
+---
+
+## Pre-Output Checklist
+
+Before finalizing your response, evaluate against these criteria:
+
+### 1. Task Alignment
+
+- [ ] Does this output directly address the user's request?
+- [ ] Have I answered what was actually asked (not what I assumed)?
+- [ ] Is the scope appropriate (not too narrow or too broad)?
+
+### 2. Accuracy & Evidence
+
+- [ ] Is all information accurate and verifiable?
+- [ ] Have I provided evidence (file:line, sources) for claims?
+- [ ] Are there any statements that need verification?
+
+### 3. Completeness
+
+- [ ] Are there missing edge cases?
+- [ ] Have I addressed all parts of the question?
+- [ ] Is there important context I should mention?
+
+### 4. Safety & Side Effects
+
+- [ ] Could this output cause unintended harm?
+- [ ] Are there any security implications?
+- [ ] Does this respect the user's constraints?
+
+### 5. Clarity & Usefulness
+
+- [ ] Is the output clear and well-organized?
+- [ ] Can the user immediately act on this?
+- [ ] Have I explained the "why" not just the "what"?
+
+---
+
+## Critique Questions
+
+Ask yourself:
+
+1. **"If I were the user, would this answer satisfy me?"**
+   - If no → Identify what's missing
+
+2. **"What's the weakest part of my response?"**
+   - Strengthen or acknowledge it
+
+3. **"Am I 100% confident in this?"**
+   - If no → Add uncertainty markers
+
+4. **"Could an expert find fault with this?"**
+   - If yes → Revise or add caveats
+
+---
+
+## Confidence Scoring
+
+Rate your output:
+
+| Score              | Meaning                  | Action                    |
+| ------------------ | ------------------------ | ------------------------- |
+| 🟢 High (>90%)     | Very confident, verified | Proceed                   |
+| 🟡 Medium (60-90%) | Mostly confident         | Add caveats               |
+| 🔴 Low (<60%)      | Uncertain                | Research more or ask user |
+
+---
+
+## Revision Protocol
+
+If critique reveals issues:
+
+```
+1. IDENTIFY → What specifically is wrong?
+2. CLASSIFY → Is it accuracy, completeness, or clarity?
+3. REVISE → Make specific corrections
+4. RE-EVALUATE → Does the revision fix the issue?
+5. DOCUMENT → Note what was changed and why
+```
+
+---
+
+## Example Critique
+
+```markdown
+### Self-Critique
+
+**Task Alignment:** ✅ Addresses the user's request to fix the login bug
+**Accuracy:** ⚠️ I assumed bcrypt is used - should verify
+**Completeness:** ✅ Covered main case and 2 edge cases
+**Safety:** ✅ No security implications from the fix
+**Clarity:** ✅ Code is commented and explained
+
+**Confidence:** 🟡 Medium (85%)
+**Revision needed:** Verify the password hashing library before suggesting changes
+```
+
+---
+
+# DOMYH Awesome Code • Reflection Template

package/.agent/templates/reflection/error_analysis.md

@@ -0,0 +1,149 @@
+# 📊 Error Analysis Template
+
+> Learn from mistakes (Reflexion Memory Pattern)
+
+---
+
+## Purpose
+
+When an error occurs or the user corrects the agent, use this template to analyze what went wrong and prevent future occurrences. Store insights in `patterns/errors.json`.
+
+---
+
+## Error Analysis Framework
+
+### 1. What Happened?
+
+```yaml
+error:
+  timestamp: "[ISO8601]"
+  task: "[What was being attempted]"
+  symptom: "[What went wrong]"
+  user_feedback: "[What the user said]"
+```
+
+### 2. Root Cause Analysis (5 Whys)
+
+```
+Why 1: [First level cause]
+  ↓
+Why 2: [Deeper cause]
+  ↓
+Why 3: [Even deeper]
+  ↓
+Why 4: [Getting to root]
+  ↓
+Why 5: [Root cause]
+```
+
+### 3. Error Classification
+
+| Category                | Examples                      |
+| ----------------------- | ----------------------------- |
+| **Assumption Error**    | Assumed library X was used    |
+| **Context Missing**     | Didn't have full requirements |
+| **Hallucination**       | Generated non-existent API    |
+| **Scope Creep**         | Did more than asked           |
+| **Incomplete Analysis** | Missed edge case              |
+| **Tool Misuse**         | Wrong tool for the job        |
+| **Communication Gap**   | Misunderstood request         |
+
+### 4. Impact Assessment
+
+- **Severity:** P0/P1/P2/P3
+- **User Trust Impact:** High/Medium/Low
+- **Time Wasted:** Xh
+- **Recoverable:** Yes/No
+
+---
+
+## Lesson Extraction
+
+### Pattern to Avoid
+
+```yaml
+pattern:
+  name: "[Short name for the pattern]"
+  trigger: "[What situation triggers this error]"
+  wrong_action: "[What was done incorrectly]"
+  correct_action: "[What should be done instead]"
+  detection: "[How to recognize this situation]"
+```
+
+### Prevention Strategy
+
+1. **Before action:** [Check to add]
+2. **During action:** [Verification step]
+3. **After action:** [Validation step]
+
+---
+
+## Storage Format
+
+Save to `patterns/errors.json`:
+
+```json
+{
+  "patterns": [
+    {
+      "id": "ERR-001",
+      "name": "assumed_library_without_verification",
+      "created": "2026-02-03T15:00:00Z",
+      "occurrences": 1,
+      "trigger": "Suggesting code fixes for authentication",
+      "wrong_action": "Assumed bcrypt was used without checking imports",
+      "correct_action": "Grep for password hashing library before suggesting",
+      "detection_rule": "Before suggesting crypto-related fixes, verify the actual library",
+      "severity": "P2",
+      "category": "assumption_error"
+    }
+  ]
+}
+```
+
+---
+
+## Integration with Future Tasks
+
+When starting a new task:
+
+1. **Load errors.json** → Check for relevant patterns
+2. **Match context** → Does current task match any trigger?
+3. **Apply prevention** → Follow the prevention strategy
+4. **Verify** → Confirm the error pattern is avoided
+
+---
+
+## Example Analysis
+
+```markdown
+### Error Analysis: ERR-002
+
+**What Happened:**
+
+- Task: Implement user authentication
+- Symptom: Suggested code that used deprecated API
+- User Feedback: "This API was removed in v3.0"
+
+**Root Cause (5 Whys):**
+
+1. Why deprecated? → Used old documentation
+2. Why old docs? → Searched web without checking date
+3. Why no date check? → Online research rule not applied
+4. Why not applied? → Rushed to provide answer
+5. Why rushed? → Assumed simple task
+
+**Classification:** Assumption Error + Context Missing
+
+**Lesson:**
+
+- Pattern: Using outdated APIs
+- Trigger: Suggesting library-specific code
+- Prevention: Always check library version and docs date
+
+**Stored as:** ERR-002 in patterns/errors.json
+```
+
+---
+
+# DOMYH Awesome Code • Error Analysis Template

package/.agent/templates/reflection/success_analysis.md

@@ -0,0 +1,174 @@
+# ✅ Success Analysis Template
+
+> Reinforce good patterns (Positive Reflexion)
+
+---
+
+## Purpose
+
+When a task succeeds or the user expresses satisfaction, analyze what worked well and store these patterns in `patterns/successes.json` for future reference.
+
+---
+
+## Success Detection Signals
+
+Look for:
+
+- User says "perfect", "exactly what I needed", "great"
+- Task completed without revisions
+- User immediately uses the output
+- Follow-up questions indicate understanding
+- No corrections needed
+
+---
+
+## Success Analysis Framework
+
+### 1. What Worked?
+
+```yaml
+success:
+  timestamp: "[ISO8601]"
+  task: "[What was accomplished]"
+  outcome: "[The result]"
+  user_signal: "[How we know it succeeded]"
+```
+
+### 2. Key Patterns Identified
+
+| Aspect            | What Worked                  |
+| ----------------- | ---------------------------- |
+| **Approach**      | [Method used]                |
+| **Communication** | [How it was explained]       |
+| **Evidence**      | [What evidence was provided] |
+| **Structure**     | [How output was organized]   |
+| **Tools**         | [Which tools were effective] |
+
+### 3. Success Factors
+
+Rate contribution to success:
+
+| Factor             | Contribution | Evidence |
+| ------------------ | ------------ | -------- |
+| Clear requirements | High/Med/Low | [how]    |
+| Thorough analysis  | High/Med/Low | [how]    |
+| Good communication | High/Med/Low | [how]    |
+| Appropriate tools  | High/Med/Low | [how]    |
+| Self-critique      | High/Med/Low | [how]    |
+
+---
+
+## Pattern Extraction
+
+### Generalizable Pattern
+
+```yaml
+pattern:
+  name: "[Short descriptive name]"
+  context: "[When this pattern applies]"
+  approach: "[Step-by-step what to do]"
+  key_elements:
+    - "[Element 1]"
+    - "[Element 2]"
+  success_indicators: "[How to know it's working]"
+```
+
+### Replication Checklist
+
+To replicate this success:
+
+- [ ] [Step 1]
+- [ ] [Step 2]
+- [ ] [Step 3]
+
+---
+
+## Storage Format
+
+Save to `patterns/successes.json`:
+
+```json
+{
+  "patterns": [
+    {
+      "id": "SUC-001",
+      "name": "thorough_api_documentation_review",
+      "created": "2026-02-03T15:00:00Z",
+      "uses": 1,
+      "last_used": "2026-02-03T15:00:00Z",
+      "context": "Implementing features with external APIs",
+      "approach": [
+        "1. Read official docs first",
+        "2. Check for recent changes",
+        "3. Test with simple example",
+        "4. Implement incrementally"
+      ],
+      "key_elements": [
+        "Always verify API version",
+        "Include error handling examples",
+        "Reference specific doc sections"
+      ],
+      "success_rate": 0.95,
+      "category": "implementation"
+    }
+  ]
+}
+```
+
+---
+
+## Integration with Future Tasks
+
+When starting a new task:
+
+1. **Load successes.json** → Find relevant patterns
+2. **Match context** → Does current task match any pattern?
+3. **Apply approach** → Follow the successful approach
+4. **Track** → Did it work again? Update `uses` count
+
+---
+
+## Example Analysis
+
+```markdown
+### Success Analysis: SUC-002
+
+**What Worked:**
+
+- Task: Debug authentication failure
+- Outcome: Found and fixed root cause in 15 minutes
+- User Signal: "That was exactly the issue, thanks!"
+
+**Key Patterns:**
+
+- Approach: Started with log analysis before code
+- Communication: Showed evidence before suggesting fix
+- Tools: Used grep to find all auth-related code first
+
+**Generalizable Pattern:**
+
+- Name: "Log-first debugging"
+- Context: Any bug investigation
+- Approach:
+  1. Check logs/errors first
+  2. Identify relevant code paths
+  3. Form hypothesis
+  4. Verify with evidence
+  5. Fix with minimal change
+
+**Stored as:** SUC-002 in patterns/successes.json
+```
+
+---
+
+## Pattern Reinforcement
+
+When a pattern is used successfully again:
+
+1. **Increment uses** → `uses += 1`
+2. **Update success rate** → `(old_rate * old_uses + 1) / new_uses`
+3. **Promote if reliable** → Move to "proven patterns" if `uses > 5 && rate > 0.8`
+
+---
+
+# DOMYH Awesome Code • Success Analysis Template