Initial commit

.claude-plugin/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "001-jeremy-taskwarrior-integration",
+  "description": "Enforces complete Taskwarrior integration protocol for ALL coding tasks. Automatically activates when user mentions 'taskwarrior' to decompose work into tracked tasks with proper lifecycle management (task add → task start → code implementation → task done). Includes time tracking via Timewarrior integration.",
+  "version": "1.0.0",
+  "author": {
+    "name": "Jeremy Longshore",
+    "email": "jeremy@intentsolutions.io"
+  },
+  "skills": [
+    "./skills"
+  ],
+  "commands": [
+    "./commands"
+  ]
+}

README.md

@@ -0,0 +1,3 @@
+# 001-jeremy-taskwarrior-integration
+
+Enforces complete Taskwarrior integration protocol for ALL coding tasks. Automatically activates when user mentions 'taskwarrior' to decompose work into tracked tasks with proper lifecycle management (task add → task start → code implementation → task done). Includes time tracking via Timewarrior integration.

commands/taskwarrior-protocol.md

@@ -0,0 +1,590 @@
+---
+name: taskwarrior-protocol
+description: Manually enforce complete Taskwarrior integration protocol with full task lifecycle management and time tracking
+model: sonnet
+---
+
+# Taskwarrior Integration Protocol - Manual Enforcement
+
+Enforce the complete Taskwarrior integration protocol for the current coding request.
+
+## Protocol Overview
+
+This command enforces a **mandatory 4-phase workflow** for ALL coding activities:
+
+1. **Phase 1: Task Decomposition** - Create Taskwarrior tasks BEFORE writing code
+2. **Phase 2: Task Activation** - Start tasks to begin time tracking
+3. **Phase 3: Implementation** - Write code with proper annotations
+4. **Phase 4: Completion** - Complete tasks and show time summary
+
+**CRITICAL RULE: NO CODE IS WRITTEN until Taskwarrior tasks are created and started.**
+
+## Phase 1: Task Decomposition
+
+Analyze the user's request and create appropriate Taskwarrior tasks.
+
+### Simple Request (1 task)
+
+```bash
+task add "Brief description" project:ProjectName priority:H/M/L due:today/tomorrow/YYYY-MM-DD +tag1 +tag2 +tag3
+```
+
+### Complex Request (multiple dependent tasks)
+
+```bash
+# Parent task
+task add "Main goal" project:ProjectName priority:H due:5days +architecture
+
+# Dependent subtasks
+task add "Subtask 1" project:ProjectName depends:1 priority:H due:1day +implementation
+task add "Subtask 2" project:ProjectName depends:2 priority:M due:2days +testing
+task add "Subtask 3" project:ProjectName depends:3 priority:L due:5days +documentation
+```
+
+### Required Attributes
+
+Every task MUST include:
+
+- **project:** Category for the work (project:DevOps, project:WebDev, project:DataScience)
+- **priority:** H (high/urgent), M (medium/normal), L (low/deferred)
+- **due:** Realistic deadline (today, tomorrow, YYYY-MM-DD, or relative like 3days)
+- **tags:** At least 2-3 relevant tags for filtering and reporting
+
+### Priority Assignment Rules
+
+**priority:H** - Use when:
+- Blocking other work
+- Production outage or critical bug
+- Security vulnerability
+- Hard deadline within 24-48 hours
+
+**priority:M** - Use when:
+- Normal feature development (DEFAULT)
+- Non-blocking improvements
+- Deadline within 3-7 days
+
+**priority:L** - Use when:
+- Nice-to-have enhancements
+- Documentation updates
+- No specific deadline
+
+### Common Tag Taxonomy
+
+**Work Type Tags:**
+- `+feature` - New functionality
+- `+bugfix` - Fixing issues
+- `+refactor` - Code restructuring
+- `+testing` - Test creation
+- `+documentation` - Docs and comments
+- `+deployment` - Release work
+- `+security` - Security-related
+- `+performance` - Optimization
+- `+debugging` - Investigation
+- `+maintenance` - Routine upkeep
+- `+automation` - Scripting/tooling
+
+**Technology Tags:**
+- `+python`, `+javascript`, `+bash`, `+typescript`
+- `+docker`, `+kubernetes`, `+cicd`
+- `+postgresql`, `+redis`, `+api`
+- `+fastapi`, `+react`, `+nextjs`
+
+**Status Tags:**
+- `+blocked` - Cannot proceed
+- `+urgent` - Immediate attention
+- `+waiting` - Awaiting input
+- `+review` - Ready for review
+
+## Phase 2: Task Activation & Time Tracking
+
+After creating tasks, activate them:
+
+```bash
+# Start the first task (or first in dependency chain)
+task <ID> start
+
+# Verify task is active
+task active
+
+# Verify Timewarrior tracking
+timew
+```
+
+**What happens:**
+- Task status changes to "started"
+- Timewarrior begins tracking time with task tags
+- Urgency score increases for active tasks
+
+## Phase 3: Code Implementation
+
+**NOW proceed with writing code.**
+
+### During Implementation
+
+**Annotate important decisions:**
+```bash
+task <ID> annotate "Decision: Using FastAPI over Flask for async support"
+task <ID> annotate "Found performance issue in database query"
+```
+
+**If encountering blockers:**
+```bash
+# Stop the task temporarily
+task <ID> stop
+
+# Document the blocker
+task <ID> annotate "Blocked: Need AWS credentials from ops team"
+
+# Mark as blocked
+task <ID> modify +blocked
+
+# Explain blocker to user and wait for resolution
+```
+
+**If scope changes:**
+```bash
+# Update existing task
+task <ID> modify +additional_tag description:"Updated description"
+
+# Or create dependent subtask
+task add "Additional work: Email notifications" depends:<ID> project:SameProject +feature
+```
+
+## Phase 4: Task Completion
+
+After code is delivered and verified:
+
+```bash
+# Complete the task
+task <ID> done
+
+# Timewarrior automatically stops tracking
+
+# Show time summary
+timew summary :ids
+
+# Check remaining work
+task next
+```
+
+### Completion Checklist
+
+Before marking task as done:
+- ✅ Code is written and tested
+- ✅ Documentation updated (if applicable)
+- ✅ Task annotations reflect final state
+- ✅ Blockers resolved or escalated
+- ✅ Time tracking accurate
+
+### Post-Completion Report
+
+Provide user with:
+```bash
+# Task details
+task <ID> info
+
+# Time spent
+timew summary :ids
+
+# Project status
+task project:<ProjectName> status:pending
+task project:<ProjectName> completed
+
+# Next tasks (if any dependencies)
+task next
+```
+
+## Example Workflows
+
+### Example 1: Simple Script Creation
+
+**User Request:** "Create a Bash script that backs up /home to /backup"
+
+**Phase 1: Decomposition**
+```bash
+task add "Create home directory backup script" project:DevOps priority:M due:today +scripting +automation +backup
+```
+
+**Phase 2: Activation**
+```bash
+task 42 start
+timew  # Verify tracking
+```
+
+**Phase 3: Implementation**
+```bash
+[Write backup.sh script with error handling, logging, etc.]
+```
+
+**Phase 4: Completion**
+```bash
+task 42 done
+timew summary :ids
+```
+
+**Output:**
+```
+Task 42 completed: Create home directory backup script
+Time spent: 15 minutes
+Project: DevOps
+Tags: scripting, automation, backup
+```
+
+### Example 2: Complex Multi-Component Project
+
+**User Request:** "Build a REST API with JWT authentication and PostgreSQL"
+
+**Phase 1: Decomposition**
+```bash
+# Parent task
+task add "Build REST API with authentication" project:WebDev priority:H due:5days +api +backend
+
+# Subtasks with dependencies
+task add "Design PostgreSQL schema" project:WebDev depends:43 priority:H due:1day +database +design
+task add "Implement JWT authentication" project:WebDev depends:44 priority:H due:2days +auth +security +jwt
+task add "Create CRUD endpoints" project:WebDev depends:45 priority:M due:3days +crud +endpoints
+task add "Write API documentation" project:WebDev depends:46 priority:L due:5days +documentation +openapi
+```
+
+**Phase 2: Activation (Sequential)**
+```bash
+task 44 start  # Start with database schema
+```
+
+**Phase 3: Implementation**
+```bash
+[Implement database schema]
+task 44 annotate "Using Alembic for migrations"
+task 44 done
+
+task 45 start  # Next: JWT auth
+[Implement JWT authentication]
+task 45 done
+
+# Continue through dependency chain...
+```
+
+**Phase 4: Completion (After all subtasks)**
+```bash
+task 43 done  # Complete parent task
+
+# Show project summary
+task project:WebDev completed
+timew summary project:WebDev :ids
+```
+
+### Example 3: Debugging Investigation
+
+**User Request:** "My app crashes with ECONNREFUSED, help debug"
+
+**Phase 1: Decomposition**
+```bash
+task add "Debug ECONNREFUSED crash" project:Debugging priority:H due:today +debugging +urgent +investigation +nodejs
+```
+
+**Phase 2: Activation**
+```bash
+task 50 start
+```
+
+**Phase 3: Implementation**
+```bash
+task 50 annotate "Error occurs during PostgreSQL connection"
+[Analyze error, check logs, test solutions]
+task 50 annotate "Root cause: PostgreSQL service not running"
+task 50 annotate "Solution: systemctl start postgresql + auto-start configuration"
+```
+
+**Phase 4: Completion**
+```bash
+task 50 done
+timew summary :ids
+```
+
+### Example 4: Recurring Maintenance
+
+**User Request:** "Script to clean Docker images weekly"
+
+**Phase 1: Decomposition**
+```bash
+task add "Weekly Docker cleanup script" project:Maintenance recur:weekly due:friday priority:M +automation +docker +cleanup
+```
+
+**Phase 2: Activation**
+```bash
+task 55 start
+```
+
+**Phase 3: Implementation**
+```bash
+[Write docker-cleanup.sh with:
+- Remove dangling images
+- Remove unused volumes
+- Remove stopped containers older than 7 days
+- Log cleanup results]
+```
+
+**Phase 4: Completion**
+```bash
+task 55 done
+
+# Note: Task will auto-generate next Friday
+task next  # Shows next week's instance
+```
+
+## Handling Special Scenarios
+
+### Scenario 1: User Has Existing Task
+
+**User:** "Help me complete task 42: 'Optimize database queries'"
+
+**Response:**
+```bash
+# Use user's existing task
+task 42 start
+
+[Provide optimization recommendations]
+
+task 42 annotate "Added indexes on user_id and created_at columns"
+task 42 annotate "Query time reduced from 2.3s to 45ms"
+task 42 done
+```
+
+### Scenario 2: Mid-Task Scope Change
+
+**User:** "Also add email notifications when backup completes"
+
+**Response:**
+```bash
+# Modify existing task to reflect expanded scope
+task 42 modify +email +notifications
+
+# Or create dependent subtask
+task add "Add email notifications to backup script" depends:42 project:DevOps priority:M +email +notifications
+```
+
+### Scenario 3: Blocked Task
+
+**Situation:** Cannot proceed due to missing credentials/permissions
+
+**Response:**
+```bash
+# Stop the task
+task 50 stop
+
+# Document the blocker
+task 50 annotate "Blocked: Need AWS S3 credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)"
+
+# Mark as blocked
+task 50 modify +blocked
+
+# Inform user
+"This task is blocked. Please provide AWS credentials to continue."
+```
+
+### Scenario 4: Multi-Session Work
+
+**Session 1:**
+```bash
+task add "Build e-commerce platform - product catalog" project:Ecommerce priority:H due:3days +feature +catalog
+task 60 start
+[Implement product catalog]
+task 60 done
+```
+
+**Session 2 (later):**
+```bash
+# Check existing work
+task project:Ecommerce list
+
+# Create related task
+task add "Build e-commerce platform - shopping cart" project:Ecommerce depends:60 priority:H +feature +cart
+task 61 start
+[Implement shopping cart]
+task 61 done
+```
+
+## Verification Requirements
+
+Before delivering code, verify:
+
+✅ **Task Created** - Task exists with proper attributes
+```bash
+task <ID> info  # Should show project, priority, tags, due date
+```
+
+✅ **Task Started** - Task is active
+```bash
+task active  # Should list your task
+```
+
+✅ **Time Tracking Active** - Timewarrior is running
+```bash
+timew  # Should show current tracking
+```
+
+✅ **Code Implemented** - Solution is complete and tested
+
+✅ **Task Completed** - Task marked done
+```bash
+task completed | grep "<description>"
+```
+
+✅ **Time Summary Shown** - User sees time spent
+```bash
+timew summary :ids
+```
+
+## Enforcement Rules
+
+### MANDATORY RULES:
+
+1. **NO CODE BEFORE TASKS** - Always create tasks FIRST
+2. **ALWAYS START TASKS** - Activate time tracking
+3. **ALWAYS COMPLETE TASKS** - Mark as done when finished
+4. **USE PROPER ATTRIBUTES** - Every task needs project:, priority:, due:, tags:
+5. **RESPECT DEPENDENCIES** - Work in order
+6. **ANNOTATE DECISIONS** - Document key choices
+7. **HANDLE BLOCKERS** - Stop and mark as +blocked
+
+### REFUSAL PROTOCOL:
+
+If user requests code without proper task setup:
+
+**DO NOT** write code immediately.
+
+**INSTEAD:**
+
+```
+Before implementing this, I need to create a Taskwarrior task to track the work properly.
+
+I'll decompose this as:
+
+task add "[description]" project:[ProjectName] priority:M due:today +[tag1] +[tag2]
+
+Then I'll start the task and implement the solution.
+
+[Proceed with proper protocol]
+```
+
+## Integration Features
+
+### Timewarrior Time Tracking
+
+Automatically integrated when tasks are started:
+
+```bash
+# When you start a task
+task <ID> start
+# → Timewarrior begins tracking with task tags
+
+# Check current tracking
+timew
+
+# View time reports
+timew summary :ids              # Total per task
+timew report :ids :week         # Weekly breakdown
+timew day                       # Today's time
+```
+
+### Dependency Management
+
+For complex projects with ordered steps:
+
+```bash
+# Create dependency chain
+task add "Step 1" project:Project priority:H
+task add "Step 2" depends:1 project:Project priority:M
+task add "Step 3" depends:2 project:Project priority:M
+
+# Only Step 1 is ready to start
+task ready  # Shows tasks with no pending dependencies
+
+# After completing Step 1, Step 2 becomes ready
+```
+
+### Task Modification
+
+Update tasks as requirements evolve:
+
+```bash
+# Change priority
+task <ID> modify priority:H
+
+# Add tags
+task <ID> modify +urgent +critical
+
+# Update description
+task <ID> modify description:"New description"
+
+# Extend deadline
+task <ID> modify due:+3days
+```
+
+## Quick Reference Commands
+
+| Operation | Command |
+|-----------|---------|
+| Create task | `task add "description" project:Name priority:M due:today +tag1 +tag2` |
+| Start task | `task <ID> start` |
+| Stop task | `task <ID> stop` |
+| Complete task | `task <ID> done` |
+| View active | `task active` |
+| View next tasks | `task next` |
+| Task details | `task <ID> info` |
+| Annotate task | `task <ID> annotate "note"` |
+| Modify task | `task <ID> modify priority:H +tag` |
+| List by project | `task project:ProjectName list` |
+| Show completed | `task completed` |
+| Current time tracking | `timew` |
+| Time summary | `timew summary :ids` |
+
+## Success Metrics
+
+After completing work, provide:
+
+```bash
+# Individual task metrics
+task <ID> info
+timew summary :ids
+
+# Project-level metrics
+task project:<ProjectName> completed count
+task project:<ProjectName> status:pending count
+
+# Personal productivity
+task completed count
+task active count
+timew summary :week
+```
+
+## Output Format
+
+After completing all phases, provide user with:
+
+```markdown
+## Taskwarrior Integration Complete
+
+### Tasks Created
+- Task 42: "Create home directory backup script"
+  - Project: DevOps
+  - Priority: M
+  - Due: 2025-10-23
+  - Tags: scripting, automation, backup
+
+### Implementation Summary
+[Brief description of code delivered]
+
+### Time Spent
+- Task 42: 15 minutes
+
+### Task Status
+✅ Task 42 completed successfully
+
+### Next Steps
+[Any remaining work or follow-up tasks]
+```
+
+---
+
+**This protocol ensures every coding activity is properly tracked, time-accounted, and managed through Taskwarrior's powerful task management system.**

plugin.lock.json

@@ -0,0 +1,61 @@
+{
+  "$schema": "internal://schemas/plugin.lock.v1.json",
+  "pluginId": "gh:jeremylongshore/claude-code-plugins-plus:plugins/productivity/001-jeremy-taskwarrior-integration",
+  "normalized": {
+    "repo": null,
+    "ref": "refs/tags/v20251128.0",
+    "commit": "2806927bbf394a514ad2ee4ec22ce70c8071ad54",
+    "treeHash": "f0459c174da19c5f00ff509d95d6a53bb1cf15e9ec2ae0276d12b6a02ce91852",
+    "generatedAt": "2025-11-28T10:18:01.627110Z",
+    "toolVersion": "publish_plugins.py@0.2.0"
+  },
+  "origin": {
+    "remote": "git@github.com:zhongweili/42plugin-data.git",
+    "branch": "master",
+    "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390",
+    "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data"
+  },
+  "manifest": {
+    "name": "001-jeremy-taskwarrior-integration",
+    "description": "Enforces complete Taskwarrior integration protocol for ALL coding tasks. Automatically activates when user mentions 'taskwarrior' to decompose work into tracked tasks with proper lifecycle management (task add → task start → code implementation → task done). Includes time tracking via Timewarrior integration.",
+    "version": "1.0.0"
+  },
+  "content": {
+    "files": [
+      {
+        "path": "README.md",
+        "sha256": "c4daeb4e086228557efc17f2a2c50119bd20e430fc1699f594d914023c8faebf"
+      },
+      {
+        "path": ".claude-plugin/plugin.json",
+        "sha256": "8f52f4745b09310405488897de90bf5817710815bddd6dd59e63b2f60dd02637"
+      },
+      {
+        "path": "commands/taskwarrior-protocol.md",
+        "sha256": "55f7643cfbc4628730fdb646576a89bba70aeae601fe739d005a03e556751ef9"
+      },
+      {
+        "path": "skills/001-jeremy-taskwarrior-integration/SKILL.md",
+        "sha256": "d2c0ee522a3d0e905306025f95887401a383ef80313389257b46338c669e092d"
+      },
+      {
+        "path": "skills/001-jeremy-taskwarrior-integration/references/README.md",
+        "sha256": "db9680278e03728fef93321fc76c435387bc0c8fe1dcc9870bdf2fa236ea8ac3"
+      },
+      {
+        "path": "skills/001-jeremy-taskwarrior-integration/scripts/README.md",
+        "sha256": "f042646ad5b685556c044080a6b73202a490fb8288be8219328faefc12d5a30e"
+      },
+      {
+        "path": "skills/001-jeremy-taskwarrior-integration/assets/README.md",
+        "sha256": "33bfb083485b48c78a1738368c52cd9f202724a414bce507db181d8291b83aec"
+      }
+    ],
+    "dirSha256": "f0459c174da19c5f00ff509d95d6a53bb1cf15e9ec2ae0276d12b6a02ce91852"
+  },
+  "security": {
+    "scannedAt": null,
+    "scannerVersion": null,
+    "flags": []
+  }
+}

skills/001-jeremy-taskwarrior-integration/SKILL.md

@@ -0,0 +1,589 @@
+---
+name: 001-jeremy-taskwarrior-integration
+description: |
+  Enforces complete Taskwarrior integration protocol for ALL coding tasks. Activates automatically when user mentions "taskwarrior", "task warrior", "tw", or discusses task management. Decomposes all coding work into properly tracked Taskwarrior tasks with full lifecycle: task add → task start → implementation → task done. Integrates with Timewarrior for automatic time tracking.
+allowed-tools: Read, WebFetch, WebSearch, Grep
+version: 1.0.0
+---
+
+## What This Skill Does
+
+This skill **enforces mandatory Taskwarrior integration** for ALL coding activities. It ensures every piece of work is:
+
+1. **Decomposed** into trackable Taskwarrior tasks BEFORE code is written
+2. **Tracked** with proper attributes (project, priority, due date, tags)
+3. **Time-accounted** via automatic Timewarrior integration
+4. **Dependency-managed** for complex multi-step projects
+5. **Completed** with proper task lifecycle (add → start → done)
+
+**CRITICAL: NO CODE IS WRITTEN until Taskwarrior tasks are created and started.**
+
+## When This Skill Activates
+
+Trigger this skill when you mention:
+- "taskwarrior"
+- "task warrior"
+- "tw" (as abbreviation)
+- "create a task for this"
+- "track this work"
+- "add to taskwarrior"
+- "start a task"
+- "task management"
+- "time tracking"
+
+## Complete Taskwarrior Integration Protocol
+
+### Phase 1: Task Decomposition (MANDATORY FIRST STEP)
+
+**Before writing ANY code**, decompose the request into Taskwarrior tasks:
+
+**For Simple Requests (1 task):**
+```bash
+task add "Brief description of work" project:ProjectName priority:H/M/L due:today/tomorrow/YYYY-MM-DD +tag1 +tag2
+```
+
+**For Complex Requests (multiple tasks with dependencies):**
+```bash
+# Parent task
+task add "Main project goal" project:ProjectName priority:H due:3days +architecture +planning
+
+# Subtasks with dependencies
+task add "Subtask 1" project:ProjectName depends:1 priority:M +implementation
+task add "Subtask 2" project:ProjectName depends:2 priority:M +testing
+task add "Subtask 3" project:ProjectName depends:3 priority:L +documentation
+```
+
+**Required Task Attributes:**
+- **project:** Categorize the work (e.g., project:DevOps, project:WebDev)
+- **priority:** H (high), M (medium), or L (low) based on urgency
+- **due:** Realistic deadline (today, tomorrow, YYYY-MM-DD, or relative like 3days)
+- **tags:** At least 2 relevant tags (+feature, +bugfix, +refactor, +testing, +deployment, +security, etc.)
+
+### Phase 2: Task Activation & Time Tracking
+
+**After creating tasks**, activate them to start time tracking:
+
+```bash
+# Start the first task in the dependency chain
+task <ID> start
+
+# Verify task is active
+task active
+
+# Timewarrior should automatically begin tracking
+timew
+```
+
+**What happens:**
+- Taskwarrior marks task as started
+- Timewarrior begins tracking time spent
+- Task appears in `task active` list
+- Urgency score increases for started tasks
+
+### Phase 3: Code Implementation
+
+**Now and ONLY now** proceed with writing code:
+
+1. Implement the solution following best practices
+2. Annotate task with key decisions or blockers:
+```bash
+task <ID> annotate "Decision: Using FastAPI over Flask for async support"
+task <ID> annotate "Blocker: Waiting for API credentials"
+```
+
+3. If blocked, stop the task temporarily:
+```bash
+task <ID> stop
+task <ID> modify +blocked
+```
+
+4. If scope changes mid-implementation:
+```bash
+task <ID> modify +additional_tag description:"Updated description"
+```
+
+### Phase 4: Task Completion
+
+**After code is delivered and verified**, complete the task:
+
+```bash
+# Complete the task
+task <ID> done
+
+# Timewarrior automatically stops tracking
+# View time summary for this task
+timew summary :ids
+
+# Check if dependent tasks are now unblocked
+task next
+```
+
+**Completion Checklist:**
+- ✅ Code is written and tested
+- ✅ Documentation is updated (if applicable)
+- ✅ Task annotations reflect final state
+- ✅ Any blockers are resolved or escalated
+- ✅ Time tracking is accurate
+
+### Phase 5: Verification & Reporting
+
+**After completing tasks**, provide summary:
+
+```bash
+# Show completed task details
+task <ID> info
+
+# Show time spent
+timew summary :ids
+
+# Show remaining work
+task next
+```
+
+## Task Decomposition Examples
+
+### Example 1: Simple Single-File Script
+
+**User Request:** "Create a Bash script that backs up my home directory"
+
+**Task Decomposition:**
+```bash
+task add "Create home directory backup script" project:DevOps priority:M due:today +scripting +automation +backup
+```
+
+**Lifecycle:**
+```bash
+task 42 start
+[Write backup.sh script]
+task 42 done
+timew summary :ids
+```
+
+### Example 2: Complex Multi-Component Feature
+
+**User Request:** "Build a REST API with authentication, user management, and PostgreSQL"
+
+**Task Decomposition:**
+```bash
+# Parent task
+task add "Build FastAPI REST API with auth" project:WebDev priority:H due:5days +api +backend
+
+# Dependent subtasks
+task add "Design PostgreSQL schema" project:WebDev depends:43 priority:H due:1day +database +design
+task add "Implement JWT authentication" project:WebDev depends:44 priority:H due:2days +auth +security
+task add "Create user management endpoints" project:WebDev depends:45 priority:M due:3days +crud +endpoints
+task add "Write API documentation" project:WebDev depends:46 priority:L due:5days +documentation +openapi
+task add "Deploy to staging environment" project:WebDev depends:47 priority:M due:5days +deployment +staging
+```
+
+**Lifecycle:**
+```bash
+task 44 start  # Start with database schema
+[Design and implement schema]
+task 44 done
+
+task 45 start  # Next: authentication
+[Implement JWT auth]
+task 45 done
+
+# Continue through dependency chain...
+```
+
+### Example 3: Debugging Investigation
+
+**User Request:** "My Node.js app crashes with ECONNREFUSED"
+
+**Task Decomposition:**
+```bash
+task add "Debug ECONNREFUSED error in Node.js app" project:Debugging priority:H due:today +debugging +nodejs +urgent +investigation
+```
+
+**Lifecycle with Annotations:**
+```bash
+task 50 start
+task 50 annotate "Error occurs during PostgreSQL connection"
+task 50 annotate "Root cause: PostgreSQL service not running"
+task 50 annotate "Solution: systemctl start postgresql"
+[Provide debugging steps and code fixes]
+task 50 done
+```
+
+### Example 4: Recurring Maintenance Task
+
+**User Request:** "Create a script I need to run weekly to clean Docker images"
+
+**Task Decomposition:**
+```bash
+task add "Weekly Docker cleanup script" project:Maintenance recur:weekly due:friday priority:M +automation +docker +cleanup
+```
+
+**Lifecycle:**
+```bash
+task 55 start
+[Write docker-cleanup.sh script]
+task 55 done
+
+# Future instances auto-generate every Friday
+task next  # Will show next week's instance
+```
+
+## Task Priority Guidelines
+
+Use this urgency matrix to assign priority:
+
+**priority:H (High) - Use when:**
+- Blocking other work
+- Production outage or critical bug
+- Security vulnerability
+- Hard deadline within 24-48 hours
+- Explicitly marked as urgent by user
+
+**priority:M (Medium) - Use when:**
+- Normal feature development
+- Non-blocking improvements
+- Deadline within 3-7 days
+- Standard maintenance work
+- Default for most tasks
+
+**priority:L (Low) - Use when:**
+- Nice-to-have enhancements
+- Documentation updates
+- Refactoring for cleanliness (not performance)
+- No specific deadline
+- Can be deferred without impact
+
+## Tag Taxonomy
+
+**Common Project Tags:**
+- `+feature` - New functionality
+- `+bugfix` - Fixing existing issues
+- `+refactor` - Code restructuring
+- `+testing` - Test creation/execution
+- `+documentation` - Docs and comments
+- `+deployment` - Release and infrastructure
+- `+security` - Security-related work
+- `+performance` - Optimization work
+- `+debugging` - Investigation and diagnosis
+- `+maintenance` - Routine upkeep
+- `+automation` - Scripting and tooling
+- `+infrastructure` - DevOps and systems
+
+**Technology Tags:**
+- `+python`, `+javascript`, `+bash`, `+typescript`
+- `+docker`, `+kubernetes`, `+cicd`
+- `+postgresql`, `+redis`, `+mongodb`
+- `+fastapi`, `+react`, `+nextjs`
+
+**Status Tags:**
+- `+blocked` - Cannot proceed (annotate reason)
+- `+urgent` - Needs immediate attention
+- `+waiting` - Awaiting external input
+- `+review` - Ready for review
+
+## Handling Special Scenarios
+
+### Scenario 1: Mid-Task Scope Change
+
+If requirements change while working:
+
+```bash
+# Modify existing task
+task <ID> modify +new_tag description:"Updated description"
+
+# Or create dependent subtask for additional work
+task add "Additional scope: Email notifications" depends:<ID> project:SameProject +feature
+```
+
+### Scenario 2: Blocked Work
+
+If encountering blockers (missing credentials, API limits, permissions):
+
+```bash
+# Stop the task
+task <ID> stop
+
+# Annotate the blocker
+task <ID> annotate "Blocked: Need AWS credentials from ops team"
+
+# Mark as blocked
+task <ID> modify +blocked
+
+# Explain to user what's needed to unblock
+```
+
+### Scenario 3: Multi-Session Work
+
+For work spanning multiple conversations:
+
+**Session 1:**
+```bash
+task add "Build e-commerce platform - product catalog" project:Ecommerce priority:H +feature
+task 60 start
+[Implement product catalog]
+task 60 done
+```
+
+**Session 2 (later):**
+```bash
+# Check existing project tasks
+task project:Ecommerce status:pending
+
+# Create related task
+task add "Build e-commerce platform - shopping cart" project:Ecommerce depends:60 priority:H +feature
+task 61 start
+[Implement shopping cart]
+task 61 done
+```
+
+### Scenario 4: Working with User's Existing Tasks
+
+If user references an existing Taskwarrior task:
+
+**User:** "Help me complete task 42: 'Optimize database queries'"
+
+**Response:**
+```bash
+# Start user's existing task
+task 42 start
+
+[Provide optimization recommendations and code]
+
+# Complete user's task
+task 42 done
+
+# Show results
+task 42 info
+timew summary :ids
+```
+
+## Integration with Timewarrior
+
+Taskwarrior automatically integrates with Timewarrior when configured. Here's what happens:
+
+**When you start a task:**
+```bash
+task <ID> start
+# Timewarrior begins tracking with tags from the task
+```
+
+**Check current tracking:**
+```bash
+timew  # Shows what's currently being tracked
+task active  # Shows active Taskwarrior tasks
+```
+
+**Stop tracking (when you stop or complete a task):**
+```bash
+task <ID> stop  # Pauses tracking
+task <ID> done  # Stops tracking and completes task
+```
+
+**View time reports:**
+```bash
+timew summary :ids              # Total time per task
+timew report :ids :week         # This week's breakdown
+timew tags                      # Most-used tags
+timew day                       # Today's time usage
+```
+
+## Workflow Enforcement Rules
+
+### MANDATORY RULES:
+
+1. **NO CODE BEFORE TASKS** - Always run `task add` BEFORE writing any code
+2. **ALWAYS START TASKS** - Run `task <ID> start` to activate time tracking
+3. **ALWAYS COMPLETE TASKS** - Run `task <ID> done` when work is delivered
+4. **USE PROPER ATTRIBUTES** - Every task needs project:, priority:, due:, and tags:
+5. **RESPECT DEPENDENCIES** - Work tasks in order defined by `depends:` relationships
+6. **ANNOTATE DECISIONS** - Use `task <ID> annotate` to document key choices
+7. **HANDLE BLOCKERS EXPLICITLY** - Stop tasks and mark as +blocked when stuck
+
+### VERIFICATION CHECKLIST:
+
+Before delivering code, confirm:
+- ✅ Task was created with proper attributes
+- ✅ Task was started (appears in `task active`)
+- ✅ Time tracking is running (verify with `timew`)
+- ✅ Code is implemented and tested
+- ✅ Task is completed with `task done`
+- ✅ Time summary is shown
+
+## Refusing Non-Compliant Requests
+
+If user asks for code without mentioning Taskwarrior, **proactively enforce the protocol**:
+
+**User:** "Write me a Python script to parse CSV files"
+
+**Your Response:**
+```
+Before I write the code, I need to create a Taskwarrior task to track this work properly.
+
+I'll decompose this as:
+task add "Create CSV parser Python script" project:DataProcessing priority:M due:today +python +scripting +parsing
+
+Then I'll start the task and implement the solution.
+
+[Proceed with task creation → task start → code implementation → task done]
+```
+
+## Success Metrics
+
+After completing work, provide these metrics:
+
+```bash
+# Task details
+task <ID> info
+
+# Time spent
+timew summary :ids
+
+# Project progress
+task project:<ProjectName> completed
+task project:<ProjectName> status:pending
+
+# Personal productivity
+task completed count
+task active count
+```
+
+## Quick Reference Commands
+
+| Operation | Command |
+|-----------|---------|
+| **Create task** | `task add "description" project:Name priority:M due:today +tag1 +tag2` |
+| **Start task** | `task <ID> start` |
+| **Stop task** | `task <ID> stop` |
+| **Complete task** | `task <ID> done` |
+| **View active tasks** | `task active` |
+| **View next tasks** | `task next` |
+| **Modify task** | `task <ID> modify priority:H +new_tag` |
+| **Annotate task** | `task <ID> annotate "note"` |
+| **View task details** | `task <ID> info` |
+| **List by project** | `task project:ProjectName list` |
+| **Show time tracking** | `timew` |
+| **Time summary** | `timew summary :ids` |
+| **Weekly report** | `timew report :ids :week` |
+
+## Expected User Workflow
+
+**Typical Interaction:**
+
+**User:** "I need help with taskwarrior - create a FastAPI authentication system"
+
+**Your Response:**
+```
+I'll enforce the Taskwarrior integration protocol for this work.
+
+## Phase 1: Task Decomposition
+
+Creating tasks for FastAPI authentication system:
+
+task add "Build FastAPI authentication system" project:WebDev priority:H due:2days +fastapi +auth +security +backend
+task add "Implement JWT token generation" project:WebDev depends:1 priority:H +jwt +auth
+task add "Create login/logout endpoints" project:WebDev depends:2 priority:M +endpoints +api
+task add "Add password hashing with bcrypt" project:WebDev depends:3 priority:M +security +passwords
+task add "Write authentication tests" project:WebDev depends:4 priority:M +testing +pytest
+
+## Phase 2: Task Activation
+
+task 1 start
+timew  # Verify tracking started
+
+## Phase 3: Implementation
+
+[Now I'll implement the authentication system...]
+
+[Provide complete FastAPI auth code]
+
+## Phase 4: Completion
+
+task 1 done
+timew summary :ids
+
+Total time: 45 minutes
+Next task: Implement JWT token generation (task 2)
+```
+
+## Best Practices
+
+### ✅ DO:
+- Create tasks for EVERY coding activity, no matter how small
+- Use descriptive task names that explain the "what" and "why"
+- Set realistic due dates based on complexity
+- Add multiple relevant tags for better filtering
+- Annotate tasks with important decisions or blockers
+- Leverage the dependency system for related work
+- Complete tasks when work is done (don't leave tasks hanging)
+- Review `task next` regularly to prioritize work
+
+### ❌ DON'T:
+- Skip task creation for "quick" tasks
+- Write code before creating and starting tasks
+- Use generic descriptions ("Fix bug" vs. "Fix OAuth redirect loop")
+- Ignore the dependency system
+- Leave tasks incomplete after delivering code
+- Forget to stop/complete tasks when switching contexts
+- Use priority:H for everything (dilutes urgency)
+
+## Troubleshooting
+
+### Issue: "Task not tracking time"
+
+**Solution:**
+```bash
+# Verify Timewarrior is installed
+which timew
+
+# Check if task is active
+task active
+
+# Manually start tracking if needed
+timew start +tag1 +tag2
+```
+
+### Issue: "Can't find task ID"
+
+**Solution:**
+```bash
+# List all tasks
+task list
+
+# Show task details by description search
+task /keyword/ list
+
+# Show recently completed tasks
+task completed
+```
+
+### Issue: "Forgot to start task before coding"
+
+**Solution:**
+```bash
+# Start the task now (retroactively)
+task <ID> start
+
+# Manually adjust Timewarrior if needed
+timew track yesterday 2:00pm - 3:30pm +projecttag +featuretag
+```
+
+## Integration with Your Workflow
+
+This skill integrates seamlessly with:
+- **VS Code Taskwarrior extensions** - See tasks in your editor sidebar
+- **CI/CD pipelines** - Auto-create tasks for deployments
+- **Git workflows** - Reference task IDs in commit messages
+- **Team collaboration** - Shared Taskwarrior server for team visibility
+- **Reporting tools** - Export to JSON for dashboards
+
+## Summary
+
+This skill enforces a **mandatory, comprehensive Taskwarrior integration** for ALL coding activities. It ensures:
+
+✅ Every piece of work is tracked as a task
+✅ Time spent is automatically accounted via Timewarrior
+✅ Complex projects are decomposed into manageable, linked subtasks
+✅ Complete audit trail of all work performed
+✅ Proper prioritization and deadline management
+✅ Full lifecycle from creation → activation → implementation → completion
+
+**NO CODE GETS WRITTEN without following the complete Taskwarrior protocol.**

skills/001-jeremy-taskwarrior-integration/assets/README.md

@@ -0,0 +1,26 @@
+# Skill Assets
+
+This directory contains static assets used by this skill.
+
+## Purpose
+
+Assets can include:
+- Configuration files (JSON, YAML)
+- Data files
+- Templates
+- Schemas
+- Test fixtures
+
+## Guidelines
+
+- Keep assets small and focused
+- Document asset purpose and format
+- Use standard file formats
+- Include schema validation where applicable
+
+## Common Asset Types
+
+- **config.json** - Configuration templates
+- **schema.json** - JSON schemas
+- **template.yaml** - YAML templates
+- **test-data.json** - Test fixtures

skills/001-jeremy-taskwarrior-integration/references/README.md

@@ -0,0 +1,26 @@
+# Skill References
+
+This directory contains reference materials that enhance this skill's capabilities.
+
+## Purpose
+
+References can include:
+- Code examples
+- Style guides
+- Best practices documentation
+- Template files
+- Configuration examples
+
+## Guidelines
+
+- Keep references concise and actionable
+- Use markdown for documentation
+- Include clear examples
+- Link to external resources when appropriate
+
+## Types of References
+
+- **examples.md** - Usage examples
+- **style-guide.md** - Coding standards
+- **templates/** - Reusable templates
+- **patterns.md** - Design patterns

skills/001-jeremy-taskwarrior-integration/scripts/README.md

@@ -0,0 +1,24 @@
+# Skill Scripts
+
+This directory contains optional helper scripts that support this skill's functionality.
+
+## Purpose
+
+Scripts here can be:
+- Referenced by the skill for automation
+- Used as examples for users
+- Executed during skill activation
+
+## Guidelines
+
+- All scripts should be well-documented
+- Include usage examples in comments
+- Make scripts executable (`chmod +x`)
+- Use `#!/bin/bash` or `#!/usr/bin/env python3` shebangs
+
+## Adding Scripts
+
+1. Create script file (e.g., `analyze.sh`, `process.py`)
+2. Add documentation header
+3. Make executable: `chmod +x script-name.sh`
+4. Test thoroughly before committing