thanh-kit 2.5.0

package/templates/skills/planning/references/solution-design.md

@@ -0,0 +1,63 @@
+# Solution Design
+
+## Core Principles
+
+Follow these fundamental principles:
+- **YAGNI** (You Aren't Gonna Need It) - Don't add functionality until necessary
+- **KISS** (Keep It Simple, Stupid) - Prefer simple solutions over complex ones
+- **DRY** (Don't Repeat Yourself) - Avoid code duplication
+
+## Design Activities
+
+### Technical Trade-off Analysis
+- Evaluate multiple approaches for each requirement
+- Compare pros and cons of different solutions
+- Consider short-term vs long-term implications
+- Balance complexity with maintainability
+- Assess development effort vs benefit
+- Recommend optimal solution based on current best practices
+
+### Security Assessment
+- Identify potential vulnerabilities during design phase
+- Consider authentication and authorization requirements
+- Assess data protection needs
+- Evaluate input validation requirements
+- Plan for secure configuration management
+- Address OWASP Top 10 concerns
+- Consider API security (rate limiting, CORS, etc.)
+
+### Performance & Scalability
+- Identify potential bottlenecks early
+- Consider database query optimization needs
+- Plan for caching strategies
+- Assess resource usage (memory, CPU, network)
+- Design for horizontal/vertical scaling
+- Plan for load distribution
+- Consider asynchronous processing where appropriate
+
+### Edge Cases & Failure Modes
+- Think through error scenarios
+- Plan for network failures
+- Consider partial failure handling
+- Design retry and fallback mechanisms
+- Plan for data consistency
+- Consider race conditions
+- Design for graceful degradation
+
+### Architecture Design
+- Create scalable system architectures
+- Design for maintainability
+- Plan component interactions
+- Design data flow
+- Consider microservices vs monolith trade-offs
+- Plan API contracts
+- Design state management
+
+## Best Practices
+
+- Document design decisions and rationale
+- Consider both technical and business requirements
+- Think through the entire user journey
+- Plan for monitoring and observability
+- Design with testing in mind
+- Consider deployment and rollback strategies

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

@@ -0,0 +1,160 @@
+---
+name: planning-with-files
+description: Transforms workflow to use Manus-style persistent markdown files for planning, progress tracking, and knowledge storage. Use when starting complex tasks, multi-step projects, research tasks, or when the user mentions planning, organizing work, tracking progress, or wants structured output.
+---
+
+# Planning with Files
+
+Work like Manus: Use persistent markdown files as your "working memory on disk."
+
+## Quick Start
+
+Before ANY complex task:
+
+1. **Create `task_plan.md`** in the working directory
+2. **Define phases** with checkboxes
+3. **Update after each phase** - mark [x] and change status
+4. **Read before deciding** - refresh goals in attention window
+
+## The 3-File Pattern
+
+For every non-trivial task, create THREE files:
+
+| File | Purpose | When to Update |
+|------|---------|----------------|
+| `task_plan.md` | Track phases and progress | After each phase |
+| `notes.md` | Store findings and research | During research |
+| `[deliverable].md` | Final output | At completion |
+
+## Core Workflow
+
+```
+Loop 1: Create task_plan.md with goal and phases
+Loop 2: Research → save to notes.md → update task_plan.md
+Loop 3: Read notes.md → create deliverable → update task_plan.md
+Loop 4: Deliver final output
+```
+
+### The Loop in Detail
+
+**Before each major action:**
+```bash
+Read task_plan.md  # Refresh goals in attention window
+```
+
+**After each phase:**
+```bash
+Edit task_plan.md  # Mark [x], update status
+```
+
+**When storing information:**
+```bash
+Write notes.md     # Don't stuff context, store in file
+```
+
+## task_plan.md Template
+
+Create this file FIRST for any complex task:
+
+```markdown
+# Task Plan: [Brief Description]
+
+## Goal
+[One sentence describing the end state]
+
+## Phases
+- [ ] Phase 1: Plan and setup
+- [ ] Phase 2: Research/gather information
+- [ ] Phase 3: Execute/build
+- [ ] Phase 4: Review and deliver
+
+## Key Questions
+1. [Question to answer]
+2. [Question to answer]
+
+## Decisions Made
+- [Decision]: [Rationale]
+
+## Errors Encountered
+- [Error]: [Resolution]
+
+## Status
+**Currently in Phase X** - [What I'm doing now]
+```
+
+## notes.md Template
+
+For research and findings:
+
+```markdown
+# Notes: [Topic]
+
+## Sources
+
+### Source 1: [Name]
+- URL: [link]
+- Key points:
+  - [Finding]
+  - [Finding]
+
+## Synthesized Findings
+
+### [Category]
+- [Finding]
+- [Finding]
+```
+
+## Critical Rules
+
+### 1. ALWAYS Create Plan First
+Never start a complex task without `task_plan.md`. This is non-negotiable.
+
+### 2. Read Before Decide
+Before any major decision, read the plan file. This keeps goals in your attention window.
+
+### 3. Update After Act
+After completing any phase, immediately update the plan file:
+- Mark completed phases with [x]
+- Update the Status section
+- Log any errors encountered
+
+### 4. Store, Don't Stuff
+Large outputs go to files, not context. Keep only paths in working memory.
+
+### 5. Log All Errors
+Every error goes in the "Errors Encountered" section. This builds knowledge for future tasks.
+
+## When to Use This Pattern
+
+**Use 3-file pattern for:**
+- Multi-step tasks (3+ steps)
+- Research tasks
+- Building/creating something
+- Tasks spanning multiple tool calls
+- Anything requiring organization
+
+**Skip for:**
+- Simple questions
+- Single-file edits
+- Quick lookups
+
+## Anti-Patterns to Avoid
+
+| Don't | Do Instead |
+|-------|------------|
+| Use TodoWrite for persistence | Create `task_plan.md` file |
+| State goals once and forget | Re-read plan before each decision |
+| Hide errors and retry | Log errors to plan file |
+| Stuff everything in context | Store large content in files |
+| Start executing immediately | Create plan file FIRST |
+
+## Advanced Patterns
+
+See [reference.md](reference.md) for:
+- Attention manipulation techniques
+- Error recovery patterns
+- Context optimization from Manus
+
+See [examples.md](examples.md) for:
+- Real task examples
+- Complex workflow patterns

package/templates/skills/planning-with-files/examples.md

@@ -0,0 +1,202 @@
+# Examples: Planning with Files in Action
+
+## Example 1: Research Task
+
+**User Request:** "Research the benefits of morning exercise and write a summary"
+
+### Loop 1: Create Plan
+```bash
+Write task_plan.md
+```
+
+```markdown
+# Task Plan: Morning Exercise Benefits Research
+
+## Goal
+Create a research summary on the benefits of morning exercise.
+
+## Phases
+- [ ] Phase 1: Create this plan ✓
+- [ ] Phase 2: Search and gather sources
+- [ ] Phase 3: Synthesize findings
+- [ ] Phase 4: Deliver summary
+
+## Key Questions
+1. What are the physical health benefits?
+2. What are the mental health benefits?
+3. What scientific studies support this?
+
+## Status
+**Currently in Phase 1** - Creating plan
+```
+
+### Loop 2: Research
+```bash
+Read task_plan.md           # Refresh goals
+WebSearch "morning exercise benefits"
+Write notes.md              # Store findings
+Edit task_plan.md           # Mark Phase 2 complete
+```
+
+### Loop 3: Synthesize
+```bash
+Read task_plan.md           # Refresh goals
+Read notes.md               # Get findings
+Write morning_exercise_summary.md
+Edit task_plan.md           # Mark Phase 3 complete
+```
+
+### Loop 4: Deliver
+```bash
+Read task_plan.md           # Verify complete
+Deliver morning_exercise_summary.md
+```
+
+---
+
+## Example 2: Bug Fix Task
+
+**User Request:** "Fix the login bug in the authentication module"
+
+### task_plan.md
+```markdown
+# Task Plan: Fix Login Bug
+
+## Goal
+Identify and fix the bug preventing successful login.
+
+## Phases
+- [x] Phase 1: Understand the bug report ✓
+- [x] Phase 2: Locate relevant code ✓
+- [ ] Phase 3: Identify root cause (CURRENT)
+- [ ] Phase 4: Implement fix
+- [ ] Phase 5: Test and verify
+
+## Key Questions
+1. What error message appears?
+2. Which file handles authentication?
+3. What changed recently?
+
+## Decisions Made
+- Auth handler is in src/auth/login.ts
+- Error occurs in validateToken() function
+
+## Errors Encountered
+- [Initial] TypeError: Cannot read property 'token' of undefined
+  → Root cause: user object not awaited properly
+
+## Status
+**Currently in Phase 3** - Found root cause, preparing fix
+```
+
+---
+
+## Example 3: Feature Development
+
+**User Request:** "Add a dark mode toggle to the settings page"
+
+### The 3-File Pattern in Action
+
+**task_plan.md:**
+```markdown
+# Task Plan: Dark Mode Toggle
+
+## Goal
+Add functional dark mode toggle to settings.
+
+## Phases
+- [x] Phase 1: Research existing theme system ✓
+- [x] Phase 2: Design implementation approach ✓
+- [ ] Phase 3: Implement toggle component (CURRENT)
+- [ ] Phase 4: Add theme switching logic
+- [ ] Phase 5: Test and polish
+
+## Decisions Made
+- Using CSS custom properties for theme
+- Storing preference in localStorage
+- Toggle component in SettingsPage.tsx
+
+## Status
+**Currently in Phase 3** - Building toggle component
+```
+
+**notes.md:**
+```markdown
+# Notes: Dark Mode Implementation
+
+## Existing Theme System
+- Located in: src/styles/theme.ts
+- Uses: CSS custom properties
+- Current themes: light only
+
+## Files to Modify
+1. src/styles/theme.ts - Add dark theme colors
+2. src/components/SettingsPage.tsx - Add toggle
+3. src/hooks/useTheme.ts - Create new hook
+4. src/App.tsx - Wrap with ThemeProvider
+
+## Color Decisions
+- Dark background: #1a1a2e
+- Dark surface: #16213e
+- Dark text: #eaeaea
+```
+
+**dark_mode_implementation.md:** (deliverable)
+```markdown
+# Dark Mode Implementation
+
+## Changes Made
+
+### 1. Added dark theme colors
+File: src/styles/theme.ts
+...
+
+### 2. Created useTheme hook
+File: src/hooks/useTheme.ts
+...
+```
+
+---
+
+## Example 4: Error Recovery Pattern
+
+When something fails, DON'T hide it:
+
+### Before (Wrong)
+```
+Action: Read config.json
+Error: File not found
+Action: Read config.json  # Silent retry
+Action: Read config.json  # Another retry
+```
+
+### After (Correct)
+```
+Action: Read config.json
+Error: File not found
+
+# Update task_plan.md:
+## Errors Encountered
+- config.json not found → Will create default config
+
+Action: Write config.json (default config)
+Action: Read config.json
+Success!
+```
+
+---
+
+## The Read-Before-Decide Pattern
+
+**Always read your plan before major decisions:**
+
+```
+[Many tool calls have happened...]
+[Context is getting long...]
+[Original goal might be forgotten...]
+
+→ Read task_plan.md          # This brings goals back into attention!
+→ Now make the decision       # Goals are fresh in context
+```
+
+This is why Manus can handle ~50 tool calls without losing track. The plan file acts as a "goal refresh" mechanism.

package/templates/skills/planning-with-files/reference.md

@@ -0,0 +1,110 @@
+# Reference: Manus Context Engineering Principles
+
+This skill is based on the context engineering principles from Manus, the AI agent company acquired by Meta for $2 billion in December 2025.
+
+## The 6 Manus Principles
+
+### 1. Filesystem as External Memory
+
+> "Markdown is my 'working memory' on disk."
+
+**Problem:** Context windows have limits. Stuffing everything in context degrades performance and increases costs.
+
+**Solution:** Treat the filesystem as unlimited memory:
+- Store large content in files
+- Keep only paths in context
+- Agent can "look up" information when needed
+- Compression must be REVERSIBLE
+
+### 2. Attention Manipulation Through Repetition
+
+**Problem:** After ~50 tool calls, models forget original goals ("lost in the middle" effect).
+
+**Solution:** Keep a `task_plan.md` file that gets RE-READ throughout execution:
+```
+Start of context: [Original goal - far away, forgotten]
+...many tool calls...
+End of context: [Recently read task_plan.md - gets ATTENTION!]
+```
+
+By reading the plan file before each decision, goals appear in the attention window.
+
+### 3. Keep Failure Traces
+
+> "Error recovery is one of the clearest signals of TRUE agentic behavior."
+
+**Problem:** Instinct says hide errors, retry silently. This wastes tokens and loses learning.
+
+**Solution:** KEEP failed actions in the plan file:
+```markdown
+## Errors Encountered
+- [2025-01-03] FileNotFoundError: config.json not found → Created default config
+- [2025-01-03] API timeout → Retried with exponential backoff, succeeded
+```
+
+The model updates its internal understanding when seeing failures.
+
+### 4. Avoid Few-Shot Overfitting
+
+> "Uniformity breeds fragility."
+
+**Problem:** Repetitive action-observation pairs cause drift and hallucination.
+
+**Solution:** Introduce controlled variation:
+- Vary phrasings slightly
+- Don't copy-paste patterns blindly
+- Recalibrate on repetitive tasks
+
+### 5. Stable Prefixes for Cache Optimization
+
+**Problem:** Agents are input-heavy (100:1 ratio). Every token costs money.
+
+**Solution:** Structure for cache hits:
+- Put static content FIRST
+- Append-only context (never modify history)
+- Consistent serialization
+
+### 6. Append-Only Context
+
+**Problem:** Modifying previous messages invalidates KV-cache.
+
+**Solution:** NEVER modify previous messages. Always append new information.
+
+## The Agent Loop
+
+Manus operates in a continuous loop:
+
+```
+1. Analyze → 2. Think → 3. Select Tool → 4. Execute → 5. Observe → 6. Iterate → 7. Deliver
+```
+
+### File Operations in the Loop:
+
+| Operation | When to Use |
+|-----------|-------------|
+| `write` | New files or complete rewrites |
+| `append` | Adding sections incrementally |
+| `edit` | Updating specific parts (checkboxes, status) |
+| `read` | Reviewing before decisions |
+
+## Manus Statistics
+
+| Metric | Value |
+|--------|-------|
+| Average tool calls per task | ~50 |
+| Input-to-output ratio | 100:1 |
+| Acquisition price | $2 billion |
+| Time to $100M revenue | 8 months |
+
+## Key Quotes
+
+> "If the model improvement is the rising tide, we want Manus to be the boat, not the piling stuck on the seafloor."
+
+> "For complex tasks, I save notes, code, and findings to files so I can reference them as I work."
+
+> "I used file.edit to update checkboxes in my plan as I progressed, rather than rewriting the whole file."
+
+## Source
+
+Based on Manus's official context engineering documentation:
+https://manus.im/de/blog/Context-Engineering-for-AI-Agents-Lessons-from-Building-Manus

package/templates/skills/problem-solving/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: Problem-Solving Techniques
+description: Apply systematic problem-solving techniques for complexity spirals (simplification cascades), innovation blocks (collision-zone thinking), recurring patterns (meta-pattern recognition), assumption constraints (inversion exercise), scale uncertainty (scale game), and dispatch when stuck. Techniques derived from Microsoft Amplifier project patterns adapted for immediate application.
+version: 2.0.0
+---
+
+# Problem-Solving Techniques
+
+Systematic approaches for different types of stuck-ness. Each technique targets specific problem patterns.
+
+## When to Use
+
+Apply when encountering:
+- **Complexity spiraling** - Multiple implementations, growing special cases, excessive branching
+- **Innovation blocks** - Conventional solutions inadequate, need breakthrough thinking
+- **Recurring patterns** - Same issue across domains, reinventing solutions
+- **Assumption constraints** - Forced into "only way", can't question premise
+- **Scale uncertainty** - Production readiness unclear, edge cases unknown
+- **General stuck-ness** - Unsure which technique applies
+
+## Quick Dispatch
+
+**Match symptom to technique:**
+
+| Stuck Symptom | Technique | Reference |
+|---------------|-----------|-----------|
+| Same thing implemented 5+ ways, growing special cases | **Simplification Cascades** | `references/simplification-cascades.md` |
+| Conventional solutions inadequate, need breakthrough | **Collision-Zone Thinking** | `references/collision-zone-thinking.md` |
+| Same issue in different places, reinventing wheels | **Meta-Pattern Recognition** | `references/meta-pattern-recognition.md` |
+| Solution feels forced, "must be done this way" | **Inversion Exercise** | `references/inversion-exercise.md` |
+| Will this work at production? Edge cases unclear? | **Scale Game** | `references/scale-game.md` |
+| Unsure which technique to use | **When Stuck** | `references/when-stuck.md` |
+
+## Core Techniques
+
+### 1. Simplification Cascades
+Find one insight eliminating multiple components. "If this is true, we don't need X, Y, Z."
+
+**Key insight:** Everything is a special case of one general pattern.
+
+**Red flag:** "Just need to add one more case..." (repeating forever)
+
+### 2. Collision-Zone Thinking
+Force unrelated concepts together to discover emergent properties. "What if we treated X like Y?"
+
+**Key insight:** Revolutionary ideas from deliberate metaphor-mixing.
+
+**Red flag:** "I've tried everything in this domain"
+
+### 3. Meta-Pattern Recognition
+Spot patterns appearing in 3+ domains to find universal principles.
+
+**Key insight:** Patterns in how patterns emerge reveal reusable abstractions.
+
+**Red flag:** "This problem is unique" (probably not)
+
+### 4. Inversion Exercise
+Flip core assumptions to reveal hidden constraints. "What if the opposite were true?"
+
+**Key insight:** Valid inversions reveal context-dependence of "rules."
+
+**Red flag:** "There's only one way to do this"
+
+### 5. Scale Game
+Test at extremes (1000x bigger/smaller, instant/year-long) to expose fundamental truths.
+
+**Key insight:** What works at one scale fails at another.
+
+**Red flag:** "Should scale fine" (without testing)
+
+## Application Process
+
+1. **Identify stuck-type** - Match symptom to technique above
+2. **Load detailed reference** - Read specific technique from `references/`
+3. **Apply systematically** - Follow technique's process
+4. **Document insights** - Record what worked/failed
+5. **Combine if needed** - Some problems need multiple techniques
+
+## Combining Techniques
+
+Powerful combinations:
+- **Simplification + Meta-pattern** - Find pattern, then simplify all instances
+- **Collision + Inversion** - Force metaphor, then invert its assumptions
+- **Scale + Simplification** - Extremes reveal what to eliminate
+- **Meta-pattern + Scale** - Universal patterns tested at extremes
+
+## References
+
+Load detailed guides as needed:
+- `references/when-stuck.md` - Dispatch flowchart and decision tree
+- `references/simplification-cascades.md` - Cascade detection and extraction
+- `references/collision-zone-thinking.md` - Metaphor collision process
+- `references/meta-pattern-recognition.md` - Pattern abstraction techniques
+- `references/inversion-exercise.md` - Assumption flipping methodology
+- `references/scale-game.md` - Extreme testing procedures
+- `references/attribution.md` - Source and adaptation notes

package/templates/skills/problem-solving/references/attribution.md

@@ -0,0 +1,69 @@
+# Problem-Solving Skills - Attribution
+
+These skills were derived from agent patterns in the Microsoft Amplifier project.
+
+## Source Repository
+
+- **Name:** Amplifier
+- **URL:** https://github.com/microsoft/amplifier
+- **Commit:** 2adb63f858e7d760e188197c8e8d4c1ef721e2a6
+- **Date:** 2025-10-10
+
+## Skills Derived from Amplifier Agents
+
+### From insight-synthesizer agent:
+- **simplification-cascades** - Finding insights that eliminate multiple components
+- **collision-zone-thinking** - Forcing unrelated concepts together for breakthroughs
+- **meta-pattern-recognition** - Spotting patterns across 3+ domains
+- **inversion-exercise** - Flipping assumptions to reveal alternatives
+- **scale-game** - Testing at extremes to expose fundamental truths
+
+### From ambiguity-guardian agent:
+- **preserving-productive-tensions** - Preserving multiple valid approaches (in architecture skill)
+
+### From knowledge-archaeologist agent:
+- **tracing-knowledge-lineages** - Understanding how ideas evolved (in research skill)
+
+### Dispatch pattern:
+- **when-stuck** - Maps stuck-symptoms to appropriate technique
+
+## What Was Adapted
+
+The Amplifier agents are specialized long-lived agents with structured JSON output. These skills extract the core problem-solving techniques and adapt them as:
+
+- **Scannable quick-reference guides** (~60-80 lines each)
+- **Symptom-based discovery** via when_to_use descriptions
+- **Immediate application** without special tooling
+- **Composable patterns** through dispatch system
+- **Progressive disclosure** via SKILL.md + references structure
+
+## Core Insight
+
+Agent capabilities are domain-agnostic patterns. Whether packaged as "amplifier agent" or "problem-solving skill", the underlying technique is the same.
+
+We extracted the techniques and made them:
+- Portable across contexts
+- Immediately applicable
+- Token-efficient through progressive disclosure
+- Discoverable through symptom-matching
+- Combinable for complex problems
+
+## License
+
+Original Amplifier project uses MIT License. These adapted skills maintain attribution and follow the same open spirit.
+
+## Adaptation Notes
+
+**Changes from original:**
+- Converted from long-lived agent to scannable reference
+- Added symptom-based dispatch system
+- Removed JSON output requirements
+- Focused on immediate application
+- Added concrete examples
+- Structured for progressive disclosure
+
+**Preserved from original:**
+- Core problem-solving techniques
+- Recognition patterns
+- Application processes
+- Fundamental insights