taskgraph-ai 0.0.0-stage → 0.50.1

package/dist/init-CNSqtmPC.js

@@ -0,0 +1,3460 @@
+import{o as e}from"./ai-services-unified-DbjBfAvG.js";import{At as t,Ct as n,Dt as r,Mt as i,Ot as a,Pt as o,Tt as s,j as c,jt as l,kt as u,nt as d,tt as f,wt as ee,xt as p}from"./config-manager-Da0wEujO.js";import{r as m}from"./git-utils-CrYiSKu0.js";import{a as h,dt as g}from"./dependency-manager-DIbDdrUV.js";import _ from"chalk";import*as v from"node:path";import y from"path";import*as b from"node:fs";import{execSync as x}from"child_process";import S from"fs";import{fileURLToPath as C}from"url";import w from"boxen";import T from"readline";import te from"figlet";import ne from"gradient-string";import re from"ora";import ie from"os";import{randomUUID as ae}from"crypto";const E=[`claude`];function oe(e){return e.filter(e=>!se(e))}function se(e){return E.includes(e)}const D=`# Task files`,O=`tasks.json`,k=`tasks/`;function A(e){return e.trim().replace(/^#/,``).trim()}function j(e){let t=A(e);return t===O||t===k}function ce(e,t){return e.map(e=>{if(j(e)){let n=A(e),r=e.match(/\s*$/)[0];return t?`# ${n}${r}`:`${n}${r}`}return e})}function le(e){let t=[],n=!1;for(let r of e){if(r.trim()===D){n=!0;continue}j(r)||n&&!r.trim()||(n&&r.trim()&&!j(r)&&(n=!1),n||t.push(r))}return t}function ue(e,t){return e.filter(e=>{let n=e.trim();return!n||j(e)||n===D?!1:!t.has(n)})}function de(e){let t=[D];return e?t.push(`# ${O}`,`# ${k} `):t.push(O,`${k} `),t}function M(e){if(e.some(e=>e.trim())){let t=e[e.length-1];t&&t.trim()&&e.push(``)}}function fe(e,t,n){if(!e||typeof e!=`string`)throw Error(`targetPath must be a non-empty string`);if(!e.endsWith(`.gitignore`))throw Error(`targetPath must end with .gitignore`);if(!t||typeof t!=`string`)throw Error(`content must be a non-empty string`);if(typeof n!=`boolean`)throw Error(`storeTasksInGit must be a boolean`)}function pe(e,t,n){try{S.writeFileSync(e,t.join(`
+`)+`
+`),typeof n==`function`&&n(`success`,`Created ${e} with full template`)}catch(t){throw typeof n==`function`&&n(`error`,`Failed to create ${e}: ${t.message}`),t}}function me(e,t,n,r){try{let i=le(S.readFileSync(e,`utf8`).split(`
+`)),a=ue(t,new Set(i.map(e=>e.trim()).filter(e=>e))),o=[...i];a.length>0&&(M(o),o.push(...a)),M(o),o.push(...de(n)),S.writeFileSync(e,o.join(`
+`)+`
+`),typeof r==`function`&&r(`debug`,`Updated ${e} according to user preference${a.length>0?` and merged new content`:``}`)}catch(t){throw typeof r==`function`&&r(`error`,`Failed to merge content with ${e}: ${t.message}`),t}}function he(e,t,n=!0,r=null){fe(e,t,n);let i=ce(t.split(`
+`),n);S.existsSync(e)?me(e,i,n,r):pe(e,i,r)}const ge=C(import.meta.url),N=y.dirname(ge);function P(){let e=[y.join(N,`assets`),y.join(N,`..`,`assets`),y.join(N,`..`,`..`,`public`,`assets`),y.join(process.cwd(),`assets`),y.join(process.cwd(),`node_modules`,`taskgraph-ai`,`dist`,`assets`),y.join(process.cwd(),`node_modules`,`taskgraph-ai`,`assets`)];for(let t of e)if(S.existsSync(t)){let e=y.join(t,`AGENTS.md`);if(S.existsSync(e))return t}throw Error(`Assets directory not found. This is likely a packaging issue.`)}function F(e){let t=P();return y.join(t,e)}function I(e){try{let t=F(e);return S.existsSync(t)}catch{return!1}}function L(e,t=`utf8`){let n=F(e);return S.readFileSync(n,t)}const R=`taskgraph-ai`;function _e(e){return Array.isArray(e?.args)&&e.args.some(e=>typeof e==`string`&&e.includes(R))}function z(e){let t=JSON.stringify(e,null,`	`);return t=t.replace(/(\[\n\t+)([^[\]]+?)(\n\t+\])/g,(e,t,n,r)=>!n.includes(`{`)&&!n.includes(`[`)?`[${n.replace(/\n\t+/g,` `).replace(/\s+/g,` `).trim()}]`:e),t}function ve(e,t){if(!t){d(`debug`,`[MCP Config] No mcpConfigPath provided, skipping MCP configuration setup`);return}let n=y.join(e,t),r=y.dirname(n);d(`info`,`Setting up MCP configuration at ${n}...`);let i={[R]:{command:`npx`,args:[`-y`,R],env:{TASKGRAPH_TOOLS:`core`}}};if(S.existsSync(r)||S.mkdirSync(r,{recursive:!0}),S.existsSync(n)){d(`info`,`MCP configuration file already exists, checking for existing taskgraph-ai...`);try{let e=JSON.parse(S.readFileSync(n,`utf8`));if(e.mcpServers||={},Object.values(e.mcpServers).some(_e)){d(`info`,`Found existing taskgraph-ai MCP configuration in mcp.json, leaving untouched`);return}e.mcpServers[R]?d(`info`,`taskgraph-ai server already configured in mcp.json`):(e.mcpServers[R]=i[R],d(`info`,`Added taskgraph-ai server to existing MCP configuration`)),S.writeFileSync(n,z(e)+`
+`),d(`success`,`Updated MCP configuration file`)}catch(e){d(`error`,`Failed to update MCP configuration: ${e.message}`);let t=`${n}.backup-${Date.now()}`;S.existsSync(n)&&(S.copyFileSync(n,t),d(`info`,`Created backup of existing mcp.json at ${t}`));let r={mcpServers:i};S.writeFileSync(n,z(r)+`
+`),d(`warn`,`Created new MCP configuration file (backup of original file was created if it existed)`)}}else{let e={mcpServers:i};S.writeFileSync(n,z(e)+`
+`),d(`success`,`Created MCP configuration file at ${n}`)}d(`info`,`MCP server will use the installed taskgraph-ai package`)}function B(e){let{name:t,description:n,content:r,argumentHint:i,mode:a}=e;return{type:`static`,metadata:{name:t,description:n,...i&&{argumentHint:i},...a&&{mode:a}},content:r}}function V(e,t,n,r,i){if(!r.includes(`$ARGUMENTS`))throw Error(`Dynamic slash command "${e}" must contain $ARGUMENTS placeholder`);return{type:`dynamic`,metadata:{name:e,description:t,argumentHint:n,...i&&{mode:i}},content:r}}const ye=V(`parse-prd`,`Parse PRD`,`<prd-file>`,`Parse a PRD document to generate tasks.
+
+Arguments: $ARGUMENTS (PRD file path)
+
+## Intelligent PRD Parsing
+
+Analyzes your requirements document and generates a complete task breakdown.
+
+## Execution
+
+\`\`\`bash
+taskgraph parse-prd --input=$ARGUMENTS
+\`\`\`
+
+## Parsing Process
+
+1. **Document Analysis**
+   - Extract key requirements
+   - Identify technical components
+   - Detect dependencies
+   - Estimate complexity
+
+2. **Task Generation**
+   - Create 10-15 tasks by default
+   - Include implementation tasks
+   - Add testing tasks
+   - Include documentation tasks
+   - Set logical dependencies
+
+3. **Smart Enhancements**
+   - Group related functionality
+   - Set appropriate priorities
+   - Add acceptance criteria
+   - Include test strategies
+
+## Options
+
+Parse arguments for modifiers:
+- Number after filename → \`--num-tasks\`
+- \`research\` → Use research mode
+- \`comprehensive\` → Generate more tasks
+
+## Post-Generation
+
+After parsing:
+1. Display task summary
+2. Show dependency graph
+3. Suggest task expansion for complex items
+4. Recommend sprint planning`,`solo`),be=V(`parse-prd-with-research`,`Parse PRD With Research`,`<prd-file>`,`Parse PRD with enhanced research mode for better task generation.
+
+Arguments: $ARGUMENTS (PRD file path)
+
+## Research-Enhanced Parsing
+
+Uses the research role, which runs on Claude Code with web search and fetch access, for more comprehensive task generation with current best practices.
+
+## Execution
+
+\`\`\`bash
+taskgraph parse-prd --input=$ARGUMENTS --research
+\`\`\`
+
+## Research Benefits
+
+1. **Current Best Practices**
+   - Latest framework patterns
+   - Security considerations
+   - Performance optimizations
+   - Accessibility requirements
+
+2. **Technical Deep Dive**
+   - Implementation approaches
+   - Library recommendations
+   - Architecture patterns
+   - Testing strategies
+
+3. **Comprehensive Coverage**
+   - Edge cases consideration
+   - Error handling tasks
+   - Monitoring setup
+   - Deployment tasks
+
+## Enhanced Output
+
+Research mode typically:
+- Generates more detailed tasks
+- Includes industry standards
+- Adds compliance considerations
+- Suggests modern tooling
+
+## When to Use
+
+- New technology domains
+- Complex requirements
+- Regulatory compliance needed
+- Best practices crucial`,`solo`),xe=V(`analyze-complexity`,`Analyze Complexity`,`[options]`,`Analyze task complexity and generate expansion recommendations.
+
+Arguments: $ARGUMENTS
+
+Perform deep analysis of task complexity across the project.
+
+## Complexity Analysis
+
+Uses AI to analyze tasks and recommend which ones need breakdown.
+
+## Execution Options
+
+\`\`\`bash
+taskgraph analyze-complexity [--research] [--threshold=5]
+\`\`\`
+
+## Analysis Parameters
+
+- \`--research\` → Use research AI for deeper analysis
+- \`--threshold=5\` → Only flag tasks above complexity 5
+- Default: Analyze all pending tasks
+
+## Analysis Process
+
+### 1. **Task Evaluation**
+For each task, AI evaluates:
+- Technical complexity
+- Time requirements
+- Dependency complexity
+- Risk factors
+- Knowledge requirements
+
+### 2. **Complexity Scoring**
+Assigns score 1-10 based on:
+- Implementation difficulty
+- Integration challenges
+- Testing requirements
+- Unknown factors
+- Technical debt risk
+
+### 3. **Recommendations**
+For complex tasks:
+- Suggest expansion approach
+- Recommend subtask breakdown
+- Identify risk areas
+- Propose mitigation strategies
+
+## Smart Analysis Features
+
+1. **Pattern Recognition**
+   - Similar task comparisons
+   - Historical complexity accuracy
+   - Team velocity consideration
+   - Technology stack factors
+
+2. **Contextual Factors**
+   - Team expertise
+   - Available resources
+   - Timeline constraints
+   - Business criticality
+
+3. **Risk Assessment**
+   - Technical risks
+   - Timeline risks
+   - Dependency risks
+   - Knowledge gaps
+
+## Output Format
+
+\`\`\`
+Task Complexity Analysis Report
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+High Complexity Tasks (>7):
+📍 #5 "Implement real-time sync" - Score: 9/10
+   Factors: WebSocket complexity, state management, conflict resolution
+   Recommendation: Expand into 5-7 subtasks
+   Risks: Performance, data consistency
+
+📍 #12 "Migrate database schema" - Score: 8/10
+   Factors: Data migration, zero downtime, rollback strategy
+   Recommendation: Expand into 4-5 subtasks
+   Risks: Data loss, downtime
+
+Medium Complexity Tasks (5-7):
+📍 #23 "Add export functionality" - Score: 6/10
+   Consider expansion if timeline tight
+
+Low Complexity Tasks (<5):
+✅ 15 tasks - No expansion needed
+
+Summary:
+- Expand immediately: 2 tasks
+- Consider expanding: 5 tasks
+- Keep as-is: 15 tasks
+\`\`\`
+
+## Actionable Output
+
+For each high-complexity task:
+1. Complexity score with reasoning
+2. Specific expansion suggestions
+3. Risk mitigation approaches
+4. Recommended subtask structure
+
+## Integration
+
+Results are:
+- Saved to \`.taskgraph/reports/complexity-analysis.md\`
+- Used by expand command
+- Inform sprint planning
+- Guide resource allocation
+
+## Next Steps
+
+After analysis:
+\`\`\`
+/taskgraph:expand 5    # Expand specific task
+/taskgraph:expand-all  # Expand all recommended
+/taskgraph:complexity-report  # View detailed report
+\`\`\``,`solo`),Se=V(`complexity-report`,`Complexity Report`,`[--file=<path>]`,`Display the task complexity analysis report.
+
+Arguments: $ARGUMENTS
+
+View the detailed complexity analysis generated by analyze-complexity command.
+
+## Viewing Complexity Report
+
+Shows comprehensive task complexity analysis with actionable insights.
+
+## Execution
+
+\`\`\`bash
+taskgraph complexity-report [--file=<path>]
+\`\`\`
+
+## Report Location
+
+Default: \`.taskgraph/reports/complexity-analysis.md\`
+Custom: Specify with --file parameter
+
+## Report Contents
+
+### 1. **Executive Summary**
+\`\`\`
+Complexity Analysis Summary
+━━━━━━━━━━━━━━━━━━━━━━━━
+Analysis Date: 2024-01-15
+Tasks Analyzed: 32
+High Complexity: 5 (16%)
+Medium Complexity: 12 (37%)
+Low Complexity: 15 (47%)
+
+Critical Findings:
+- 5 tasks need immediate expansion
+- 3 tasks have high technical risk
+- 2 tasks block critical path
+\`\`\`
+
+### 2. **Detailed Task Analysis**
+For each complex task:
+- Complexity score breakdown
+- Contributing factors
+- Specific risks identified
+- Expansion recommendations
+- Similar completed tasks
+
+### 3. **Risk Matrix**
+Visual representation:
+\`\`\`
+Risk vs Complexity Matrix
+━━━━━━━━━━━━━━━━━━━━━━━
+High Risk  | #5(9) #12(8) | #23(6)
+Med Risk   | #34(7)       | #45(5) #67(5)
+Low Risk   | #78(8)       | [15 tasks]
+           | High Complex  | Med Complex
+\`\`\`
+
+### 4. **Recommendations**
+
+**Immediate Actions:**
+1. Expand task #5 - Critical path + high complexity
+2. Expand task #12 - High risk + dependencies
+3. Review task #34 - Consider splitting
+
+**Sprint Planning:**
+- Don't schedule multiple high-complexity tasks together
+- Ensure expertise available for complex tasks
+- Build in buffer time for unknowns
+
+## Interactive Features
+
+When viewing report:
+1. **Quick Actions**
+   - Press 'e' to expand a task
+   - Press 'd' for task details
+   - Press 'r' to refresh analysis
+
+2. **Filtering**
+   - View by complexity level
+   - Filter by risk factors
+   - Show only actionable items
+
+3. **Export Options**
+   - Markdown format
+   - CSV for spreadsheets
+   - JSON for tools
+
+## Report Intelligence
+
+- Compares with historical data
+- Shows complexity trends
+- Identifies patterns
+- Suggests process improvements
+
+## Integration
+
+Use report for:
+- Sprint planning sessions
+- Resource allocation
+- Risk assessment
+- Team discussions
+- Client updates
+
+## Example Usage
+
+\`\`\`
+/taskgraph:complexity-report
+→ Opens latest analysis
+
+/taskgraph:complexity-report --file=archived/2024-01-01.md
+→ View historical analysis
+
+After viewing:
+/taskgraph:expand 5
+→ Expand high-complexity task
+\`\`\``,`solo`),Ce=V(`expand-task`,`Expand Task`,`<task-id>`,`Break down a complex task into subtasks.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Intelligent Task Expansion
+
+Analyzes a task and creates detailed subtasks for better manageability.
+
+## Execution
+
+\`\`\`bash
+taskgraph expand --id=$ARGUMENTS
+\`\`\`
+
+## Expansion Process
+
+1. **Task Analysis**
+   - Review task complexity
+   - Identify components
+   - Detect technical challenges
+   - Estimate time requirements
+
+2. **Subtask Generation**
+   - Create 3-7 subtasks typically
+   - Each subtask 1-4 hours
+   - Logical implementation order
+   - Clear acceptance criteria
+
+3. **Smart Breakdown**
+   - Setup/configuration tasks
+   - Core implementation
+   - Testing components
+   - Integration steps
+   - Documentation updates
+
+## Enhanced Features
+
+Based on task type:
+- **Feature**: Setup → Implement → Test → Integrate
+- **Bug Fix**: Reproduce → Diagnose → Fix → Verify
+- **Refactor**: Analyze → Plan → Refactor → Validate
+
+## Post-Expansion
+
+After expansion:
+1. Show subtask hierarchy
+2. Update time estimates
+3. Suggest implementation order
+4. Highlight critical path`,`solo`),we=B({name:`expand-all-tasks`,description:`Expand All Tasks`,content:`Expand all pending tasks that need subtasks.
+
+## Bulk Task Expansion
+
+Intelligently expands all tasks that would benefit from breakdown.
+
+## Execution
+
+\`\`\`bash
+taskgraph expand --all
+\`\`\`
+
+## Smart Selection
+
+Only expands tasks that:
+- Are marked as pending
+- Have high complexity (>5)
+- Lack existing subtasks
+- Would benefit from breakdown
+
+## Expansion Process
+
+1. **Analysis Phase**
+   - Identify expansion candidates
+   - Group related tasks
+   - Plan expansion strategy
+
+2. **Batch Processing**
+   - Expand tasks in logical order
+   - Maintain consistency
+   - Preserve relationships
+   - Optimize for parallelism
+
+3. **Quality Control**
+   - Ensure subtask quality
+   - Avoid over-decomposition
+   - Maintain task coherence
+   - Update dependencies
+
+## Options
+
+- Add \`force\` to expand all regardless of complexity
+- Add \`research\` for enhanced AI analysis
+
+## Results
+
+After bulk expansion:
+- Summary of tasks expanded
+- New subtask count
+- Updated complexity metrics
+- Suggested task order`,mode:`solo`}),Te=V(`add-task`,`Add Task`,`<description>`,`Add new tasks with intelligent parsing and context awareness.
+
+Arguments: $ARGUMENTS
+
+## Smart Task Addition
+
+Parse natural language to create well-structured tasks.
+
+### 1. **Input Understanding**
+
+I'll intelligently parse your request:
+- Natural language → Structured task
+- Detect priority from keywords (urgent, ASAP, important)
+- Infer dependencies from context
+- Suggest complexity based on description
+- Determine task type (feature, bug, refactor, test, docs)
+
+### 2. **Smart Parsing Examples**
+
+**"Add urgent task to fix login bug"**
+→ Title: Fix login bug
+→ Priority: high
+→ Type: bug
+→ Suggested complexity: medium
+
+**"Create task for API documentation after task 23 is done"**
+→ Title: API documentation
+→ Dependencies: [23]
+→ Type: documentation
+→ Priority: medium
+
+**"Need to refactor auth module - depends on 12 and 15, high complexity"**
+→ Title: Refactor auth module
+→ Dependencies: [12, 15]
+→ Complexity: high
+→ Type: refactor
+
+### 3. **Context Enhancement**
+
+Based on current project state:
+- Suggest related existing tasks
+- Warn about potential conflicts
+- Recommend dependencies
+- Propose subtasks if complex
+
+### 4. **Interactive Refinement**
+
+\`\`\`yaml
+Task Preview:
+─────────────
+Title: [Extracted title]
+Priority: [Inferred priority]
+Dependencies: [Detected dependencies]
+Complexity: [Estimated complexity]
+
+Suggestions:
+- Similar task #34 exists, consider as dependency?
+- This seems complex, break into subtasks?
+- Tasks #45-47 work on same module
+\`\`\`
+
+### 5. **Validation & Creation**
+
+Before creating:
+- Validate dependencies exist
+- Check for duplicates
+- Ensure logical ordering
+- Verify task completeness
+
+### 6. **Smart Defaults**
+
+Intelligent defaults based on:
+- Task type patterns
+- Team conventions
+- Historical data
+- Current sprint/phase
+
+Result: High-quality tasks from minimal input.`,`solo`),Ee=V(`add-subtask`,`Add Subtask`,`<parent-id> <title>`,`Add a subtask to a parent task.
+
+Arguments: $ARGUMENTS
+
+Parse arguments to create a new subtask or convert existing task.
+
+## Adding Subtasks
+
+Creates subtasks to break down complex parent tasks into manageable pieces.
+
+## Argument Parsing
+
+Flexible natural language:
+- "add subtask to 5: implement login form"
+- "break down 5 with: setup, implement, test"
+- "subtask for 5: handle edge cases"
+- "5: validate user input" → adds subtask to task 5
+
+## Execution Modes
+
+### 1. Create New Subtask
+\`\`\`bash
+taskgraph add-subtask --parent=<id> --title="<title>" --description="<desc>"
+\`\`\`
+
+### 2. Convert Existing Task
+\`\`\`bash
+taskgraph add-subtask --parent=<id> --task-id=<existing-id>
+\`\`\`
+
+## Smart Features
+
+1. **Automatic Subtask Generation**
+   - If title contains "and" or commas, create multiple
+   - Suggest common subtask patterns
+   - Inherit parent's context
+
+2. **Intelligent Defaults**
+   - Priority based on parent
+   - Appropriate time estimates
+   - Logical dependencies between subtasks
+
+3. **Validation**
+   - Check parent task complexity
+   - Warn if too many subtasks
+   - Ensure subtask makes sense
+
+## Creation Process
+
+1. Parse parent task context
+2. Generate subtask with ID like "5.1"
+3. Set appropriate defaults
+4. Link to parent task
+5. Update parent's time estimate
+
+## Example Flows
+
+\`\`\`
+/taskgraph:add-subtask to 5: implement user authentication
+→ Created subtask #5.1: "implement user authentication"
+→ Parent task #5 now has 1 subtask
+→ Suggested next subtasks: tests, documentation
+
+/taskgraph:add-subtask 5: setup, implement, test
+→ Created 3 subtasks:
+  #5.1: setup
+  #5.2: implement
+  #5.3: test
+\`\`\`
+
+## Post-Creation
+
+- Show updated task hierarchy
+- Suggest logical next subtasks
+- Update complexity estimates
+- Recommend subtask order`,`solo`),De=V(`remove-task`,`Remove Task`,`<task-id>`,`Remove a task permanently from the project.
+
+Arguments: $ARGUMENTS (task ID)
+
+Delete a task and handle all its relationships properly.
+
+## Task Removal
+
+Permanently removes a task while maintaining project integrity.
+
+## Argument Parsing
+
+- "remove task 5"
+- "delete 5"
+- "5" → remove task 5
+- Can include "-y" for auto-confirm
+
+## Execution
+
+\`\`\`bash
+taskgraph remove-task --id=<id> [-y]
+\`\`\`
+
+## Pre-Removal Analysis
+
+1. **Task Details**
+   - Current status
+   - Work completed
+   - Time invested
+   - Associated data
+
+2. **Relationship Check**
+   - Tasks that depend on this
+   - Dependencies this task has
+   - Subtasks that will be removed
+   - Blocking implications
+
+3. **Impact Assessment**
+   \`\`\`
+   Task Removal Impact
+   ━━━━━━━━━━━━━━━━━━
+   Task: #5 "Implement authentication" (in-progress)
+   Status: 60% complete (~8 hours work)
+
+   Will affect:
+   - 3 tasks depend on this (will be blocked)
+   - Has 4 subtasks (will be deleted)
+   - Part of critical path
+
+   ⚠️  This action cannot be undone
+   \`\`\`
+
+## Smart Warnings
+
+- Warn if task is in-progress
+- Show dependent tasks that will be blocked
+- Highlight if part of critical path
+- Note any completed work being lost
+
+## Removal Process
+
+1. Show comprehensive impact
+2. Require confirmation (unless -y)
+3. Update dependent task references
+4. Remove task and subtasks
+5. Clean up orphaned dependencies
+6. Log removal with timestamp
+
+## Alternative Actions
+
+Suggest before deletion:
+- Mark as cancelled instead
+- Convert to documentation
+- Archive task data
+- Transfer work to another task
+
+## Post-Removal
+
+- List affected tasks
+- Show broken dependencies
+- Update project statistics
+- Suggest dependency fixes
+- Recalculate timeline
+
+## Example Flows
+
+\`\`\`
+/taskgraph:remove-task 5
+→ Task #5 is in-progress with 8 hours logged
+→ 3 other tasks depend on this
+→ Suggestion: Mark as cancelled instead?
+Remove anyway? (y/n)
+
+/taskgraph:remove-task 5 -y
+→ Removed: Task #5 and 4 subtasks
+→ Updated: 3 task dependencies
+→ Warning: Tasks #7, #8, #9 now have missing dependency
+→ Run /taskgraph:fix-dependencies to resolve
+\`\`\`
+
+## Safety Features
+
+- Confirmation required
+- Impact preview
+- Removal logging
+- Suggest alternatives
+- No cascade delete of dependents`,`solo`),Oe=V(`remove-subtask`,`Remove Subtask`,`<subtask-id>`,`Remove a subtask from its parent task.
+
+Arguments: $ARGUMENTS
+
+Parse subtask ID to remove, with option to convert to standalone task.
+
+## Removing Subtasks
+
+Remove a subtask and optionally convert it back to a standalone task.
+
+## Argument Parsing
+
+- "remove subtask 5.1"
+- "delete 5.1"
+- "convert 5.1 to task" → remove and convert
+- "5.1 standalone" → convert to standalone
+
+## Execution Options
+
+### 1. Delete Subtask
+\`\`\`bash
+taskgraph remove-subtask --id=<parentId.subtaskId>
+\`\`\`
+
+### 2. Convert to Standalone
+\`\`\`bash
+taskgraph remove-subtask --id=<parentId.subtaskId> --convert
+\`\`\`
+
+## Pre-Removal Checks
+
+1. **Validate Subtask**
+   - Verify subtask exists
+   - Check completion status
+   - Review dependencies
+
+2. **Impact Analysis**
+   - Other subtasks that depend on it
+   - Parent task implications
+   - Data that will be lost
+
+## Removal Process
+
+### For Deletion:
+1. Confirm if subtask has work done
+2. Update parent task estimates
+3. Remove subtask and its data
+4. Clean up dependencies
+
+### For Conversion:
+1. Assign new standalone task ID
+2. Preserve all task data
+3. Update dependency references
+4. Maintain task history
+
+## Smart Features
+
+- Warn if subtask is in-progress
+- Show impact on parent task
+- Preserve important data
+- Update related estimates
+
+## Example Flows
+
+\`\`\`
+/taskgraph:remove-subtask 5.1
+→ Warning: Subtask #5.1 is in-progress
+→ This will delete all subtask data
+→ Parent task #5 will be updated
+Confirm deletion? (y/n)
+
+/taskgraph:remove-subtask 5.1 convert
+→ Converting subtask #5.1 to standalone task #89
+→ Preserved: All task data and history
+→ Updated: 2 dependency references
+→ New task #89 is now independent
+\`\`\`
+
+## Post-Removal
+
+- Update parent task status
+- Recalculate estimates
+- Show updated hierarchy
+- Suggest next actions`,`solo`),ke=V(`remove-subtasks`,`Remove Subtasks`,`<task-id>`,`Clear all subtasks from a specific task.
+
+Arguments: $ARGUMENTS (task ID)
+
+Remove all subtasks from a parent task at once.
+
+## Clearing Subtasks
+
+Bulk removal of all subtasks from a parent task.
+
+## Execution
+
+\`\`\`bash
+taskgraph remove-subtasks --id=$ARGUMENTS
+\`\`\`
+
+## Pre-Clear Analysis
+
+1. **Subtask Summary**
+   - Number of subtasks
+   - Completion status of each
+   - Work already done
+   - Dependencies affected
+
+2. **Impact Assessment**
+   - Data that will be lost
+   - Dependencies to be removed
+   - Effect on project timeline
+   - Parent task implications
+
+## Confirmation Required
+
+\`\`\`
+Remove Subtasks Confirmation
+━━━━━━━━━━━━━━━━━━━━━━━━━
+Parent Task: #5 "Implement user authentication"
+Subtasks to remove: 4
+- #5.1 "Setup auth framework" (done)
+- #5.2 "Create login form" (in-progress)
+- #5.3 "Add validation" (pending)
+- #5.4 "Write tests" (pending)
+
+⚠️  This will permanently delete all subtask data
+Continue? (y/n)
+\`\`\`
+
+## Smart Features
+
+- Option to convert to standalone tasks
+- Backup task data before clearing
+- Preserve completed work history
+- Update parent task appropriately
+
+## Process
+
+1. List all subtasks for confirmation
+2. Check for in-progress work
+3. Remove all subtasks
+4. Update parent task
+5. Clean up dependencies
+
+## Alternative Options
+
+Suggest alternatives:
+- Convert important subtasks to tasks
+- Keep completed subtasks
+- Archive instead of delete
+- Export subtask data first
+
+## Post-Clear
+
+- Show updated parent task
+- Recalculate time estimates
+- Update task complexity
+- Suggest next steps
+
+## Example
+
+\`\`\`
+/taskgraph:remove-subtasks 5
+→ Found 4 subtasks to remove
+→ Warning: Subtask #5.2 is in-progress
+→ Cleared all subtasks from task #5
+→ Updated parent task estimates
+→ Suggestion: Consider re-expanding with better breakdown
+\`\`\``,`solo`),Ae=B({name:`remove-all-subtasks`,description:`Remove All Subtasks`,content:`Clear all subtasks from all tasks globally.
+
+## Global Subtask Clearing
+
+Remove all subtasks across the entire project. Use with extreme caution.
+
+## Execution
+
+\`\`\`bash
+taskgraph clear-subtasks --all
+\`\`\`
+
+## Pre-Clear Analysis
+
+1. **Project-Wide Summary**
+   \`\`\`
+   Global Subtask Summary
+   ━━━━━━━━━━━━━━━━━━━━
+   Total parent tasks: 12
+   Total subtasks: 47
+   - Completed: 15
+   - In-progress: 8
+   - Pending: 24
+
+   Work at risk: ~120 hours
+   \`\`\`
+
+2. **Critical Warnings**
+   - In-progress subtasks that will lose work
+   - Completed subtasks with valuable history
+   - Complex dependency chains
+   - Integration test results
+
+## Double Confirmation
+
+\`\`\`
+⚠️  DESTRUCTIVE OPERATION WARNING ⚠️
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+This will remove ALL 47 subtasks from your project
+Including 8 in-progress and 15 completed subtasks
+
+This action CANNOT be undone
+
+Type 'CLEAR ALL SUBTASKS' to confirm:
+\`\`\`
+
+## Smart Safeguards
+
+- Require explicit confirmation phrase
+- Create automatic backup
+- Log all removed data
+- Option to export first
+
+## Use Cases
+
+Valid reasons for global clear:
+- Project restructuring
+- Major pivot in approach
+- Starting fresh breakdown
+- Switching to different task organization
+
+## Process
+
+1. Full project analysis
+2. Create backup file
+3. Show detailed impact
+4. Require confirmation
+5. Execute removal
+6. Generate summary report
+
+## Alternative Suggestions
+
+Before clearing all:
+- Export subtasks to file
+- Clear only pending subtasks
+- Clear by task category
+- Archive instead of delete
+
+## Post-Clear Report
+
+\`\`\`
+Global Subtask Clear Complete
+━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Removed: 47 subtasks from 12 tasks
+Backup saved: .taskgraph/backup/subtasks-20240115.json
+Parent tasks updated: 12
+Time estimates adjusted: Yes
+
+Next steps:
+- Review updated task list
+- Re-expand complex tasks as needed
+- Check project timeline
+\`\`\``,mode:`solo`}),je=V(`convert-task-to-subtask`,`Convert Task To Subtask`,`<parent-id> <task-id>`,`Convert an existing task into a subtask.
+
+Arguments: $ARGUMENTS
+
+Parse parent ID and task ID to convert.
+
+## Task Conversion
+
+Converts an existing standalone task into a subtask of another task.
+
+## Argument Parsing
+
+- "move task 8 under 5"
+- "make 8 a subtask of 5"
+- "nest 8 in 5"
+- "5 8" → make task 8 a subtask of task 5
+
+## Execution
+
+\`\`\`bash
+taskgraph add-subtask --parent=<parent-id> --task-id=<task-to-convert>
+\`\`\`
+
+## Pre-Conversion Checks
+
+1. **Validation**
+   - Both tasks exist and are valid
+   - No circular parent relationships
+   - Task isn't already a subtask
+   - Logical hierarchy makes sense
+
+2. **Impact Analysis**
+   - Dependencies that will be affected
+   - Tasks that depend on converting task
+   - Priority alignment needed
+   - Status compatibility
+
+## Conversion Process
+
+1. Change task ID from "8" to "5.1" (next available)
+2. Update all dependency references
+3. Inherit parent's context where appropriate
+4. Adjust priorities if needed
+5. Update time estimates
+
+## Smart Features
+
+- Preserve task history
+- Maintain dependencies
+- Update all references
+- Create conversion log
+
+## Example
+
+\`\`\`
+/taskgraph:add-subtask/from-task 5 8
+→ Converting: Task #8 becomes subtask #5.1
+→ Updated: 3 dependency references
+→ Parent task #5 now has 1 subtask
+→ Note: Subtask inherits parent's priority
+
+Before: #8 "Implement validation" (standalone)
+After:  #5.1 "Implement validation" (subtask of #5)
+\`\`\`
+
+## Post-Conversion
+
+- Show new task hierarchy
+- List updated dependencies
+- Verify project integrity
+- Suggest related conversions`,`solo`),Me=V(`add-dependency`,`Add Dependency`,`<task-id> <depends-on-id>`,`Add a dependency between tasks.
+
+Arguments: $ARGUMENTS
+
+Parse the task IDs to establish dependency relationship.
+
+## Adding Dependencies
+
+Creates a dependency where one task must be completed before another can start.
+
+## Argument Parsing
+
+Parse natural language or IDs:
+- "make 5 depend on 3" → task 5 depends on task 3
+- "5 needs 3" → task 5 depends on task 3
+- "5 3" → task 5 depends on task 3
+- "5 after 3" → task 5 depends on task 3
+
+## Execution
+
+\`\`\`bash
+taskgraph add-dependency --id=<task-id> --depends-on=<dependency-id>
+\`\`\`
+
+## Validation
+
+Before adding:
+1. **Verify both tasks exist**
+2. **Check for circular dependencies**
+3. **Ensure dependency makes logical sense**
+4. **Warn if creating complex chains**
+
+## Smart Features
+
+- Detect if dependency already exists
+- Suggest related dependencies
+- Show impact on task flow
+- Update task priorities if needed
+
+## Post-Addition
+
+After adding dependency:
+1. Show updated dependency graph
+2. Identify any newly blocked tasks
+3. Suggest task order changes
+4. Update project timeline
+
+## Example Flows
+
+\`\`\`
+/taskgraph:add-dependency 5 needs 3
+→ Task #5 now depends on Task #3
+→ Task #5 is now blocked until #3 completes
+→ Suggested: Also consider if #5 needs #4
+\`\`\``,`solo`),Ne=V(`remove-dependency`,`Remove Dependency`,`<task-id> <depends-on-id>`,`Remove a dependency between tasks.
+
+Arguments: $ARGUMENTS
+
+Parse the task IDs to remove dependency relationship.
+
+## Removing Dependencies
+
+Removes a dependency relationship, potentially unblocking tasks.
+
+## Argument Parsing
+
+Parse natural language or IDs:
+- "remove dependency between 5 and 3"
+- "5 no longer needs 3"
+- "unblock 5 from 3"
+- "5 3" → remove dependency of 5 on 3
+
+## Execution
+
+\`\`\`bash
+taskgraph remove-dependency --id=<task-id> --depends-on=<dependency-id>
+\`\`\`
+
+## Pre-Removal Checks
+
+1. **Verify dependency exists**
+2. **Check impact on task flow**
+3. **Warn if it breaks logical sequence**
+4. **Show what will be unblocked**
+
+## Smart Analysis
+
+Before removing:
+- Show why dependency might have existed
+- Check if removal makes tasks executable
+- Verify no critical path disruption
+- Suggest alternative dependencies
+
+## Post-Removal
+
+After removing:
+1. Show updated task status
+2. List newly unblocked tasks
+3. Update project timeline
+4. Suggest next actions
+
+## Safety Features
+
+- Confirm if removing critical dependency
+- Show tasks that become immediately actionable
+- Warn about potential issues
+- Keep removal history
+
+## Example
+
+\`\`\`
+/taskgraph:remove-dependency 5 from 3
+→ Removed: Task #5 no longer depends on #3
+→ Task #5 is now UNBLOCKED and ready to start
+→ Warning: Consider if #5 still needs #2 completed first
+\`\`\``,`solo`),Pe=B({name:`fix-dependencies`,description:`Fix Dependencies`,content:`Automatically fix dependency issues found during validation.
+
+## Automatic Dependency Repair
+
+Intelligently fixes common dependency problems while preserving project logic.
+
+## Execution
+
+\`\`\`bash
+taskgraph fix-dependencies
+\`\`\`
+
+## What Gets Fixed
+
+### 1. **Auto-Fixable Issues**
+- Remove references to deleted tasks
+- Break simple circular dependencies
+- Remove self-dependencies
+- Clean up duplicate dependencies
+
+### 2. **Smart Resolutions**
+- Reorder dependencies to maintain logic
+- Suggest task merging for over-dependent tasks
+- Flatten unnecessary dependency chains
+- Remove redundant transitive dependencies
+
+### 3. **Manual Review Required**
+- Complex circular dependencies
+- Critical path modifications
+- Business logic dependencies
+- High-impact changes
+
+## Fix Process
+
+1. **Analysis Phase**
+   - Run validation check
+   - Categorize issues by type
+   - Determine fix strategy
+
+2. **Execution Phase**
+   - Apply automatic fixes
+   - Log all changes made
+   - Preserve task relationships
+
+3. **Verification Phase**
+   - Re-validate after fixes
+   - Show before/after comparison
+   - Highlight manual fixes needed
+
+## Smart Features
+
+- Preserves intended task flow
+- Minimal disruption approach
+- Creates fix history/log
+- Suggests manual interventions
+
+## Output Example
+
+\`\`\`
+Dependency Auto-Fix Report
+━━━━━━━━━━━━━━━━━━━━━━━━
+Fixed Automatically:
+✅ Removed 2 references to deleted tasks
+✅ Resolved 1 self-dependency
+✅ Cleaned 3 redundant dependencies
+
+Manual Review Needed:
+⚠️ Complex circular dependency: #12 → #15 → #18 → #12
+  Suggestion: Make #15 not depend on #12
+⚠️ Task #45 has 8 dependencies
+  Suggestion: Break into subtasks
+
+Run '/taskgraph:validate-dependencies' to verify fixes
+\`\`\`
+
+## Safety
+
+- Preview mode available
+- Rollback capability
+- Change logging
+- No data loss`,mode:`solo`}),Fe=B({name:`validate-dependencies`,description:`Validate Dependencies`,content:`Validate all task dependencies for issues.
+
+## Dependency Validation
+
+Comprehensive check for dependency problems across the entire project.
+
+## Execution
+
+\`\`\`bash
+taskgraph validate-dependencies
+\`\`\`
+
+## Validation Checks
+
+1. **Circular Dependencies**
+   - A depends on B, B depends on A
+   - Complex circular chains
+   - Self-dependencies
+
+2. **Missing Dependencies**
+   - References to non-existent tasks
+   - Deleted task references
+   - Invalid task IDs
+
+3. **Logical Issues**
+   - Completed tasks depending on pending
+   - Cancelled tasks in dependency chains
+   - Impossible sequences
+
+4. **Complexity Warnings**
+   - Over-complex dependency chains
+   - Too many dependencies per task
+   - Bottleneck tasks
+
+## Smart Analysis
+
+The validation provides:
+- Visual dependency graph
+- Critical path analysis
+- Bottleneck identification
+- Suggested optimizations
+
+## Report Format
+
+\`\`\`
+Dependency Validation Report
+━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ No circular dependencies found
+⚠️  2 warnings found:
+   - Task #23 has 7 dependencies (consider breaking down)
+   - Task #45 blocks 5 other tasks (potential bottleneck)
+❌ 1 error found:
+   - Task #67 depends on deleted task #66
+
+Critical Path: #1 → #5 → #23 → #45 → #50 (15 days)
+\`\`\`
+
+## Actionable Output
+
+For each issue found:
+- Clear description
+- Impact assessment
+- Suggested fix
+- Command to resolve
+
+## Next Steps
+
+After validation:
+- Run \`/taskgraph:fix-dependencies\` to auto-fix
+- Manually adjust problematic dependencies
+- Rerun to verify fixes`,mode:`solo`}),Ie=B({name:`setup-models`,description:`Setup Models`,content:`Run interactive setup to configure AI models.
+
+## Interactive Model Configuration
+
+Guides you through setting up AI providers for TaskGraph.
+
+## Execution
+
+\`\`\`bash
+taskgraph models --setup
+\`\`\`
+
+## Setup Process
+
+1. **Environment Check**
+   - Confirm Claude Code is installed and signed in
+   - Show current configuration
+
+2. **Model Selection**
+   - Choose the main model (required)
+   - Choose the research model (recommended)
+   - Choose a fallback model (optional)
+
+TaskGraph uses Claude Code, so no API keys are needed. Available models: opus, sonnet, haiku.
+
+## Smart Recommendations
+
+Based on your needs:
+- **For best results**: opus for main, sonnet for research
+- **Budget conscious**: haiku for fallback
+- **Balanced**: sonnet for all roles
+
+## Configuration Storage
+
+Model choices are saved in \`.taskgraph/config.json\`.
+
+## Post-Setup
+
+After configuration:
+- Show usage examples
+- Suggest next steps
+- Verify parse-prd works`,mode:`solo`}),Le=B({name:`view-models`,description:`View Models`,content:`View current AI model configuration.
+
+## Model Configuration Display
+
+Shows the currently configured AI providers and models for TaskGraph.
+
+## Execution
+
+\`\`\`bash
+taskgraph models
+\`\`\`
+
+## Information Displayed
+
+1. **Main Provider**
+   - Model ID and name
+   - Usage: Primary task generation
+
+2. **Research Provider**
+   - Model ID and name
+   - Usage: Enhanced research mode
+
+3. **Fallback Provider**
+   - Model ID and name
+   - Usage: Backup when main fails
+
+## Visual Status
+
+\`\`\`
+TaskGraph Model Configuration
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Main:     ✅ claude-code / sonnet
+Research: ✅ claude-code / sonnet
+Fallback: ✅ claude-code / sonnet
+
+Available Models:
+- opus
+- sonnet
+- haiku
+\`\`\`
+
+## Next Actions
+
+Based on configuration:
+- If Claude Code is missing → Suggest installing and signing in
+- If no research model → Explain benefits
+- If all configured → Show usage tips`,mode:`solo`}),Re=B({name:`install-taskgraph`,description:`Install TaskGraph`,content:`Check if TaskGraph is installed and install it if needed.
+
+This command helps you get TaskGraph set up globally on your system.
+
+## Detection and Installation Process
+
+1. **Check Current Installation**
+   \`\`\`bash
+   # Check if taskgraph command exists
+   which taskgraph || echo "TaskGraph not found"
+
+   # Check npm global packages
+   npm list -g taskgraph-ai
+   \`\`\`
+
+2. **System Requirements Check**
+   \`\`\`bash
+   # Verify Node.js is installed
+   node --version
+
+   # Verify npm is installed
+   npm --version
+
+   # Check Node version (need 16+)
+   \`\`\`
+
+3. **Install TaskGraph Globally**
+   If not installed, run:
+   \`\`\`bash
+   npm install -g taskgraph-ai
+   \`\`\`
+
+4. **Verify Installation**
+   \`\`\`bash
+   # Check version
+   taskgraph --version
+
+   # Verify command is available
+   which taskgraph
+   \`\`\`
+
+5. **Initial Setup**
+   \`\`\`bash
+   # Initialize in current directory
+   taskgraph init
+   \`\`\`
+
+6. **Check the AI provider**
+   TaskGraph uses Claude Code, so no API keys are needed. Make sure Claude Code is installed and signed in:
+   \`\`\`bash
+   # Verify Claude Code is available
+   claude --version
+
+   # Check current model configuration
+   taskgraph models
+   \`\`\`
+
+7. **Quick Test**
+   \`\`\`bash
+   # Create a test PRD
+   echo "Build a simple hello world API" > test-prd.txt
+
+   # Try parsing it
+   taskgraph parse-prd test-prd.txt -n 3
+   \`\`\`
+
+## Troubleshooting
+
+If installation fails:
+
+**Permission Errors:**
+\`\`\`bash
+# Try with sudo (macOS/Linux)
+sudo npm install -g taskgraph-ai
+
+# Or fix npm permissions
+npm config set prefix ~/.npm-global
+export PATH=~/.npm-global/bin:$PATH
+\`\`\`
+
+**Network Issues:**
+\`\`\`bash
+# Use different registry
+npm install -g taskgraph-ai --registry https://registry.npmjs.org/
+\`\`\`
+
+**Node Version Issues:**
+\`\`\`bash
+# Install Node 20+ via nvm
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
+nvm install 20
+nvm use 20
+\`\`\`
+
+## Success Confirmation
+
+Once installed, you should see:
+\`\`\`
+✅ TaskGraph installed
+✅ Command 'taskgraph' available globally
+✅ AI provider configured
+✅ Ready to use slash commands!
+
+Try: /taskgraph:init your-prd.md
+\`\`\`
+
+## Next Steps
+
+After installation:
+1. Run \`/taskgraph:status\` to verify setup
+2. Configure AI providers with \`/taskgraph:setup-models\`
+3. Start using TaskGraph commands!`,mode:`solo`}),ze=B({name:`quick-install-taskgraph`,description:`Quick Install TaskGraph`,content:`Quick install TaskGraph globally if not already installed.
+
+Execute this streamlined installation:
+
+\`\`\`bash
+# Check and install in one command
+taskgraph --version 2>/dev/null || npm install -g taskgraph-ai
+
+# Verify installation
+taskgraph --version
+
+# Quick setup check
+taskgraph models || echo "Note: TaskGraph uses Claude Code; make sure it is installed and signed in"
+\`\`\`
+
+If you see "command not found" after installation, you may need to:
+1. Restart your terminal
+2. Or add npm global bin to PATH: \`export PATH=$(npm bin -g):$PATH\`
+
+Once installed, you can use all the TaskGraph commands!
+
+Quick test: Run \`/taskgraph:help\` to see all available commands.`,mode:`solo`}),Be=V(`to-review`,`To Review`,`<task-id>`,`Set a task's status to review.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Marking Task for Review
+
+This status indicates work is complete but needs verification before final approval.
+
+## When to Use Review Status
+
+- Code complete but needs peer review
+- Implementation done but needs testing
+- Documentation written but needs proofreading
+- Design complete but needs stakeholder approval
+
+## Execution
+
+\`\`\`bash
+taskgraph set-status --id=$ARGUMENTS --status=review
+\`\`\`
+
+## Review Preparation
+
+When setting to review:
+1. **Generate Review Checklist**
+   - Link to PR/MR if applicable
+   - Highlight key changes
+   - Note areas needing attention
+   - Include test results
+
+2. **Documentation**
+   - Update task with review notes
+   - Link relevant artifacts
+   - Specify reviewers if known
+
+3. **Smart Actions**
+   - Create review reminders
+   - Track review duration
+   - Suggest reviewers based on expertise
+   - Prepare rollback plan if needed`,`solo`),Ve=V(`to-deferred`,`To Deferred`,`<task-id>`,`Defer a task for later consideration.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Deferring a Task
+
+This status indicates a task is valid but not currently actionable or prioritized.
+
+## Valid Reasons for Deferral
+
+- Waiting for external dependencies
+- Reprioritized for future sprint
+- Blocked by technical limitations
+- Resource constraints
+- Strategic timing considerations
+
+## Execution
+
+\`\`\`bash
+taskgraph set-status --id=$ARGUMENTS --status=deferred
+\`\`\`
+
+## Deferral Management
+
+When deferring:
+1. **Document Reason**
+   - Capture why it's being deferred
+   - Set reactivation criteria
+   - Note any partial work completed
+
+2. **Impact Analysis**
+   - Check dependent tasks
+   - Update project timeline
+   - Notify affected stakeholders
+
+3. **Future Planning**
+   - Set review reminders
+   - Tag for specific milestone
+   - Preserve context for reactivation
+   - Link to blocking issues
+
+## Smart Tracking
+
+- Monitor deferral duration
+- Alert when criteria met
+- Prevent scope creep
+- Regular review cycles`,`solo`),He=V(`to-cancelled`,`To Cancelled`,`<task-id>`,`Cancel a task permanently.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Cancelling a Task
+
+This status indicates a task is no longer needed and won't be completed.
+
+## Valid Reasons for Cancellation
+
+- Requirements changed
+- Feature deprecated
+- Duplicate of another task
+- Strategic pivot
+- Technical approach invalidated
+
+## Pre-Cancellation Checks
+
+1. Confirm no critical dependencies
+2. Check for partial implementation
+3. Verify cancellation rationale
+4. Document lessons learned
+
+## Execution
+
+\`\`\`bash
+taskgraph set-status --id=$ARGUMENTS --status=cancelled
+\`\`\`
+
+## Cancellation Impact
+
+When cancelling:
+1. **Dependency Updates**
+   - Notify dependent tasks
+   - Update project scope
+   - Recalculate timelines
+
+2. **Clean-up Actions**
+   - Remove related branches
+   - Archive any work done
+   - Update documentation
+   - Close related issues
+
+3. **Learning Capture**
+   - Document why cancelled
+   - Note what was learned
+   - Update estimation models
+   - Prevent future duplicates
+
+## Historical Preservation
+
+- Keep for reference
+- Tag with cancellation reason
+- Link to replacement if any
+- Maintain audit trail`,`solo`),Ue=V(`init-project`,`Init Project`,`[prd-file]`,`Initialize a new TaskGraph project.
+
+Arguments: $ARGUMENTS
+
+Parse arguments to determine initialization preferences.
+
+## Initialization Process
+
+1. **Parse Arguments**
+   - PRD file path (if provided)
+   - Project name
+   - Auto-confirm flag (-y)
+
+2. **Project Setup**
+   \`\`\`bash
+   taskgraph init
+   \`\`\`
+
+3. **Smart Initialization**
+   - Detect existing project files
+   - Suggest project name from directory
+   - Check for git repository
+   - Verify AI provider configuration
+
+## Configuration Options
+
+Based on arguments:
+- \`quick\` / \`-y\` → Skip confirmations
+- \`<file.md>\` → Use as PRD after init
+- \`--name=<name>\` → Set project name
+- \`--description=<desc>\` → Set description
+
+## Post-Initialization
+
+After successful init:
+1. Show project structure created
+2. Verify AI models configured
+3. Suggest next steps:
+   - Parse PRD if available
+   - Configure AI providers
+   - Set up git hooks
+   - Create first tasks
+
+## Integration
+
+If PRD file provided:
+\`\`\`
+/taskgraph:init my-prd.md
+→ Automatically runs parse-prd after init
+\`\`\``,`solo`),We=V(`init-project-quick`,`Init Project Quick`,`[prd-file]`,`Quick initialization with auto-confirmation.
+
+Arguments: $ARGUMENTS
+
+Initialize a TaskGraph project without prompts, accepting all defaults.
+
+## Quick Setup
+
+\`\`\`bash
+taskgraph init -y
+\`\`\`
+
+## What It Does
+
+1. Creates \`.taskgraph/\` directory structure
+2. Initializes empty \`tasks.json\`
+3. Sets up default configuration
+4. Uses directory name as project name
+5. Skips all confirmation prompts
+
+## Smart Defaults
+
+- Project name: Current directory name
+- Description: "TaskGraph Project"
+- Model config: Existing environment vars
+- Task structure: Standard format
+
+## Next Steps
+
+After quick init:
+1. Configure AI models if needed:
+   \`\`\`
+   /taskgraph:models/setup
+   \`\`\`
+
+2. Parse PRD if available:
+   \`\`\`
+   /taskgraph:parse-prd <file>
+   \`\`\`
+
+3. Or create first task:
+   \`\`\`
+   /taskgraph:add-task create initial setup
+   \`\`\`
+
+Perfect for rapid project setup!`,`solo`);B({name:`generate-tasks`,description:`Generate Task Files`,content:`Generate individual task files from tasks.json.
+
+## Task File Generation
+
+Creates separate markdown files for each task, perfect for AI agents or documentation.
+
+## Execution
+
+\`\`\`bash
+taskgraph generate
+\`\`\`
+
+## What It Creates
+
+For each task, generates a file like \`task_001.md\`:
+
+\`\`\`
+Task ID: 1
+Title: Implement user authentication
+Status: pending
+Priority: high
+Dependencies: []
+Created: 2024-01-15
+Complexity: 7
+
+## Description
+Create a secure user authentication system with login, logout, and session management.
+
+## Details
+- Use JWT tokens for session management
+- Implement secure password hashing
+- Add remember me functionality
+- Include password reset flow
+
+## Test Strategy
+- Unit tests for auth functions
+- Integration tests for login flow
+- Security testing for vulnerabilities
+- Performance tests for concurrent logins
+
+## Subtasks
+1.1 Setup authentication framework (pending)
+1.2 Create login endpoints (pending)
+1.3 Implement session management (pending)
+1.4 Add password reset (pending)
+\`\`\`
+
+## File Organization
+
+Creates structure:
+\`\`\`
+.taskgraph/
+└── tasks/
+    ├── task_001.md
+    ├── task_002.md
+    ├── task_003.md
+    └── ...
+\`\`\`
+
+## Smart Features
+
+1. **Consistent Formatting**
+   - Standardized structure
+   - Clear sections
+   - AI-readable format
+   - Markdown compatible
+
+2. **Contextual Information**
+   - Full task details
+   - Related task references
+   - Progress indicators
+   - Implementation notes
+
+3. **Incremental Updates**
+   - Only regenerate changed tasks
+   - Preserve custom additions
+   - Track generation timestamp
+   - Version control friendly
+
+## Use Cases
+
+- **AI Context**: Provide task context to AI assistants
+- **Documentation**: Standalone task documentation
+- **Archival**: Task history preservation
+- **Sharing**: Send specific tasks to team members
+- **Review**: Easier task review process
+
+## Post-Generation
+
+\`\`\`
+Task File Generation Complete
+━━━━━━━━━━━━━━━━━━━━━━━━━━
+Generated: 45 task files
+Location: .taskgraph/tasks/
+Total size: 156 KB
+
+New files: 5
+Updated files: 12
+Unchanged: 28
+
+Ready for:
+- AI agent consumption
+- Version control
+- Team distribution
+\`\`\`
+
+## Integration Benefits
+
+- Git-trackable task history
+- Easy task sharing
+- AI tool compatibility
+- Offline task access
+- Backup redundancy`,mode:`solo`});const H=[ye,be,xe,Se,Ce,we,Te,Ee,De,Oe,ke,Ae,je,Me,Ne,Pe,Fe,Ie,Le,Re,ze,Be,Ve,He,Ue,We,B({name:`goham`,description:`Start Working with Hamster Brief`,argumentHint:`[brief-url]`,mode:`team`,content:`# Start Working with Hamster Brief
+
+End-to-end workflow for working on tasks from a connected Hamster brief. All tasks from the brief are worked on in a single branch, with one PR created at the end.
+
+## Step 1: Verify Connection & Authentication
+
+\`\`\`bash
+# Check current context and authentication status
+tm context
+\`\`\`
+
+If not connected or authentication fails:
+- Get brief URL from user if not available
+- Connect: \`tm context <brief url>\`
+- Refresh token if needed: \`tm auth refresh\`
+
+## Step 2: List Available Tasks
+
+\`\`\`bash
+# View all tasks from the brief
+tm list
+\`\`\`
+
+Review the task list to understand what needs to be done. Note the total number of tasks.
+
+## Step 3: Initialize Git Branch for Brief
+
+\`\`\`bash
+# Ensure you're on dev branch and pull latest
+git checkout dev
+git pull origin dev
+
+# Create a single branch for the entire brief (e.g., hamster-brief-YYYY-MM-DD or brief-specific name)
+git checkout -b hamster-brief
+
+# Verify branch creation
+git branch
+\`\`\`
+
+**Note**: This branch will be used for ALL tasks in the brief. Do not create separate branches per task.
+
+## Step 4: Task Loop (Repeat for Each Task)
+
+Work through all tasks sequentially in the same branch:
+
+### 4.1: Read Task Details
+
+\`\`\`bash
+# Get detailed information about the task
+tm show 1
+
+# If task has subtasks, examine them all
+tm show 1,1.1,1.2,1.3  # Adjust IDs as needed
+\`\`\`
+
+### 4.2: Log Initial Context
+
+\`\`\`bash
+# Document task understanding and initial findings
+tm update-task -i 1 --append --prompt="Starting task implementation.
+
+Initial context:
+- Task requirements: [summarize key requirements]
+- Dependencies identified: [list any dependencies]
+- Files that may need modification: [list relevant files]
+- Approach planned: [brief implementation approach]"
+\`\`\`
+
+### 4.3: Mark Task as In-Progress
+
+\`\`\`bash
+# Mark task and first subtask (if exists) as in-progress
+tm set-status -i 1,1.1 -s in-progress
+\`\`\`
+
+### 4.4: Subtask Implementation Loop
+
+For each subtask (1.1, 1.2, 1.3, etc.):
+
+#### 4.4.1: Read Subtask Details
+\`\`\`bash
+tm show 1.1  # Replace with current subtask ID
+\`\`\`
+
+#### 4.4.2: Log Research & Context Gathering
+\`\`\`bash
+# Document findings during implementation
+tm update-task -i 1 --append --prompt="Subtask 1.1 - Context gathered:
+
+- Code exploration findings: [what you discovered]
+- Implementation approach: [how you plan to implement]
+- Key decisions made: [important choices]
+- Challenges encountered: [any blockers or issues]"
+\`\`\`
+
+#### 4.4.3: Implement Subtask
+- Write code following the subtask requirements
+- Make necessary changes to files
+
+#### 4.4.4: Quality Verification
+\`\`\`bash
+# Run linting
+pnpm lint
+
+# Run type checking
+pnpm typecheck
+
+# If either fails, fix issues and re-run until both pass
+\`\`\`
+
+#### 4.4.5: CodeRabbit Review
+\`\`\`bash
+# Generate code review (wait for plain text results)
+coderabbit --prompt-only
+
+# Review the output and address any critical issues if needed
+\`\`\`
+
+#### 4.4.6: Log Implementation Completion
+\`\`\`bash
+# Document what was completed
+tm update-task -i 1 --append --prompt="Subtask 1.1 - Implementation complete:
+
+- Files modified: [list files changed]
+- Key changes: [summary of implementation]
+- CodeRabbit feedback addressed: [if any issues were fixed]
+- Ready for commit"
+\`\`\`
+
+#### 4.4.7: Commit Subtask Work
+\`\`\`bash
+# Stage changes
+git add .
+
+# Commit with detailed message following git_workflow.mdc format
+git commit -m "feat(task-1): Complete subtask 1.1 - [Subtask Title]
+
+- Implementation details
+- Key changes made
+- Files modified: [list files]
+- CodeRabbit review completed
+
+Subtask 1.1: [Brief description of what was accomplished]
+Relates to Task 1: [Main task title]"
+\`\`\`
+
+#### 4.4.8: Mark Subtask as Done
+\`\`\`bash
+tm set-status -i 1.1 -s done
+\`\`\`
+
+#### 4.4.9: Move to Next Subtask
+Repeat steps 4.4.1 through 4.4.8 for the next subtask (1.2, 1.3, etc.)
+
+### 4.5: Complete Parent Task
+
+After all subtasks are complete:
+
+#### 4.5.1: Final Quality Checks
+\`\`\`bash
+# Final linting
+pnpm lint
+
+# Final type checking
+pnpm typecheck
+
+# Final CodeRabbit review
+coderabbit --prompt-only
+
+# Address any remaining issues if critical
+\`\`\`
+
+#### 4.5.2: Log Task Completion
+\`\`\`bash
+# Document final task completion
+tm update-task -i 1 --append --prompt="Task 1 - Complete:
+
+- All subtasks completed: [list all subtasks]
+- Final verification passed: lint, typecheck, CodeRabbit review
+- Files changed: [comprehensive list]
+- Committed to brief branch"
+\`\`\`
+
+#### 4.5.3: Mark Parent Task as Done
+\`\`\`bash
+tm set-status -i 1 -s done
+\`\`\`
+
+**Note**: Do NOT push or create PR yet. Continue to next task in the same branch.
+
+### 4.6: Move to Next Task
+
+\`\`\`bash
+# Verify remaining tasks
+tm list
+
+# Continue with next task (e.g., Task 2)
+# Repeat steps 4.1 through 4.5 for Task 2, then Task 3, etc.
+\`\`\`
+
+## Step 5: Complete All Tasks
+
+Continue working through all tasks (Steps 4.1-4.6) until all tasks in the brief are complete. All work is committed to the same \`hamster-brief\` branch.
+
+## Step 6: Final Verification & PR Creation
+
+After ALL tasks are complete:
+
+### 6.1: Verify All Tasks Complete
+\`\`\`bash
+# Verify all tasks are done
+tm list
+
+# Should show all tasks with status 'done'
+\`\`\`
+
+### 6.2: Final Quality Checks
+\`\`\`bash
+# Final comprehensive checks
+pnpm lint
+pnpm typecheck
+coderabbit --prompt-only
+
+# Address any remaining issues if critical
+\`\`\`
+
+### 6.3: Push Branch
+\`\`\`bash
+# Push the brief branch to remote
+git push origin hamster-brief
+\`\`\`
+
+### 6.4: Create Pull Request to Dev
+\`\`\`bash
+# Get all task titles (adjust task IDs as needed)
+# Create comprehensive PR description
+
+gh pr create \\
+  --base dev \\
+  --title "Hamster Brief: Complete Implementation" \\
+  --body "## Brief Overview
+Completed all tasks from Hamster brief.
+
+## Tasks Completed
+- [x] Task 1: [Task 1 title]
+  - Subtasks: 1.1, 1.2, 1.3
+- [x] Task 2: [Task 2 title]
+  - Subtasks: 2.1, 2.2
+- [x] Task 3: [Task 3 title]
+  - [Continue listing all tasks]
+
+## Implementation Summary
+- Total tasks: [number]
+- Total subtasks: [number]
+- Files modified: [comprehensive list]
+- All quality checks passed
+
+## Quality Checks
+- Linting passed (pnpm lint)
+- Type checking passed (pnpm typecheck)
+- CodeRabbit review completed for all changes
+
+## Testing
+- [ ] Manual testing completed
+- [ ] All checks passing
+
+Complete implementation of Hamster brief tasks"
+\`\`\`
+
+## Step 7: Cleanup
+
+\`\`\`bash
+# After PR is merged, switch back to dev
+git checkout dev
+git pull origin dev
+
+# Delete local branch (optional)
+git branch -d hamster-brief
+\`\`\`
+
+## Important Notes
+
+- **Use ONLY**: \`tm list\`, \`tm show <id>\`, \`tm set-status\`, \`tm update-task\`, \`tm auth refresh\`, \`tm context <brief url>\`
+- **DON'T use MCP tools** - not compatible with Hamster integration
+- **Single branch per brief**: All tasks work in the same branch (\`hamster-brief\`)
+- **Single PR per brief**: One PR created after all tasks are complete
+- **Always target dev branch** - never main branch
+- **Regular logging**: Use \`tm update-task -i <id> --append\` frequently to document:
+  - Context gathered during exploration
+  - Implementation decisions made
+  - Challenges encountered
+  - Completion status
+- **Quality gates**: Never skip lint, typecheck, or CodeRabbit review
+- **Commit format**: Follow git_workflow.mdc commit message standards
+- **PR format**: Always use \`--base dev\` when creating PRs
+
+## Workflow Summary
+
+\`\`\`
+1. Verify connection -> tm context
+2. List tasks -> tm list
+3. Create single branch -> git checkout -b hamster-brief
+4. For each task (in same branch):
+   a. Read task -> tm show X
+   b. Log context -> tm update-task -i X --append
+   c. Mark in-progress -> tm set-status -i X,X.Y -s in-progress
+   d. For each subtask:
+      - Read -> tm show X.Y
+      - Log context -> tm update-task -i X --append
+      - Implement code
+      - Verify -> pnpm lint && pnpm typecheck
+      - Review -> coderabbit --prompt-only
+      - Log completion -> tm update-task -i X --append
+      - Commit -> git commit (following git_workflow.mdc format)
+      - Mark done -> tm set-status -i X.Y -s done
+   e. Final checks -> pnpm lint && pnpm typecheck && coderabbit --prompt-only
+   f. Log completion -> tm update-task -i X --append
+   g. Mark task done -> tm set-status -i X -s done
+   h. Continue to next task (same branch)
+5. After ALL tasks complete:
+   a. Final verification -> pnpm lint && pnpm typecheck && coderabbit --prompt-only
+   b. Push branch -> git push origin hamster-brief
+   c. Create PR -> gh pr create --base dev
+\`\`\`
+`}),V(`show-task`,`Show Task`,`<task-id>`,`Show detailed task information with rich context and insights.
+
+Arguments: $ARGUMENTS
+
+## Enhanced Task Display
+
+Parse arguments to determine what to show and how.
+
+### 1. **Smart Task Selection**
+
+Based on $ARGUMENTS:
+- Number → Show specific task with full context
+- "current" → Show active in-progress task(s)
+- "next" → Show recommended next task
+- "blocked" → Show all blocked tasks with reasons
+- "critical" → Show critical path tasks
+- Multiple IDs → Comparative view
+
+### 2. **Contextual Information**
+
+For each task, intelligently include:
+
+**Core Details**
+- Full task information (id, title, description, details)
+- Current status with history
+- Test strategy and acceptance criteria
+- Priority and complexity analysis
+
+**Relationships**
+- Dependencies (what it needs)
+- Dependents (what needs it)
+- Parent/subtask hierarchy
+- Related tasks (similar work)
+
+**Time Intelligence**
+- Created/updated timestamps
+- Time in current status
+- Estimated vs actual time
+- Historical completion patterns
+
+### 3. **Visual Enhancements**
+
+\`\`\`
+📋 Task #45: Implement User Authentication
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Status: 🟡 in-progress (2 hours)
+Priority: 🔴 High | Complexity: 73/100
+
+Dependencies: ✅ #41, ✅ #42, ⏳ #43 (blocked)
+Blocks: #46, #47, #52
+
+Progress: ████████░░ 80% complete
+
+Recent Activity:
+- 2h ago: Status changed to in-progress
+- 4h ago: Dependency #42 completed
+- Yesterday: Task expanded with 3 subtasks
+\`\`\`
+
+### 4. **Intelligent Insights**
+
+Based on task analysis:
+- **Risk Assessment**: Complexity vs time remaining
+- **Bottleneck Analysis**: Is this blocking critical work?
+- **Recommendation**: Suggested approach or concerns
+- **Similar Tasks**: How others completed similar work
+
+### 5. **Action Suggestions**
+
+Context-aware next steps:
+- If blocked → Show how to unblock
+- If complex → Suggest expansion
+- If in-progress → Show completion checklist
+- If done → Show dependent tasks ready to start
+
+### 6. **Multi-Task View**
+
+When showing multiple tasks:
+- Common dependencies
+- Optimal completion order
+- Parallel work opportunities
+- Combined complexity analysis`),V(`list-tasks`,`List Tasks`,`[filters]`,`List tasks with intelligent argument parsing.
+
+Parse arguments to determine filters and display options:
+- Status: pending, in-progress, done, review, deferred, cancelled
+- Priority: high, medium, low (or priority:high)
+- Special: subtasks, tree, dependencies, blocked
+- IDs: Direct numbers (e.g., "1,3,5" or "1-5")
+- Complex: "pending high" = pending AND high priority
+
+Arguments: $ARGUMENTS
+
+Let me parse your request intelligently:
+
+1. **Detect Filter Intent**
+   - If arguments contain status keywords → filter by status
+   - If arguments contain priority → filter by priority
+   - If arguments contain "subtasks" → include subtasks
+   - If arguments contain "tree" → hierarchical view
+   - If arguments contain numbers → show specific tasks
+   - If arguments contain "blocked" → show blocked tasks only
+
+2. **Smart Combinations**
+   Examples of what I understand:
+   - "pending high" → pending tasks with high priority
+   - "done today" → tasks completed today
+   - "blocked" → tasks with unmet dependencies
+   - "1-5" → tasks 1 through 5
+   - "subtasks tree" → hierarchical view with subtasks
+
+3. **Execute Appropriate Query**
+   Based on parsed intent, run the most specific taskgraph command
+
+4. **Enhanced Display**
+   - Group by relevant criteria
+   - Show most important information first
+   - Use visual indicators for quick scanning
+   - Include relevant metrics
+
+5. **Intelligent Suggestions**
+   Based on what you're viewing, suggest next actions:
+   - Many pending? → Suggest priority order
+   - Many blocked? → Show dependency resolution
+   - Looking at specific tasks? → Show related tasks`),B({name:`list-tasks-with-subtasks`,description:`List Tasks With Subtasks`,content:`List all tasks including their subtasks in a hierarchical view.
+
+This command shows all tasks with their nested subtasks, providing a complete project overview.
+
+## Execution
+
+Run the TaskGraph list command with subtasks flag:
+\`\`\`bash
+taskgraph list --with-subtasks
+\`\`\`
+
+## Enhanced Display
+
+I'll organize the output to show:
+- Parent tasks with clear indicators
+- Nested subtasks with proper indentation
+- Status badges for quick scanning
+- Dependencies and blockers highlighted
+- Progress indicators for tasks with subtasks
+
+## Smart Filtering
+
+Based on the task hierarchy:
+- Show completion percentage for parent tasks
+- Highlight blocked subtask chains
+- Group by functional areas
+- Indicate critical path items
+
+This gives you a complete tree view of your project structure.`}),V(`list-tasks-by-status`,`List Tasks By Status`,`<status>`,`List tasks filtered by a specific status.
+
+Arguments: $ARGUMENTS
+
+Parse the status from arguments and list only tasks matching that status.
+
+## Status Options
+- \`pending\` - Not yet started
+- \`in-progress\` - Currently being worked on
+- \`done\` - Completed
+- \`review\` - Awaiting review
+- \`deferred\` - Postponed
+- \`cancelled\` - Cancelled
+
+## Execution
+
+Based on $ARGUMENTS, run:
+\`\`\`bash
+taskgraph list --status=$ARGUMENTS
+\`\`\`
+
+## Enhanced Display
+
+For the filtered results:
+- Group by priority within the status
+- Show time in current status
+- Highlight tasks approaching deadlines
+- Display blockers and dependencies
+- Suggest next actions for each status group
+
+## Intelligent Insights
+
+Based on the status filter:
+- **Pending**: Show recommended start order
+- **In-Progress**: Display idle time warnings
+- **Done**: Show newly unblocked tasks
+- **Review**: Indicate review duration
+- **Deferred**: Show reactivation criteria
+- **Cancelled**: Display impact analysis`),V(`project-status`,`Project Status`,`[focus-area]`,`Enhanced status command with comprehensive project insights.
+
+Arguments: $ARGUMENTS
+
+## Intelligent Status Overview
+
+### 1. **Executive Summary**
+Quick dashboard view:
+- 🏃 Active work (in-progress tasks)
+- 📊 Progress metrics (% complete, velocity)
+- 🚧 Blockers and risks
+- ⏱️ Time analysis (estimated vs actual)
+- 🎯 Sprint/milestone progress
+
+### 2. **Contextual Analysis**
+
+Based on $ARGUMENTS, focus on:
+- "sprint" → Current sprint progress and burndown
+- "blocked" → Dependency chains and resolution paths
+- "team" → Task distribution and workload
+- "timeline" → Schedule adherence and projections
+- "risk" → High complexity or overdue items
+
+### 3. **Smart Insights**
+
+**Workflow Health:**
+- Idle tasks (in-progress > 24h without updates)
+- Bottlenecks (multiple tasks waiting on same dependency)
+- Quick wins (low complexity, high impact)
+
+**Predictive Analytics:**
+- Completion projections based on velocity
+- Risk of missing deadlines
+- Recommended task order for optimal flow
+
+### 4. **Visual Intelligence**
+
+Dynamic visualization based on data:
+\`\`\`
+Sprint Progress: ████████░░ 80% (16/20 tasks)
+Velocity Trend: ↗️ +15% this week
+Blocked Tasks:  🔴 3 critical path items
+
+Priority Distribution:
+High:   ████████ 8 tasks (2 blocked)
+Medium: ████░░░░ 4 tasks
+Low:    ██░░░░░░ 2 tasks
+\`\`\`
+
+### 5. **Actionable Recommendations**
+
+Based on analysis:
+1. **Immediate actions** (unblock critical path)
+2. **Today's focus** (optimal task sequence)
+3. **Process improvements** (recurring patterns)
+4. **Resource needs** (skills, time, dependencies)
+
+### 6. **Historical Context**
+
+Compare to previous periods:
+- Velocity changes
+- Pattern recognition
+- Improvement areas
+- Success patterns to repeat`),V(`next-task`,`Next Task`,`[preference]`,`Intelligently determine and prepare the next action based on comprehensive context.
+
+This enhanced version of 'next' considers:
+- Current task states
+- Recent activity
+- Time constraints
+- Dependencies
+- Your working patterns
+
+Arguments: $ARGUMENTS
+
+## Intelligent Next Action
+
+### 1. **Context Gathering**
+Let me analyze the current situation:
+- Active tasks (in-progress)
+- Recently completed tasks
+- Blocked tasks
+- Time since last activity
+- Arguments provided: $ARGUMENTS
+
+### 2. **Smart Decision Tree**
+
+**If you have an in-progress task:**
+- Has it been idle > 2 hours? → Suggest resuming or switching
+- Near completion? → Show remaining steps
+- Blocked? → Find alternative task
+
+**If no in-progress tasks:**
+- Unblocked high-priority tasks? → Start highest
+- Complex tasks need breakdown? → Suggest expansion
+- All tasks blocked? → Show dependency resolution
+
+**Special arguments handling:**
+- "quick" → Find task < 2 hours
+- "easy" → Find low complexity task
+- "important" → Find high priority regardless of complexity
+- "continue" → Resume last worked task
+
+### 3. **Preparation Workflow**
+
+Based on selected task:
+1. Show full context and history
+2. Set up development environment
+3. Run relevant tests
+4. Open related files
+5. Show similar completed tasks
+6. Estimate completion time
+
+### 4. **Alternative Suggestions**
+
+Always provide options:
+- Primary recommendation
+- Quick alternative (< 1 hour)
+- Strategic option (unblocks most tasks)
+- Learning option (new technology/skill)
+
+### 5. **Workflow Integration**
+
+Seamlessly connect to:
+- \`/project:taskgraph:start [selected]\`
+- \`/project:workflows:auto-implement\`
+- \`/project:taskgraph:expand\` (if complex)
+- \`/project:utils:complexity-report\` (if unsure)
+
+The goal: Zero friction from decision to implementation.`),V(`help`,`Help`,`[command-name]`,"Show help for TaskGraph commands.\n\nArguments: $ARGUMENTS\n\nDisplay help for TaskGraph commands and available options.\n\n## TaskGraph Command Help\n\n### Quick Navigation\n\nType `/taskgraph:` and use tab completion to explore all commands.\n\n### Command Categories\n\n#### 🚀 Setup & Installation\n- `/taskgraph:install-taskgraph` - Comprehensive installation guide\n- `/taskgraph:quick-install-taskgraph` - One-line global install\n\n#### 📋 Project Setup\n- `/taskgraph:init-project` - Initialize new project\n- `/taskgraph:init-project-quick` - Quick setup with auto-confirm\n- `/taskgraph:view-models` - View AI configuration\n- `/taskgraph:setup-models` - Configure AI providers\n\n#### 🎯 Task Generation\n- `/taskgraph:parse-prd` - Generate tasks from PRD\n- `/taskgraph:parse-prd-with-research` - Enhanced parsing\n- `/taskgraph:generate-tasks` - Create task files\n\n#### 📝 Task Management\n- `/taskgraph:list-tasks` - List all tasks\n- `/taskgraph:list-tasks-by-status` - List tasks filtered by status\n- `/taskgraph:list-tasks-with-subtasks` - List tasks with subtasks\n- `/taskgraph:show-task` - Display task details\n- `/taskgraph:add-task` - Create new task\n- `/taskgraph:update-task` - Update single task\n- `/taskgraph:update-tasks-from-id` - Update multiple tasks\n- `/taskgraph:next-task` - Get next task recommendation\n\n#### 🔄 Status Management\n- `/taskgraph:to-pending` - Set task to pending\n- `/taskgraph:to-in-progress` - Set task to in-progress\n- `/taskgraph:to-done` - Set task to done\n- `/taskgraph:to-review` - Set task to review\n- `/taskgraph:to-deferred` - Set task to deferred\n- `/taskgraph:to-cancelled` - Set task to cancelled\n\n#### 🔍 Analysis & Breakdown\n- `/taskgraph:analyze-complexity` - Analyze task complexity\n- `/taskgraph:complexity-report` - View complexity report\n- `/taskgraph:expand-task` - Break down complex task\n- `/taskgraph:expand-all-tasks` - Expand all eligible tasks\n\n#### 🔗 Dependencies\n- `/taskgraph:add-dependency` - Add task dependency\n- `/taskgraph:remove-dependency` - Remove dependency\n- `/taskgraph:validate-dependencies` - Check for issues\n- `/taskgraph:fix-dependencies` - Auto-fix dependency issues\n\n#### 📦 Subtasks\n- `/taskgraph:add-subtask` - Add subtask to task\n- `/taskgraph:convert-task-to-subtask` - Convert task to subtask\n- `/taskgraph:remove-subtask` - Remove subtask\n- `/taskgraph:remove-subtasks` - Clear specific task subtasks\n- `/taskgraph:remove-all-subtasks` - Clear all subtasks\n\n#### 🗑️ Task Removal\n- `/taskgraph:remove-task` - Remove task permanently\n\n#### 🤖 Workflows\n- `/taskgraph:smart-workflow` - Intelligent workflows\n- `/taskgraph:command-pipeline` - Command chaining\n- `/taskgraph:auto-implement-tasks` - Auto-implementation\n\n#### 📊 Utilities\n- `/taskgraph:analyze-project` - Project analysis\n- `/taskgraph:project-status` - Project dashboard\n- `/taskgraph:sync-readme` - Sync README with tasks\n- `/taskgraph:learn` - Interactive learning\n- `/taskgraph:tm-main` - Main TaskGraph interface\n\n### Quick Start Examples\n\n```\n/taskgraph:list-tasks\n/taskgraph:show-task 1.2\n/taskgraph:add-task\n/taskgraph:next-task\n```\n\n### Getting Started\n\n1. Install: `/taskgraph:quick-install-taskgraph`\n2. Initialize: `/taskgraph:init-project-quick`\n3. Learn: `/taskgraph:learn`\n4. Work: `/taskgraph:smart-workflow`\n\nFor detailed command info, run the specific command with `--help` or check command documentation."),V(`to-done`,`To Done`,`<task-id>`,`Mark a task as completed.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Completing a Task
+
+This command validates task completion and updates project state intelligently.
+
+## Pre-Completion Checks
+
+1. Verify test strategy was followed
+2. Check if all subtasks are complete
+3. Validate acceptance criteria met
+4. Ensure code is committed
+
+## Execution
+
+\`\`\`bash
+taskgraph set-status --id=$ARGUMENTS --status=done
+\`\`\`
+
+## Post-Completion Actions
+
+1. **Update Dependencies**
+   - Identify newly unblocked tasks
+   - Update sprint progress
+   - Recalculate project timeline
+
+2. **Documentation**
+   - Generate completion summary
+   - Update CLAUDE.md with learnings
+   - Log implementation approach
+
+3. **Next Steps**
+   - Show newly available tasks
+   - Suggest logical next task
+   - Update velocity metrics
+
+## Celebration & Learning
+
+- Show impact of completion
+- Display unblocked work
+- Recognize achievement
+- Capture lessons learned`),V(`to-pending`,`To Pending`,`<task-id>`,`Set a task's status to pending.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Setting Task to Pending
+
+This moves a task back to the pending state, useful for:
+- Resetting erroneously started tasks
+- Deferring work that was prematurely begun
+- Reorganizing sprint priorities
+
+## Execution
+
+\`\`\`bash
+taskgraph set-status --id=$ARGUMENTS --status=pending
+\`\`\`
+
+## Validation
+
+Before setting to pending:
+- Warn if task is currently in-progress
+- Check if this will block other tasks
+- Suggest documenting why it's being reset
+- Preserve any work already done
+
+## Smart Actions
+
+After setting to pending:
+- Update sprint planning if needed
+- Notify about freed resources
+- Suggest priority reassessment
+- Log the status change with context`),V(`to-in-progress`,`To In Progress`,`<task-id>`,`Start working on a task by setting its status to in-progress.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Starting Work on Task
+
+This command does more than just change status - it prepares your environment for productive work.
+
+## Pre-Start Checks
+
+1. Verify dependencies are met
+2. Check if another task is already in-progress
+3. Ensure task details are complete
+4. Validate test strategy exists
+
+## Execution
+
+\`\`\`bash
+taskgraph set-status --id=$ARGUMENTS --status=in-progress
+\`\`\`
+
+## Environment Setup
+
+After setting to in-progress:
+1. Create/checkout appropriate git branch
+2. Open relevant documentation
+3. Set up test watchers if applicable
+4. Display task details and acceptance criteria
+5. Show similar completed tasks for reference
+
+## Smart Suggestions
+
+- Estimated completion time based on complexity
+- Related files from similar tasks
+- Potential blockers to watch for
+- Recommended first steps`),V(`update-task`,`Update Task`,`<update-spec>`,`Update tasks with intelligent field detection and bulk operations.
+
+Arguments: $ARGUMENTS
+
+## Intelligent Task Updates
+
+Parse arguments to determine update intent and execute smartly.
+
+### 1. **Natural Language Processing**
+
+Understand update requests like:
+- "mark 23 as done" → Update status to done
+- "increase priority of 45" → Set priority to high
+- "add dependency on 12 to task 34" → Add dependency
+- "tasks 20-25 need review" → Bulk status update
+- "all API tasks high priority" → Pattern-based update
+
+### 2. **Smart Field Detection**
+
+Automatically detect what to update:
+- Status keywords: done, complete, start, pause, review
+- Priority changes: urgent, high, low, deprioritize
+- Dependency updates: depends on, blocks, after
+- Assignment: assign to, owner, responsible
+- Time: estimate, spent, deadline
+
+### 3. **Bulk Operations**
+
+Support for multiple task updates:
+\`\`\`
+Examples:
+- "complete tasks 12, 15, 18"
+- "all pending auth tasks to in-progress"
+- "increase priority for tasks blocking 45"
+- "defer all documentation tasks"
+\`\`\`
+
+### 4. **Contextual Validation**
+
+Before updating, check:
+- Status transitions are valid
+- Dependencies don't create cycles
+- Priority changes make sense
+- Bulk updates won't break project flow
+
+Show preview:
+\`\`\`
+Update Preview:
+─────────────────
+Tasks to update: #23, #24, #25
+Change: status → in-progress
+Impact: Will unblock tasks #30, #31
+Warning: Task #24 has unmet dependencies
+\`\`\`
+
+### 5. **Smart Suggestions**
+
+Based on update:
+- Completing task? → Show newly unblocked tasks
+- Changing priority? → Show impact on sprint
+- Adding dependency? → Check for conflicts
+- Bulk update? → Show summary of changes
+
+### 6. **Workflow Integration**
+
+After updates:
+- Auto-update dependent task states
+- Trigger status recalculation
+- Update sprint/milestone progress
+- Log changes with context
+
+Result: Flexible, intelligent task updates with safety checks.`),V(`update-single-task`,`Update Single Task`,`<task-id> <changes>`,`Update a single specific task with new information.
+
+Arguments: $ARGUMENTS
+
+Parse task ID and update details.
+
+## Single Task Update
+
+Precisely update one task with AI assistance to maintain consistency.
+
+## Argument Parsing
+
+Natural language updates:
+- "5: add caching requirement"
+- "update 5 to include error handling"
+- "task 5 needs rate limiting"
+- "5 change priority to high"
+
+## Execution
+
+\`\`\`bash
+taskgraph update-task --id=<id> --prompt="<context>"
+\`\`\`
+
+## Update Types
+
+### 1. **Content Updates**
+- Enhance description
+- Add requirements
+- Clarify details
+- Update acceptance criteria
+
+### 2. **Metadata Updates**
+- Change priority
+- Adjust time estimates
+- Update complexity
+- Modify dependencies
+
+### 3. **Strategic Updates**
+- Revise approach
+- Change test strategy
+- Update implementation notes
+- Adjust subtask needs
+
+## AI-Powered Updates
+
+The AI:
+1. **Understands Context**
+   - Reads current task state
+   - Identifies update intent
+   - Maintains consistency
+   - Preserves important info
+
+2. **Applies Changes**
+   - Updates relevant fields
+   - Keeps style consistent
+   - Adds without removing
+   - Enhances clarity
+
+3. **Validates Results**
+   - Checks coherence
+   - Verifies completeness
+   - Maintains relationships
+   - Suggests related updates
+
+## Example Updates
+
+\`\`\`
+/taskgraph:update/single 5: add rate limiting
+→ Updating Task #5: "Implement API endpoints"
+
+Current: Basic CRUD endpoints
+Adding: Rate limiting requirements
+
+Updated sections:
+✓ Description: Added rate limiting mention
+✓ Details: Added specific limits (100/min)
+✓ Test Strategy: Added rate limit tests
+✓ Complexity: Increased from 5 to 6
+✓ Time Estimate: Increased by 2 hours
+
+Suggestion: Also update task #6 (API Gateway) for consistency?
+\`\`\`
+
+## Smart Features
+
+1. **Incremental Updates**
+   - Adds without overwriting
+   - Preserves work history
+   - Tracks what changed
+   - Shows diff view
+
+2. **Consistency Checks**
+   - Related task alignment
+   - Subtask compatibility
+   - Dependency validity
+   - Timeline impact
+
+3. **Update History**
+   - Timestamp changes
+   - Track who/what updated
+   - Reason for update
+   - Previous versions
+
+## Field-Specific Updates
+
+Quick syntax for specific fields:
+- "5 priority:high" → Update priority only
+- "5 add-time:4h" → Add to time estimate
+- "5 status:review" → Change status
+- "5 depends:3,4" → Add dependencies
+
+## Post-Update
+
+- Show updated task
+- Highlight changes
+- Check related tasks
+- Update suggestions
+- Timeline adjustments`),V(`update-tasks-from-id`,`Update Tasks From ID`,`<from-id> <changes>`,`Update multiple tasks starting from a specific ID.
+
+Arguments: $ARGUMENTS
+
+Parse starting task ID and update context.
+
+## Bulk Task Updates
+
+Update multiple related tasks based on new requirements or context changes.
+
+## Argument Parsing
+
+- "from 5: add security requirements"
+- "5 onwards: update API endpoints"
+- "starting at 5: change to use new framework"
+
+## Execution
+
+\`\`\`bash
+taskgraph update --from=<id> --prompt="<context>"
+\`\`\`
+
+## Update Process
+
+### 1. **Task Selection**
+Starting from specified ID:
+- Include the task itself
+- Include all dependent tasks
+- Include related subtasks
+- Smart boundary detection
+
+### 2. **Context Application**
+AI analyzes the update context and:
+- Identifies what needs changing
+- Maintains consistency
+- Preserves completed work
+- Updates related information
+
+### 3. **Intelligent Updates**
+- Modify descriptions appropriately
+- Update test strategies
+- Adjust time estimates
+- Revise dependencies if needed
+
+## Smart Features
+
+1. **Scope Detection**
+   - Find natural task groupings
+   - Identify related features
+   - Stop at logical boundaries
+   - Avoid over-updating
+
+2. **Consistency Maintenance**
+   - Keep naming conventions
+   - Preserve relationships
+   - Update cross-references
+   - Maintain task flow
+
+3. **Change Preview**
+   \`\`\`
+   Bulk Update Preview
+   ━━━━━━━━━━━━━━━━━━
+   Starting from: Task #5
+   Tasks to update: 8 tasks + 12 subtasks
+
+   Context: "add security requirements"
+
+   Changes will include:
+   - Add security sections to descriptions
+   - Update test strategies for security
+   - Add security-related subtasks where needed
+   - Adjust time estimates (+20% average)
+
+   Continue? (y/n)
+   \`\`\`
+
+## Example Updates
+
+\`\`\`
+/taskgraph:update-tasks-from-id 5: change database to PostgreSQL
+→ Analyzing impact starting from task #5
+→ Found 6 related tasks to update
+→ Updates will maintain consistency
+→ Preview changes? (y/n)
+
+Applied updates:
+✓ Task #5: Updated connection logic references
+✓ Task #6: Changed migration approach
+✓ Task #7: Updated query syntax notes
+✓ Task #8: Revised testing strategy
+✓ Task #9: Updated deployment steps
+✓ Task #12: Changed backup procedures
+\`\`\`
+
+## Safety Features
+
+- Preview all changes
+- Selective confirmation
+- Rollback capability
+- Change logging
+- Validation checks
+
+## Post-Update
+
+- Summary of changes
+- Consistency verification
+- Suggest review tasks
+- Update timeline if needed`),B({name:`tm-main`,description:`TaskGraph Main`,content:"# TaskGraph Command Reference\n\nComprehensive command structure for TaskGraph integration with Claude Code.\n\n## Command Organization\n\nCommands are organized hierarchically to match TaskGraph's CLI structure while providing enhanced Claude Code integration.\n\n## Project Setup & Configuration\n\n### `/taskgraph:init`\n- `init-project` - Initialize new project (handles PRD files intelligently)\n- `init-project-quick` - Quick setup with auto-confirmation (-y flag)\n\n### `/taskgraph:models`\n- `view-models` - View current AI model configuration\n- `setup-models` - Interactive model configuration\n- `set-main` - Set primary generation model\n- `set-research` - Set research model\n- `set-fallback` - Set fallback model\n\n## Task Generation\n\n### `/taskgraph:parse-prd`\n- `parse-prd` - Generate tasks from PRD document\n- `parse-prd-with-research` - Enhanced parsing with research mode\n\n### `/taskgraph:generate`\n- `generate-tasks` - Create individual task files from tasks.json\n\n## Task Management\n\n### `/taskgraph:list`\n- `list-tasks` - Smart listing with natural language filters\n- `list-tasks-with-subtasks` - Include subtasks in hierarchical view\n- `list-tasks-by-status` - Filter by specific status\n\n### `/taskgraph:set-status`\n- `to-pending` - Reset task to pending\n- `to-in-progress` - Start working on task\n- `to-done` - Mark task complete\n- `to-review` - Submit for review\n- `to-deferred` - Defer task\n- `to-cancelled` - Cancel task\n\n### `/taskgraph:sync-readme`\n- `sync-readme` - Export tasks to README.md with formatting\n\n### `/taskgraph:update`\n- `update-task` - Update tasks with natural language\n- `update-tasks-from-id` - Update multiple tasks from a starting point\n- `update-single-task` - Update specific task\n\n### `/taskgraph:add-task`\n- `add-task` - Add new task with AI assistance\n\n### `/taskgraph:remove-task`\n- `remove-task` - Remove task with confirmation\n\n## Subtask Management\n\n### `/taskgraph:add-subtask`\n- `add-subtask` - Add new subtask to parent\n- `convert-task-to-subtask` - Convert existing task to subtask\n\n### `/taskgraph:remove-subtask`\n- `remove-subtask` - Remove subtask (with optional conversion)\n\n### `/taskgraph:clear-subtasks`\n- `clear-subtasks` - Clear subtasks from specific task\n- `clear-all-subtasks` - Clear all subtasks globally\n\n## Task Analysis & Breakdown\n\n### `/taskgraph:analyze-complexity`\n- `analyze-complexity` - Analyze and generate expansion recommendations\n\n### `/taskgraph:complexity-report`\n- `complexity-report` - Display complexity analysis report\n\n### `/taskgraph:expand`\n- `expand-task` - Break down specific task\n- `expand-all-tasks` - Expand all eligible tasks\n- `with-research` - Enhanced expansion\n\n## Task Navigation\n\n### `/taskgraph:next`\n- `next-task` - Intelligent next task recommendation\n\n### `/taskgraph:show`\n- `show-task` - Display detailed task information\n\n### `/taskgraph:status`\n- `project-status` - Comprehensive project dashboard\n\n## Dependency Management\n\n### `/taskgraph:add-dependency`\n- `add-dependency` - Add task dependency\n\n### `/taskgraph:remove-dependency`\n- `remove-dependency` - Remove task dependency\n\n### `/taskgraph:validate-dependencies`\n- `validate-dependencies` - Check for dependency issues\n\n### `/taskgraph:fix-dependencies`\n- `fix-dependencies` - Automatically fix dependency problems\n\n## Workflows & Automation\n\n### `/taskgraph:workflows`\n- `smart-workflow` - Context-aware intelligent workflow execution\n- `command-pipeline` - Chain multiple commands together\n- `auto-implement-tasks` - Advanced auto-implementation with code generation\n\n## Utilities\n\n### `/taskgraph:utils`\n- `analyze-project` - Deep project analysis and insights\n\n### `/taskgraph:setup`\n- `install-taskgraph` - Comprehensive installation guide\n- `quick-install-taskgraph` - One-line global installation\n\n## Usage Patterns\n\n### Natural Language\nMost commands accept natural language arguments:\n```\n/taskgraph:add-task create user authentication system\n/taskgraph:update mark all API tasks as high priority\n/taskgraph:list show blocked tasks\n```\n\n### ID-Based Commands\nCommands requiring IDs intelligently parse from $ARGUMENTS:\n```\n/taskgraph:show 45\n/taskgraph:expand 23\n/taskgraph:set-status/to-done 67\n```\n\n### Smart Defaults\nCommands provide intelligent defaults and suggestions based on context."}),V(`smart-workflow`,`Smart Workflow`,`[context]`,`Execute an intelligent workflow based on current project state and recent commands.
+
+This command analyzes:
+1. Recent commands you've run
+2. Current project state
+3. Time of day / day of week
+4. Your working patterns
+
+Arguments: $ARGUMENTS
+
+## Intelligent Workflow Selection
+
+Based on context, I'll determine the best workflow:
+
+### Context Analysis
+- Previous command executed
+- Current task states
+- Unfinished work from last session
+- Your typical patterns
+
+### Smart Execution
+
+If last command was:
+- \`status\` → Likely starting work → Run daily standup
+- \`complete\` → Task finished → Find next task
+- \`list pending\` → Planning → Suggest sprint planning
+- \`expand\` → Breaking down work → Show complexity analysis
+- \`init\` → New project → Show onboarding workflow
+
+If no recent commands:
+- Morning? → Daily standup workflow
+- Many pending tasks? → Sprint planning
+- Tasks blocked? → Dependency resolution
+- Friday? → Weekly review
+
+### Workflow Composition
+
+I'll chain appropriate commands:
+1. Analyze current state
+2. Execute primary workflow
+3. Suggest follow-up actions
+4. Prepare environment for coding
+
+### Learning Mode
+
+This command learns from your patterns:
+- Track command sequences
+- Note time preferences
+- Remember common workflows
+- Adapt to your style
+
+Example flows detected:
+- Morning: standup → next → start
+- After lunch: status → continue task
+- End of day: complete → commit → status`),V(`learn`,`Learn`,`[topic]`,`Learn about TaskGraph capabilities through interactive exploration.
+
+Arguments: $ARGUMENTS
+
+## Interactive TaskGraph Learning
+
+Based on your input, I'll help you discover capabilities:
+
+### 1. **What are you trying to do?**
+
+If $ARGUMENTS contains:
+- "start" / "begin" → Show project initialization workflows
+- "manage" / "organize" → Show task management commands
+- "automate" / "auto" → Show automation workflows
+- "analyze" / "report" → Show analysis tools
+- "fix" / "problem" → Show troubleshooting commands
+- "fast" / "quick" → Show efficiency shortcuts
+
+### 2. **Intelligent Suggestions**
+
+Based on your project state:
+
+**No tasks yet?**
+\`\`\`
+You'll want to start with:
+1. /project:taskgraph:init <prd-file>
+   → Creates tasks from requirements
+
+2. /project:taskgraph:parse-prd <file>
+   → Alternative task generation
+
+Try: /project:taskgraph:init demo-prd.md
+\`\`\`
+
+**Have tasks?**
+Let me analyze what you might need...
+- Many pending tasks? → Learn sprint planning
+- Complex tasks? → Learn task expansion
+- Daily work? → Learn workflow automation
+
+### 3. **Command Discovery**
+
+**By Category:**
+- 📋 Task Management: list, show, add, update, complete
+- 🔄 Workflows: auto-implement, sprint-plan, daily-standup
+- 🛠️ Utilities: check-health, complexity-report, sync-memory
+- 🔍 Analysis: validate-deps, show dependencies
+
+**By Scenario:**
+- "I want to see what to work on" → \`/project:taskgraph:next\`
+- "I need to break this down" → \`/project:taskgraph:expand <id>\`
+- "Show me everything" → \`/project:taskgraph:status\`
+- "Just do it for me" → \`/project:workflows:auto-implement\`
+
+### 4. **Power User Patterns**
+
+**Command Chaining:**
+\`\`\`
+/project:taskgraph:next
+/project:taskgraph:start <id>
+/project:workflows:auto-implement
+\`\`\`
+
+**Smart Filters:**
+\`\`\`
+/project:taskgraph:list pending high
+/project:taskgraph:list blocked
+/project:taskgraph:list 1-5 tree
+\`\`\`
+
+**Automation:**
+\`\`\`
+/project:workflows:pipeline init → expand-all → sprint-plan
+\`\`\`
+
+### 5. **Learning Path**
+
+Based on your experience level:
+
+**Beginner Path:**
+1. init → Create project
+2. status → Understand state
+3. next → Find work
+4. complete → Finish task
+
+**Intermediate Path:**
+1. expand → Break down complex tasks
+2. sprint-plan → Organize work
+3. complexity-report → Understand difficulty
+4. validate-deps → Ensure consistency
+
+**Advanced Path:**
+1. pipeline → Chain operations
+2. smart-flow → Context-aware automation
+3. Custom commands → Extend the system
+
+### 6. **Try This Now**
+
+Based on what you asked about, try:
+[Specific command suggestion based on $ARGUMENTS]
+
+Want to learn more about a specific command?
+Type: /project:help <command-name>`),V(`command-pipeline`,`Command Pipeline`,`<pipeline-spec>`,`Execute a pipeline of commands based on a specification.
+
+Arguments: $ARGUMENTS
+
+## Command Pipeline Execution
+
+Parse pipeline specification from arguments. Supported formats:
+
+### Simple Pipeline
+\`init → expand-all → sprint-plan\`
+
+### Conditional Pipeline
+\`status → if:pending>10 → sprint-plan → else → next\`
+
+### Iterative Pipeline
+\`for:pending-tasks → expand → complexity-check\`
+
+### Smart Pipeline Patterns
+
+**1. Project Setup Pipeline**
+\`\`\`
+init [prd] →
+expand-all →
+complexity-report →
+sprint-plan →
+show first-sprint
+\`\`\`
+
+**2. Daily Work Pipeline**
+\`\`\`
+standup →
+if:in-progress → continue →
+else → next → start
+\`\`\`
+
+**3. Task Completion Pipeline**
+\`\`\`
+complete [id] →
+git-commit →
+if:blocked-tasks-freed → show-freed →
+next
+\`\`\`
+
+**4. Quality Check Pipeline**
+\`\`\`
+list in-progress →
+for:each → check-idle-time →
+if:idle>1day → prompt-update
+\`\`\`
+
+### Pipeline Features
+
+**Variables**
+- Store results: \`status → $count=pending-count\`
+- Use in conditions: \`if:$count>10\`
+- Pass between commands: \`expand $high-priority-tasks\`
+
+**Error Handling**
+- On failure: \`try:complete → catch:show-blockers\`
+- Skip on error: \`optional:test-run\`
+- Retry logic: \`retry:3:commit\`
+
+**Parallel Execution**
+- Parallel branches: \`[analyze | test | lint]\`
+- Join results: \`parallel → join:report\`
+
+### Execution Flow
+
+1. Parse pipeline specification
+2. Validate command sequence
+3. Execute with state passing
+4. Handle conditions and loops
+5. Aggregate results
+6. Show summary
+
+This enables complex workflows like:
+\`parse-prd → expand-all → filter:complex>70 → assign:senior → sprint-plan:weighted\``),V(`auto-implement-tasks`,`Auto Implement Tasks`,`[task-id]`,`Enhanced auto-implementation with intelligent code generation and testing.
+
+Arguments: $ARGUMENTS
+
+## Intelligent Auto-Implementation
+
+Advanced implementation with context awareness and quality checks.
+
+### 1. **Pre-Implementation Analysis**
+
+Before starting:
+- Analyze task complexity and requirements
+- Check codebase patterns and conventions
+- Identify similar completed tasks
+- Assess test coverage needs
+- Detect potential risks
+
+### 2. **Smart Implementation Strategy**
+
+Based on task type and context:
+
+**Feature Tasks**
+1. Research existing patterns
+2. Design component architecture
+3. Implement with tests
+4. Integrate with system
+5. Update documentation
+
+**Bug Fix Tasks**
+1. Reproduce issue
+2. Identify root cause
+3. Implement minimal fix
+4. Add regression tests
+5. Verify side effects
+
+**Refactoring Tasks**
+1. Analyze current structure
+2. Plan incremental changes
+3. Maintain test coverage
+4. Refactor step-by-step
+5. Verify behavior unchanged
+
+### 3. **Code Intelligence**
+
+**Pattern Recognition**
+- Learn from existing code
+- Follow team conventions
+- Use preferred libraries
+- Match style guidelines
+
+**Test-Driven Approach**
+- Write tests first when possible
+- Ensure comprehensive coverage
+- Include edge cases
+- Performance considerations
+
+### 4. **Progressive Implementation**
+
+Step-by-step with validation:
+\`\`\`
+Step 1/5: Setting up component structure ✓
+Step 2/5: Implementing core logic ✓
+Step 3/5: Adding error handling ⚡ (in progress)
+Step 4/5: Writing tests ⏳
+Step 5/5: Integration testing ⏳
+
+Current: Adding try-catch blocks and validation...
+\`\`\`
+
+### 5. **Quality Assurance**
+
+Automated checks:
+- Linting and formatting
+- Test execution
+- Type checking
+- Dependency validation
+- Performance analysis
+
+### 6. **Smart Recovery**
+
+If issues arise:
+- Diagnostic analysis
+- Suggestion generation
+- Fallback strategies
+- Manual intervention points
+- Learning from failures
+
+### 7. **Post-Implementation**
+
+After completion:
+- Generate PR description
+- Update documentation
+- Log lessons learned
+- Suggest follow-up tasks
+- Update task relationships
+
+Result: High-quality, production-ready implementations.`),V(`analyze-project`,`Analyze Project`,`[focus-area]`,`Advanced project analysis with actionable insights and recommendations.
+
+Arguments: $ARGUMENTS
+
+## Comprehensive Project Analysis
+
+Multi-dimensional analysis based on requested focus area.
+
+### 1. **Analysis Modes**
+
+Based on $ARGUMENTS:
+- "velocity" → Sprint velocity and trends
+- "quality" → Code quality metrics
+- "risk" → Risk assessment and mitigation
+- "dependencies" → Dependency graph analysis
+- "team" → Workload and skill distribution
+- "architecture" → System design coherence
+- Default → Full spectrum analysis
+
+### 2. **Velocity Analytics**
+
+\`\`\`
+📊 Velocity Analysis
+━━━━━━━━━━━━━━━━━━━
+Current Sprint: 24 points/week ↗️ +20%
+Rolling Average: 20 points/week
+Efficiency: 85% (17/20 tasks on time)
+
+Bottlenecks Detected:
+- Code review delays (avg 4h wait)
+- Test environment availability
+- Dependency on external team
+
+Recommendations:
+1. Implement parallel review process
+2. Add staging environment
+3. Mock external dependencies
+\`\`\`
+
+### 3. **Risk Assessment**
+
+**Technical Risks**
+- High complexity tasks without backup assignee
+- Single points of failure in architecture
+- Insufficient test coverage in critical paths
+- Technical debt accumulation rate
+
+**Project Risks**
+- Critical path dependencies
+- Resource availability gaps
+- Deadline feasibility analysis
+- Scope creep indicators
+
+### 4. **Dependency Intelligence**
+
+Visual dependency analysis:
+\`\`\`
+Critical Path:
+#12 → #15 → #23 → #45 → #50 (20 days)
+         ↘ #24 → #46 ↗
+
+Optimization: Parallelize #15 and #24
+Time Saved: 3 days
+\`\`\`
+
+### 5. **Quality Metrics**
+
+**Code Quality**
+- Test coverage trends
+- Complexity scores
+- Technical debt ratio
+- Review feedback patterns
+
+**Process Quality**
+- Rework frequency
+- Bug introduction rate
+- Time to resolution
+- Knowledge distribution
+
+### 6. **Predictive Insights**
+
+Based on patterns:
+- Completion probability by deadline
+- Resource needs projection
+- Risk materialization likelihood
+- Suggested interventions
+
+### 7. **Executive Dashboard**
+
+High-level summary with:
+- Health score (0-100)
+- Top 3 risks
+- Top 3 opportunities
+- Recommended actions
+- Success probability
+
+Result: Data-driven decisions with clear action paths.`),V(`sync-readme`,`Sync README`,`[options]`,`Export tasks to README.md with professional formatting.
+
+Arguments: $ARGUMENTS
+
+Generate a well-formatted README with current task information.
+
+## README Synchronization
+
+Creates or updates README.md with beautifully formatted task information.
+
+## Argument Parsing
+
+Optional filters:
+- "pending" → Only pending tasks
+- "with-subtasks" → Include subtask details
+- "by-priority" → Group by priority
+- "sprint" → Current sprint only
+
+## Execution
+
+\`\`\`bash
+taskgraph sync-readme [--with-subtasks] [--status=<status>]
+\`\`\`
+
+## README Generation
+
+### 1. **Project Header**
+\`\`\`markdown
+# Project Name
+
+## 📋 Task Progress
+
+Last Updated: 2024-01-15 10:30 AM
+
+### Summary
+- Total Tasks: 45
+- Completed: 15 (33%)
+- In Progress: 5 (11%)
+- Pending: 25 (56%)
+\`\`\`
+
+### 2. **Task Sections**
+Organized by status or priority:
+- Progress indicators
+- Task descriptions
+- Dependencies noted
+- Time estimates
+
+### 3. **Visual Elements**
+- Progress bars
+- Status badges
+- Priority indicators
+- Completion checkmarks
+
+## Smart Features
+
+1. **Intelligent Grouping**
+   - By feature area
+   - By sprint/milestone
+   - By assigned developer
+   - By priority
+
+2. **Progress Tracking**
+   - Overall completion
+   - Sprint velocity
+   - Burndown indication
+   - Time tracking
+
+3. **Formatting Options**
+   - GitHub-flavored markdown
+   - Task checkboxes
+   - Collapsible sections
+   - Table format available
+
+## Example Output
+
+\`\`\`markdown
+## 🚀 Current Sprint
+
+### In Progress
+- [ ] 🔄 #5 **Implement user authentication** (60% complete)
+  - Dependencies: API design (#3 ✅)
+  - Subtasks: 4 (2 completed)
+  - Est: 8h / Spent: 5h
+
+### Pending (High Priority)
+- [ ] ⚡ #8 **Create dashboard UI**
+  - Blocked by: #5
+  - Complexity: High
+  - Est: 12h
+\`\`\`
+
+## Customization
+
+Based on arguments:
+- Include/exclude sections
+- Detail level control
+- Custom grouping
+- Filter by criteria
+
+## Post-Sync
+
+After generation:
+1. Show diff preview
+2. Backup existing README
+3. Write new content
+4. Commit reminder
+5. Update timestamp
+
+## Integration
+
+Works well with:
+- Git workflows
+- CI/CD pipelines
+- Project documentation
+- Team updates
+- Client reports`)];function U(e,t){return t===`team`?e.filter(e=>e.metadata.mode===`team`||e.metadata.mode===`common`||!e.metadata.mode):e.filter(e=>e.metadata.mode===`solo`||e.metadata.mode===`common`||!e.metadata.mode)}U(H,`solo`),U(H,`team`),H.filter(e=>e.metadata.mode===`common`||!e.metadata.mode);var Ge=class{supportsNestedCommands=!0;get supportsCommands(){return this.commandsDir!==``}formatAll(e){return e.map(e=>this.format(e))}getFilename(e){return this.supportsNestedCommands?`${e}${this.extension}`:`tm-${e}${this.extension}`}transformArgumentPlaceholder(e){return e}postProcess(e){return e}getCommandsPath(e){return this.supportsNestedCommands?v.join(e,this.commandsDir,`tm`):v.join(e,this.commandsDir)}addSlashCommands(e,t,n){let r=this.getCommandsPath(e),i=[];if(!this.supportsCommands)return{success:!1,count:0,directory:r,files:[],error:`Profile "${this.name}" does not support slash commands`};try{n?.mode&&this.removeSlashCommands(e,t,!1);let a=n?.mode?U(t,n.mode):t;b.existsSync(r)||b.mkdirSync(r,{recursive:!0});let o=this.formatAll(a);for(let e of o){let t=v.join(r,e.filename);b.writeFileSync(t,e.content),i.push(e.filename)}return{success:!0,count:i.length,directory:r,files:i}}catch(e){return{success:!1,count:0,directory:r,files:[],error:e instanceof Error?e.message:String(e)}}}removeSlashCommands(e,t,n=!0){let r=this.getCommandsPath(e),i=[];if(!this.supportsCommands)return{success:!1,count:0,directory:r,files:[],error:`Profile "${this.name}" does not support slash commands`};if(!b.existsSync(r))return{success:!0,count:0,directory:r,files:[]};try{let e=new Set(t.map(e=>{let t=e.metadata.name.toLowerCase();return this.supportsNestedCommands?t:`tm-${t}`})),a=b.readdirSync(r);for(let t of a){let n=v.basename(t,v.extname(t)).toLowerCase();if(e.has(n)){let e=v.join(r,t);b.rmSync(e,{force:!0}),i.push(t)}}return n&&b.readdirSync(r).length===0&&b.rmSync(r,{recursive:!0,force:!0}),{success:!0,count:i.length,directory:r,files:i}}catch(e){return{success:!1,count:i.length,directory:r,files:i,error:e instanceof Error?e.message:String(e)}}}replaceSlashCommands(e,t,n){let r=this.removeSlashCommands(e,t);return r.success?this.addSlashCommands(e,t,{mode:n}):r}};const Ke={claude:new class extends Ge{name=`claude`;displayName=`Claude Code`;commandsDir=`.claude/commands`;extension=`.md`;format(e){let t=this.buildHeader(e),n=this.transformArgumentPlaceholder(e.content);return{filename:this.getFilename(e.metadata.name),content:`${t}${n}`}}buildHeader(e){let t=[e.metadata.description,``];return e.metadata.argumentHint&&(t.push(`Arguments: $ARGUMENTS`),t.push(``)),t.join(`
+`)}}};function qe(e){return Ke[e.toLowerCase()]}function Je(){let e=ie.homedir(),t=process.env.SHELL||``;if(t.includes(`zsh`))return y.join(e,`.zshrc`);if(t.includes(`bash`)){let t=y.join(e,`.bash_profile`);return process.platform===`darwin`?t:y.join(e,`.bashrc`)}if(t.includes(`fish`))return y.join(e,`.config`,`fish`,`config.fish`);if(process.platform===`win32`){if(process.env.PSModulePath){let t=process.env.PROFILE||y.join(e,`Documents`,`WindowsPowerShell`,`Microsoft.PowerShell_profile.ps1`),n=y.join(e,`Documents`,`PowerShell`,`Microsoft.PowerShell_profile.ps1`);return S.existsSync(n)?n:S.existsSync(t)?t:n}let t=y.join(e,`.bashrc`);if(S.existsSync(t))return t}let n=y.join(e,`.zshrc`);if(S.existsSync(n))return n;let r=y.join(e,`.bashrc`);return S.existsSync(r)?r:null}function W(e){return e.endsWith(`.ps1`)}function G(e){return e.includes(`config.fish`)}function Ye(e,t,n){if(!/^[A-Z_][A-Z0-9_]*$/i.test(e))return{success:!1,message:`Invalid environment variable name: ${e}. Must start with a letter or underscore and contain only alphanumeric characters and underscores.`};if(typeof t!=`string`||t.includes(`
+`)||t.includes(`\r`))return{success:!1,message:`Invalid value: must be a single-line string without newlines`};let r=Je();if(!r)return{success:!1,message:`Could not determine shell type (zsh, bash, fish, or PowerShell)`};try{let i=y.dirname(r);if(S.existsSync(i)||S.mkdirSync(i,{recursive:!0}),!S.existsSync(r)){let e=process.platform===`darwin`&&r.endsWith(`.bash_profile`);if(W(r)||e)S.writeFileSync(r,``);else return{success:!1,shellConfigFile:r,message:`Shell config file ${r} not found`}}let a=S.readFileSync(r,`utf8`),o;if(o=W(r)?RegExp(`^\\s*\\$env:${e}\\s*=`,`m`).test(a):G(r)?RegExp(`^\\s*set\\s+-[gux]*x[gux]*\\s+${e}\\s+`,`m`).test(a):RegExp(`^\\s*export\\s+${e}\\s*=`,`m`).test(a),o)return{success:!0,shellConfigFile:r,message:`${e} already configured`,alreadyExists:!0};let s,c;W(r)?(s=`$env:${e} = "${t.replace(/["`$]/g,"`$&")}"`,c=`#`):G(r)?(s=`set -gx ${e} '${t.replace(/'/g,`'\\''`)}'`,c=`#`):(s=`export ${e}='${t.replace(/'/g,`'\\''`)}'`,c=`#`);let l=`\n${n?`${c} ${n}\n`:``}${s}\n`;return S.appendFileSync(r,l),{success:!0,shellConfigFile:r,message:`Added ${e} to ${r}`}}catch(e){return{success:!1,shellConfigFile:r,message:`Failed to modify shell config: ${e.message}`}}}function Xe(){return Ye(`ENABLE_EXPERIMENTAL_MCP_CLI`,`true`,`Claude Code deferred MCP loading (added by TaskGraph)`)}function Ze(e){let{name:t,displayName:n=t,profileDir:r=`.${t.toLowerCase()}`,rulesDir:i=`${r}/rules`,mcpConfig:a=!0,mcpConfigName:o=a?`mcp.json`:null,fileMap:s={},onAdd:c,onPostConvert:l}=e,u=o?y.join(r,o):null,f=null;try{let e=qe(t);e?.supportsCommands&&(f={profile:e,commands:H})}catch(e){d(`debug`,`[${n}] Slash command profile lookup failed: ${e.message}`)}return{profileName:t,displayName:n,profileDir:r,rulesDir:i,mcpConfig:a,mcpConfigName:o,mcpConfigPath:u,fileMap:s,slashCommands:f,...c&&{onAddRulesProfile:c},...l&&{onPostConvertRulesProfile:l}}}function Qe(e,t){d(`info`,`[Claude] Commands and agents are now available via the TaskGraph plugin`),d(`info`,`[Claude] Install with: /plugin marketplace add taskgraph`),d(`info`,`[Claude] Then: /plugin install taskgraph@taskgraph`);let n=y.join(t,`AGENTS.md`),r=y.join(e,`CLAUDE.md`),i=y.join(e,`.taskgraph`,`CLAUDE.md`),a=`@./.taskgraph/CLAUDE.md`,o=`\n## TaskGraph Instructions\n**Import TaskGraph's development workflow commands and guidelines, treat as if import is in the main CLAUDE.md file.**\n${a}`;if(S.existsSync(n))try{let t=y.join(e,`.taskgraph`);if(S.existsSync(t)||S.mkdirSync(t,{recursive:!0}),S.copyFileSync(n,i),d(`debug`,`[Claude] Created TaskGraph instructions at ${i}`),S.existsSync(r)){let e=S.readFileSync(r,`utf8`);if(e.includes(a))d(`info`,`[Claude] TaskGraph import already present in ${r}`);else{let t=e.trim()+`
+`+o+`
+`;S.writeFileSync(r,t),d(`info`,`[Claude] Added TaskGraph import to existing ${r}`)}}else{let e=`# Claude Code Instructions\n${o}\n`;S.writeFileSync(r,e),d(`info`,`[Claude] Created ${r} with TaskGraph import`)}}catch(e){d(`error`,`[Claude] Failed to set up Claude instructions: ${e.message}`)}let s=Xe();s.success?s.alreadyExists?d(`debug`,`[Claude] Deferred MCP loading already configured`):(d(`info`,`[Claude] Enabled deferred MCP loading in ${s.shellConfigFile}`),d(`info`,`[Claude] Restart your terminal for changes to take effect`)):d(`debug`,`[Claude] Could not configure deferred loading: ${s.message}`)}function $e(e){let t={};if(e.mcpServers){t.mcpServers={};for(let[n,r]of Object.entries(e.mcpServers)){let e={};e.type=`stdio`,r.command&&(e.command=r.command),r.args&&(e.args=r.args),r.env&&(e.env=r.env),Object.keys(r).forEach(t=>{[`command`,`args`,`env`,`type`].includes(t)||(e[t]=r[t])}),t.mcpServers[n]=e}}return t}function et(e,t){let n=y.join(e,`.mcp.json`);if(S.existsSync(n))try{let e=$e(JSON.parse(S.readFileSync(n,`utf8`)));S.writeFileSync(n,JSON.stringify(e,null,`	`)+`
+`),d(`debug`,`[Claude] Transformed MCP configuration to Claude format at ${n}`)}catch(e){d(`error`,`[Claude] Failed to transform MCP configuration: ${e.message}`)}}const tt=Ze({name:`claude`,displayName:`Claude Code`,profileDir:`.`,rulesDir:`.`,mcpConfigName:`.mcp.json`,fileMap:{"AGENTS.md":`.taskgraph/CLAUDE.md`},onAdd:Qe,onPostConvert:et});var nt=e({claudeProfile:()=>tt});function rt(e){return E.includes(e)}function it(e){if(!rt(e))return null;let t=nt[`${e}Profile`];if(!t)throw Error(`Profile not found: static import missing for '${e}'. Valid profiles: ${E.join(`, `)}`);return t}function at(e,t,n){let r=y.join(e,t.rulesDir),i=n?.mode,a=0;if(typeof t.onAddRulesProfile==`function`)try{t.onAddRulesProfile(r,P()),d(`debug`,`[Rule Transformer] Called onAddRulesProfile for ${t.profileName}`)}catch(e){d(`error`,`[Rule Transformer] onAddRulesProfile failed for ${t.profileName}: ${e.message}`),a++}if(t.mcpConfig!==!1)try{ve(e,t.mcpConfigPath),d(`debug`,`[Rule Transformer] Setup MCP configuration for ${t.profileName}`)}catch(e){d(`error`,`[Rule Transformer] MCP setup failed for ${t.profileName}: ${e.message}`)}if(typeof t.onPostConvertRulesProfile==`function`)try{t.onPostConvertRulesProfile(r,P()),d(`debug`,`[Rule Transformer] Called onPostConvertRulesProfile for ${t.profileName}`)}catch(e){d(`error`,`[Rule Transformer] onPostConvertRulesProfile failed for ${t.profileName}: ${e.message}`)}if(t.slashCommands)try{let n=i?{mode:i}:void 0,r=t.slashCommands.profile.addSlashCommands(e,t.slashCommands.commands,n);r.success?d(`debug`,`[Rule Transformer] Created ${r.count} slash commands in ${r.directory}${i?` (mode: ${i})`:``}`):d(`error`,`[Rule Transformer] Failed to add slash commands for ${t.profileName}: ${r.error}`)}catch(e){d(`error`,`[Rule Transformer] Slash commands failed for ${t.profileName}: ${e.message}`)}return{success:1,failed:a}}function ot(){let e=(e,t)=>`${p.text(`${e}. `)}${_.yellow(t)}`,t=(e,t)=>`${p.text(e?`   └─ `:`   ├─ `)}${t}`,n=e=>`${_.dim(`CLI: `)}${_.cyan(e)}`,r=[e(1,`Choose your AI models (optional)`),t(!1,`${_.dim(`Models: Use `)}${_.cyan(`taskgraph models --setup`)}`),t(!0,_.dim("AI calls run through your signed-in Claude Code (run `claude` once to sign in)")),e(2,`Discuss your idea with AI and create a PRD`),t(!1,`${_.dim(`Simple projects: Use `)}${_.cyan(`example_prd.txt`)}${_.dim(` template`)}`),t(!0,`${_.dim(`Complex systems: Use `)}${_.cyan(`example_prd_rpg.txt`)}${_.dim(` template`)}`),e(3,`Parse your PRD to generate initial tasks`),t(!0,n(`taskgraph parse-prd .taskgraph/docs/prd.md`)),e(4,`Analyze task complexity`),t(!0,n(`taskgraph analyze-complexity --research`)),e(5,`Expand tasks into subtasks`),t(!0,n(`taskgraph expand --all --research`)),e(6,`Start working on tasks`),t(!0,n(`taskgraph next`)),`${p.text(`7. `)}${_.green.bold(`Ship it!`)}`],i=`${_.dim(`* Run `)}${_.cyan(`taskgraph --help`)}${_.dim(` to see all available commands`)}`;return`${_.cyan.bold(`Things you should do next:`)}\n\n${r.join(`
+`)}\n\n${i}`}function st(e){try{let t=JSON.parse(S.readFileSync(e,`utf-8`));for(let e of[`main`,`research`,`fallback`])if(t.models&&t.models[e]){let n=t.models[e].provider,r=t.models[e].modelId;if(c[n]){let i=c[n].find(e=>e.id===r);i&&i.max_tokens&&(t.models[e].maxTokens=i.max_tokens)}}return S.writeFileSync(e,JSON.stringify(t,null,2)),!0}catch(e){return console.error(`Error updating config maxTokens:`,e.message),!1}}const K={debug:0,info:1,warn:2,error:3,success:4},q=process.env.TASKGRAPH_LOG_LEVEL?K[process.env.TASKGRAPH_LOG_LEVEL.toLowerCase()]:K.info;function ct(){f()||g()}function J(e,...t){let n={debug:p.muted(`•`),info:p.brand(`→`),warn:_.yellow(`!`),error:_.red(`✗`),success:_.green(`✓`)};if(K[e]>=q){let r=n[e]||``;f()||(e===`error`?console.error(r,_.red(...t)):e===`warn`?console.warn(r,_.yellow(...t)):e===`success`?console.log(r,_.green(...t)):e===`info`?console.log(r,p.brand(...t)):console.log(r,...t))}if(process.env.DEBUG===`true`){let n=`[${e.toUpperCase()}] ${t.join(` `)}\n`;S.appendFileSync(`init-debug.log`,n)}}function Y(e){S.existsSync(e)||(S.mkdirSync(e,{recursive:!0}),J(`info`,`Created directory: ${e}`))}function X(){let e=process.env.HOME||process.env.USERPROFILE,t;if(process.env.SHELL?.includes(`zsh`))t=y.join(e,`.zshrc`);else if(process.env.SHELL?.includes(`bash`))t=y.join(e,`.bashrc`);else return J(`debug`,`Could not determine shell type. Aliases not added.`),!1;try{if(!S.existsSync(t))return J(`debug`,`Shell config file ${t} not found.`),!1;let e=S.readFileSync(t,`utf8`),n=[{name:`tm`,line:`alias tm='taskgraph'`},{name:`taskgraph`,line:`alias taskgraph='taskgraph'`}].filter(t=>!e.includes(t.line));if(n.length===0)return J(`debug`,`All TaskGraph aliases already exist.`),!0;let r=n.map(e=>e.line).join(`
+`),i=`
+# TaskGraph aliases added on ${new Date().toLocaleDateString()}
+${r}
+`;return S.appendFileSync(t,i),J(`debug`,`Added ${n.length} alias(es): ${n.map(e=>e.name).join(`, `)}`),!0}catch(e){return J(`debug`,`Failed to add aliases: ${e.message}`),!1}}function lt(e){let t=y.join(e,l);if(S.existsSync(t)){J(`debug`,`State file already exists, preserving current configuration`);return}let n={currentTag:`master`,lastSwitched:new Date().toISOString(),branchTagMapping:{},migrationNoticeShown:!1};try{S.writeFileSync(t,JSON.stringify(n,null,2)),J(`success`,`Created initial state file: ${t}`),J(`info`,`Default tag set to "master" for task organization`)}catch(e){J(`error`,`Failed to create state file: ${e.message}`)}}function Z(e,t,n={}){if(!I(e)){J(`error`,`Source file not found: ${e}`);return}let r=L(e,`utf8`);if(Object.entries(n).forEach(([e,t])=>{let n=RegExp(`\\{\\{${e}\\}\\}`,`g`);r=r.replace(n,t)}),S.existsSync(t)){let e=y.basename(t);if(e===`.gitignore`){J(`info`,`${t} already exists, merging content...`);let e=S.readFileSync(t,`utf8`),n=new Set(e.split(`
+`).map(e=>e.trim())),i=r.split(`
+`).filter(e=>!n.has(e.trim()));if(i.length>0){let n=`${e.trim()}\n\n# Added by TaskGraph\n${i.join(`
+`)}`;S.writeFileSync(t,n),J(`success`,`Updated ${t} with additional entries`)}else J(`info`,`No new content to add to ${t}`);return}if(e===`README-taskgraph.md`){J(`info`,`${t} already exists`);let e=y.join(y.dirname(t),`README-taskgraph.md`);S.writeFileSync(e,r),J(`success`,`Created ${e} (preserved original README-taskgraph.md)`);return}J(`debug`,`${t} already exists, skipping.`);return}S.writeFileSync(t,r),J(`info`,`Created file: ${t}`)}async function ut(e={}){f()||ct(),e.git===!0?e.initGit=!0:e.git===!1&&(e.initGit=!1),e.gitTasks===!0?e.storeTasksInGit=!0:e.gitTasks===!1&&(e.storeTasksInGit=!1);let t=e.yes||e.name&&e.description,n;if(n=e.rulesExplicitlyProvided?e.rules:[],t){f()||console.log(`SKIPPING PROMPTS - Using defaults or provided values`),e.name,e.description,e.version,e.author;let t=e.dryRun||!1,r=e.initGit===void 0?!0:e.initGit,i=e.storeTasksInGit===void 0?!0:e.storeTasksInGit;if(t)return J(`info`,`DRY RUN MODE: No files will be modified`),J(`info`,`Would initialize TaskGraph project`),J(`info`,`Would create/update necessary project files`),J(`info`,`${r?`Would initialize Git repository`:`Would skip Git initialization`}`),J(`info`,`${i?`Would store tasks in Git`:`Would exclude tasks from Git`}`),{dryRun:!0};await $(!0,r,i,t,{...e,preferredLanguage:`English`},n)}else{J(`debug`,`Required options not provided, proceeding with prompts.`);let t;try{J(`debug`,`Init started - taskgraph_id: ${dt()}`),t=T.createInterface({input:process.stdin,output:process.stdout});let r=!0,i=!0;r=e.initGit===void 0?(await Q(t,_.cyan(`Initialize a Git repository in project root? (Y/n): `),e=>{let t=e.trim().toLowerCase()!==`n`,n=t?_.green(`✓`):_.red(`✗`);return _.cyan(`Initialize a Git repository in project root?`)+` `+n+` `+_.dim(t?`Yes`:`No`)})).trim().toLowerCase()!==`n`:e.initGit,i=e.storeTasksInGit===void 0?(await Q(t,_.cyan(`Store tasks in Git (tasks.json and tasks/ directory)? (Y/n): `),e=>{let t=e.trim().toLowerCase()!==`n`,n=t?_.green(`✓`):_.red(`✗`);return _.cyan(`Store tasks in Git (tasks.json and tasks/ directory)?`)+` `+n+` `+_.dim(t?`Yes`:`No`)})).trim().toLowerCase()!==`n`:e.storeTasksInGit;let a=!1;e.rulesExplicitlyProvided?J(`info`,`Using rule profiles provided via command line: ${n.join(`, `)}`):a=(await Q(t,_.cyan(`Set up Claude Code integration (CLAUDE.md import)? (y/N): `),e=>{let t=e.trim().toLowerCase()===`y`,n=t?_.green(`✓`):_.red(`✗`);return _.cyan(`Set up Claude Code integration?`)+` `+n+` `+_.dim(t?`Yes`:`No`)})).trim().toLowerCase()===`y`;let o=(await Q(t,_.cyan(`Preferred response language (English): `))).trim()||`English`;console.log(`
+`+_.bold(`TaskGraph Project Settings:`)),console.log(_.dim(`─`.repeat(50)));let s=a?_.green(`✓`):_.dim(`✗`);console.log(`  `+_.dim(`Claude Code integration:`.padEnd(32)),s+` `+_.dim(a?`Yes`:`No`)),console.log(`  `+_.dim(`Response language:`.padEnd(32)),p.text(o));let c=r?_.green(`✓`):_.dim(`✗`);console.log(`  `+_.dim(`Initialize Git repository:`.padEnd(32)),c+` `+_.dim(r?`Yes`:`No`));let l=i?_.green(`✓`):_.dim(`✗`);if(console.log(`  `+_.dim(`Store tasks in Git:`.padEnd(32)),l+` `+_.dim(i?`Yes`:`No`)),console.log(_.dim(`─`.repeat(50))),(await Q(t,_.yellow(`
+Do you want to continue with these settings? (Y/n): `))).trim().toLowerCase()===`n`){t.close(),J(`info`,`Project initialization cancelled by user`),process.exit(0);return}let u=e.dryRun||!1;if(u)return J(`info`,`DRY RUN MODE: No files will be modified`),J(`info`,`Would initialize TaskGraph project`),J(`info`,`Would create/update necessary project files`),J(`info`,`${r?`Would initialize Git repository`:`Would skip Git initialization`}`),J(`info`,`${i?`Would store tasks in Git`:`Would exclude tasks from Git`}`),{dryRun:!0};await $(!0,r,i,u,{...e,shouldSetupRules:a,preferredLanguage:o},a?E:n),t.close()}catch(e){t&&t.close(),J(`error`,`Error during initialization process: ${e.message}`),process.exit(1)}}}function Q(e,t,n){return new Promise(r=>{e.question(t,e=>{T.moveCursor(process.stdout,0,-1),T.cursorTo(process.stdout,0),T.clearLine(process.stdout,0),n&&process.stdout.write(n(e)+`
+`),r(e)})})}function dt(){return ae()}function ft(e){try{if(!S.existsSync(e)){J(`warn`,`Config file does not exist, skipping storage configuration`);return}let t=S.readFileSync(e,`utf8`),n=JSON.parse(t);n.storage||={},n.storage.type=`file`,n.storage.operatingMode=`solo`,J(`debug`,`Configured storage for local file storage`),S.writeFileSync(e,JSON.stringify(n,null,2)),J(`debug`,`Storage configuration updated in config.json`)}catch(e){J(`error`,`Failed to update storage configuration: ${e.message}`)}}async function $(e,c,l,d,p,g=E){let v=process.cwd();J(`debug`,`Initializing project in ${v}`),Y(y.join(v,a)),Y(y.join(v,i)),Y(y.join(v,u)),Y(y.join(v,t)),Y(y.join(v,o)),lt(v);let b={year:new Date().getFullYear()};function S(e){let t=it(e);t?at(v,t,{mode:`solo`}):J(`warn`,`Unknown rule profile: ${e}`)}Z(`env.example`,y.join(v,n),b),Z(`config.json`,y.join(v,r),{...b});let C=y.join(v,r);st(C)?J(`debug`,`Updated config with correct maxTokens values`):J(`debug`,`Could not update maxTokens in config`),ft(C);try{let e=L(`gitignore`,`utf8`);he(y.join(v,s),e,l,J)}catch(e){J(`error`,`Failed to create .gitignore: ${e.message}`)}Z(`example_prd.txt`,y.join(v,ee)),Z(`example_prd_rpg.txt`,y.join(v,o,`example_prd_rpg.txt`));try{c===!1?J(`info`,`Git initialization skipped due to --no-git flag.`):c===!0?m()?J(`debug`,`Existing Git repository detected – skipping git init despite --git flag.`):(J(`info`,`Initializing Git repository due to --git flag...`),x(`git init`,{cwd:v,stdio:`ignore`}),J(`success`,`Git repository initialized`)):m()?J(`debug`,`Existing Git repository detected – skipping git init.`):(J(`info`,`No Git repository detected. Initializing one in project root...`),x(`git init`,{cwd:v,stdio:`ignore`}),J(`success`,`Git repository initialized`))}catch{J(`warn`,`Git not available, skipping repository initialization`)}if(g.length>0){J(`info`,`Setting up Claude Code integration...`);for(let e of g)S(e)}e&&X();let T={cwd:v,stdio:`inherit`};if(f()&&(T.stdio=`ignore`,J(`info`,`Running npm install silently...`)),p.preferredLanguage&&!d)try{let e=(await import(`./response-language-CGnha79j.js`)).default;e(p.preferredLanguage,{projectRoot:v,silent:!0}),J(`debug`,`Response language set to: ${p.preferredLanguage}`)}catch(e){J(`warn`,`Failed to set response language: ${e.message}`)}else f()&&!d?J(`debug`,`Skipping response language setup in silent (MCP) mode.`):d&&J(`debug`,`DRY RUN: Skipping response language setup.`);if(!f()&&!d&&!p?.yes){console.log(w(_.cyan(`Configuring AI Models...`),{padding:.5,margin:{top:1,bottom:.5},borderStyle:`round`,borderColor:`cyan`,width:60})),J(`info`,`Running interactive model setup. Please select your preferred AI models.`);try{x(`npx taskgraph models --setup`,{stdio:`inherit`,cwd:v}),J(`success`,`AI Models configured.`)}catch(e){J(`error`,`Failed to configure AI models:`,e.message),J(`warn`,`You may need to run "taskgraph models --setup" manually.`)}}else f()&&!d?(J(`info`,`Skipping interactive model setup in silent (MCP) mode.`),J(`warn`,`Please configure AI models using "taskgraph models --set-..." or the "models" MCP tool.`)):d?J(`info`,`DRY RUN: Skipping interactive model setup.`):p?.yes&&(J(`info`,`Skipping interactive model setup due to --yes flag.`),J(`info`,`Default AI models will be used. You can configure different models later using "taskgraph models --setup" or "taskgraph models --set-..." commands.`));if(e&&!d?(J(`debug`,`Adding shell aliases...`),X()&&J(`debug`,`Shell aliases added successfully`)):e&&d&&J(`debug`,`DRY RUN: Would add shell aliases (tm, taskgraph)`),f()||console.log(w(`${h.multiline(te.textSync(`Success!`,{font:`Standard`}))}\n${_.green(`Project initialized successfully!`)}`,{padding:1,margin:1,borderStyle:`double`,borderColor:`green`,width:60})),!f()){let e=ot();console.log(w(_.yellow.bold(`Workflow
+`)+`
+`+e,{padding:1,margin:{top:0,bottom:1,left:0,right:0},borderStyle:`round`,borderColor:`yellow`,width:60}))}}export{E as n,oe as r,ut as t};