taskgraph-ai 0.52.23 → 0.54.7

package/dist/init-p_pWjmVE.js

@@ -1,3139 +0,0 @@
-import{a as e}from"./ai-services-unified-kmQRPU0g.js";import{$ as t,Ct as n,Dt as r,Et as i,M as a,Ot as o,Q as s,St as c,Tt as l,_t as u,ht as d,vt as f,wt as ee,xt as p,yt as m}from"./config-manager-DhVH8AQp.js";import{r as h}from"./git-utils--i2q96hv.js";import{D as te,V as g}from"./src-yE1DeXKG.js";import _ from"chalk";import*as v from"node:path";import y from"path";import{execSync as b}from"child_process";import*as x from"node:fs";import S from"fs";import{fileURLToPath as C}from"url";import w from"readline";import ne from"os";import{randomUUID as re}from"crypto";const T=[`claude`];function ie(e){return e.filter(e=>!ae(e))}function ae(e){return T.includes(e)}const E=`tasks.json`,D=`tasks/`;function O(e){return e.trim().replace(/^#/,``).trim()}function k(e){let t=O(e);return t===`tasks.json`||t===`tasks/`}function oe(e,t){return e.map(e=>{if(k(e)){let n=O(e),r=e.match(/\s*$/)[0];return t?`# ${n}${r}`:`${n}${r}`}return e})}function se(e){let t=[],n=!1;for(let r of e)r.trim()===`# Task files`?n=!0:k(r)||(!n||r.trim())&&(n&&r.trim()&&!k(r)&&(n=!1),n||t.push(r));return t}function ce(e,t){return e.filter(e=>{let n=e.trim();return!n||k(e)||n===`# Task files`?!1:!t.has(n)})}function A(e){let t=[`# Task files`];return e?t.push(`# ${E}`,`# ${D} `):t.push(E,`${D} `),t}function le(e,t){if(e.some(k))return e;let n=[...e];for(;n.length>0&&!n[n.length-1].trim();)n.pop();return j(n),n.push(...A(t)),n}function j(e){if(e.some(e=>e.trim())){let t=e[e.length-1];t&&t.trim()&&e.push(``)}}function ue(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 de(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 fe(e,t,n,r){try{let i=se(S.readFileSync(e,`utf8`).split(`
-`)),a=ce(t,new Set(i.map(e=>e.trim()).filter(e=>e))),o=[...i];a.length>0&&(j(o),o.push(...a)),j(o),o.push(...A(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 pe(e){try{if(!S.existsSync(e))return;let t=S.readFileSync(e,`utf8`).split(`
-`).find(e=>O(e)===E);return t===void 0?void 0:t.trim().startsWith(`#`)}catch{return}}function me(e,t,n=!0,r=null){ue(e,t,n);let i=oe(t.split(`
-`),n);S.existsSync(e)?fe(e,i,n,r):de(e,le(i,n),r)}const he=C(import.meta.url),M=y.dirname(he);function N(){let e=[y.join(M,`assets`),y.join(M,`..`,`assets`),y.join(M,`..`,`..`,`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 P(e){let t=N();return y.join(t,e)}function ge(e){try{let t=P(e);return S.existsSync(t)}catch{return!1}}function F(e,t=`utf8`){let n=P(e);return S.readFileSync(n,t)}const I=`taskgraph-ai`;function _e(e){return Array.isArray(e?.args)&&e.args.some(e=>typeof e==`string`&&e.includes(`taskgraph-ai`))}function L(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,n){if(!n){t(`debug`,`[MCP Config] No mcpConfigPath provided, skipping MCP configuration setup`);return}let r=y.join(e,n),i=y.dirname(r);t(`debug`,`Setting up MCP configuration at ${r}...`);let a={[I]:{command:`npx`,args:[`-y`,I],env:{TASKGRAPH_TOOLS:`core`}}};if(S.existsSync(i)||S.mkdirSync(i,{recursive:!0}),S.existsSync(r)){t(`debug`,`MCP configuration file already exists, checking for existing taskgraph-ai...`);try{let e=JSON.parse(S.readFileSync(r,`utf8`));if(e.mcpServers||={},Object.values(e.mcpServers).some(_e)){t(`debug`,`Found existing taskgraph-ai MCP configuration in mcp.json, leaving untouched`);return}e.mcpServers[`taskgraph-ai`]?t(`debug`,`taskgraph-ai server already configured in mcp.json`):(e.mcpServers[I]=a[I],t(`debug`,`Added taskgraph-ai server to existing MCP configuration`)),S.writeFileSync(r,L(e)+`
-`),t(`debug`,`Updated MCP configuration file`)}catch(e){t(`error`,`Failed to update MCP configuration: ${e.message}`);let n=`${r}.backup-${Date.now()}`;S.existsSync(r)&&(S.copyFileSync(r,n),t(`warn`,`Saved the old file as ${n}`));let i={mcpServers:a};S.writeFileSync(r,L(i)+`
-`),t(`warn`,`Created new MCP configuration file (backup of original file was created if it existed)`)}}else{let e={mcpServers:a};S.writeFileSync(r,L(e)+`
-`),t(`debug`,`Created MCP configuration file at ${r}`)}t(`debug`,`MCP server will use the installed taskgraph-ai package`)}function R(e){let{name:t,description:n,content:r,argumentHint:i}=e;return{type:`static`,metadata:{name:t,description:n,...i&&{argumentHint:i}},content:r}}function z(e,t,n,r){if(!r.includes(`$ARGUMENTS`))throw Error(`Dynamic slash command "${e}" must contain $ARGUMENTS placeholder`);return{type:`dynamic`,metadata:{name:e,description:t,argumentHint:n},content:r}}const ye=z(`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`),be=z(`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`),xe=z(`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
-\`\`\``),Se=z(`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
-\`\`\``),Ce=z(`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`),we=R({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`}),Te=z(`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.`),Ee=z(`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`),De=z(`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`),Oe=z(`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`),ke=z(`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
-\`\`\``),Ae=R({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
-\`\`\``}),je=z(`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`),Me=z(`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
-\`\`\``),Ne=z(`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
-\`\`\``),Pe=R({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`}),Fe=R({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`}),Ie=R({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`}),Le=R({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`}),Re=R({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!`}),ze=R({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.`}),Be=z(`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`),Ve=z(`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`),He=z(`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`),Ue=z(`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
-\`\`\``),We=z(`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!`);R({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`});const Ge=[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,z(`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`),z(`graph`,`Dependency Graph`,`[task-id]`,`Show the project's tasks as a dependency tree.
-
-Arguments: $ARGUMENTS
-
-1. If the arguments contain a task ID, run \`taskgraph graph --id=<id>\` to show that task and everything that depends on it. Otherwise run \`taskgraph graph\`.
-2. Show the output unchanged in a code block.
-3. Then, in one or two sentences, point out what stands out: the task marked "← next", anything in progress, and any task listed as missing a dependency or stuck in a dependency loop, with the fix command the output suggests.`),z(`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`),R({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.`}),z(`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`),z(`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`),z(`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.`),z(`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:graph` - Show tasks as a dependency tree\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."),z(`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`),z(`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`),z(`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`),z(`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.`),z(`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`),z(`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`),R({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- `graph` - Dependency tree with the next task marked\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."}),z(`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`),z(`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>`),z(`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\``),z(`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.`),z(`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.`),z(`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`)];var Ke=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){let n=this.getCommandsPath(e),r=[];if(!this.supportsCommands)return{success:!1,count:0,directory:n,files:[],error:`Profile "${this.name}" does not support slash commands`};try{x.existsSync(n)||x.mkdirSync(n,{recursive:!0});let e=this.formatAll(t);for(let t of e){let e=v.join(n,t.filename);x.writeFileSync(e,t.content),r.push(t.filename)}return{success:!0,count:r.length,directory:n,files:r}}catch(e){return{success:!1,count:0,directory:n,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(!x.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=x.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);x.rmSync(e,{force:!0}),i.push(t)}}return n&&x.readdirSync(r).length===0&&x.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)}}}};const B={claude:new class extends Ke{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 B[e.toLowerCase()]}function Je(){let e=ne.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 V(e){return e.endsWith(`.ps1`)}function H(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(V(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=V(r)?RegExp(`^\\s*\\$env:${e}\\s*=`,`m`).test(a):H(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;V(r)?(s=`$env:${e} = "${t.replace(/["`$]/g,"`$&")}"`,c=`#`):H(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:n,displayName:r=n,profileDir:i=`.${n.toLowerCase()}`,rulesDir:a=`${i}/rules`,mcpConfig:o=!0,mcpConfigName:s=o?`mcp.json`:null,fileMap:c={},onAdd:l,onPostConvert:u}=e,d=s?y.join(i,s):null,f=null;try{let e=qe(n);e?.supportsCommands&&(f={profile:e,commands:Ge})}catch(e){t(`debug`,`[${r}] Slash command profile lookup failed: ${e.message}`)}return{profileName:n,displayName:r,profileDir:i,rulesDir:a,mcpConfig:o,mcpConfigName:s,mcpConfigPath:d,fileMap:c,slashCommands:f,...l&&{onAddRulesProfile:l},...u&&{onPostConvertRulesProfile:u}}}function Qe(e,n){let r=y.join(n,`AGENTS.md`),i=y.join(e,`CLAUDE.md`),a=y.join(e,`.taskgraph`,`CLAUDE.md`),o=`@./.taskgraph/CLAUDE.md`,s=`\n## TaskGraph Instructions\n**Import TaskGraph's development workflow commands and guidelines, treat as if import is in the main CLAUDE.md file.**\n${o}`;if(S.existsSync(r))try{let n=y.join(e,`.taskgraph`);if(S.existsSync(n)||S.mkdirSync(n,{recursive:!0}),S.copyFileSync(r,a),t(`debug`,`[Claude] Created TaskGraph instructions at ${a}`),S.existsSync(i)){let e=S.readFileSync(i,`utf8`);if(e.includes(o))t(`debug`,`[Claude] TaskGraph import already present in ${i}`);else{let n=e.trim()+`
-`+s+`
-`;S.writeFileSync(i,n),t(`debug`,`[Claude] Added TaskGraph import to existing ${i}`)}}else{let e=`# Claude Code Instructions\n${s}\n`;S.writeFileSync(i,e),t(`debug`,`[Claude] Created ${i} with TaskGraph import`)}}catch(e){t(`error`,`[Claude] Failed to set up Claude instructions: ${e.message}`)}let c=Xe();c.success?c.alreadyExists?t(`debug`,`[Claude] Deferred MCP loading already configured`):t(`debug`,`[Claude] Enabled deferred MCP loading in ${c.shellConfigFile}`):t(`debug`,`[Claude] Could not configure deferred loading: ${c.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,n){let r=y.join(e,`.mcp.json`);if(S.existsSync(r))try{let e=$e(JSON.parse(S.readFileSync(r,`utf8`)));S.writeFileSync(r,JSON.stringify(e,null,`	`)+`
-`),t(`debug`,`[Claude] Transformed MCP configuration to Claude format at ${r}`)}catch(e){t(`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=/* @__PURE__ */ e({claudeProfile:()=>tt});function rt(e){return T.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: ${T.join(`, `)}`);return t}function at(e,n){let r=y.join(e,n.rulesDir),i=0;if(typeof n.onAddRulesProfile==`function`)try{n.onAddRulesProfile(r,N()),t(`debug`,`[Rule Transformer] Called onAddRulesProfile for ${n.profileName}`)}catch(e){t(`error`,`[Rule Transformer] onAddRulesProfile failed for ${n.profileName}: ${e.message}`),i++}if(n.mcpConfig!==!1)try{ve(e,n.mcpConfigPath),t(`debug`,`[Rule Transformer] Setup MCP configuration for ${n.profileName}`)}catch(e){t(`error`,`[Rule Transformer] MCP setup failed for ${n.profileName}: ${e.message}`)}if(typeof n.onPostConvertRulesProfile==`function`)try{n.onPostConvertRulesProfile(r,N()),t(`debug`,`[Rule Transformer] Called onPostConvertRulesProfile for ${n.profileName}`)}catch(e){t(`error`,`[Rule Transformer] onPostConvertRulesProfile failed for ${n.profileName}: ${e.message}`)}if(n.slashCommands)try{let r=n.slashCommands.profile.addSlashCommands(e,n.slashCommands.commands);r.success?t(`debug`,`[Rule Transformer] Created ${r.count} slash commands in ${r.directory}`):t(`error`,`[Rule Transformer] Failed to add slash commands for ${n.profileName}: ${r.error}`)}catch(e){t(`error`,`[Rule Transformer] Slash commands failed for ${n.profileName}: ${e.message}`)}return{success:1,failed:i}}function ot(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(a[n]){let i=a[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 U=`alias tm='taskgraph'`,W=`ENABLE_EXPERIMENTAL_MCP_CLI`,G={debug:0,info:1,warn:2,error:3,success:4},st=process.env.TASKGRAPH_LOG_LEVEL?G[process.env.TASKGRAPH_LOG_LEVEL.toLowerCase()]:G.info;function ct(){s()||g()}function K(e,...t){let n={debug:d.muted(`•`),info:d.brand(`→`),warn:_.yellow(`!`),error:_.red(`✗`),success:_.green(`✓`)};if(G[e]>=st){let r=n[e]||``;s()||(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,d.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 lt(e,...t){K(e===`warn`||e===`error`?e:`debug`,...t)}function q(e){S.existsSync(e)||(S.mkdirSync(e,{recursive:!0}),K(`debug`,`Created directory: ${e}`))}function J(){let e=process.env.HOME||process.env.USERPROFILE;return e?[`.zshrc`,`.bashrc`,`.bash_profile`,`.profile`].map(t=>y.join(e,t)):[]}function ut(e){return[y.join(e,c),y.join(e,p),y.join(e,r),y.join(e,`.git`),y.join(e,m),y.join(e,u),y.join(e,`CLAUDE.md`),y.join(e,`.mcp.json`),...J()]}function Y(e){let t=/* @__PURE__ */ new Map;for(let n of e){let e=null;try{S.existsSync(n)&&(e=S.statSync(n).isDirectory()?``:S.readFileSync(n,`utf8`))}catch{e=null}t.set(n,e)}return t}function dt(e,t,n){let r=t=>y.join(e,t),i=e=>t.get(e)==null&&n.get(e)!=null,a=e=>t.get(e)!=null&&n.get(e)!=null&&t.get(e)!==n.get(e),o=t.get(r(`.taskgraph/config.json`))!=null||t.get(r(`.taskgraph/tasks/tasks.json`))!=null,s=[];!o&&n.get(r(`.taskgraph/config.json`))!=null?s.push({path:`${c}/`,note:`tasks, settings and PRD templates`}):o&&i(r(`.taskgraph/config.json`))&&s.push({path:p,note:`restored`}),i(r(`.git`))&&s.push({path:`.git/`,note:`new Git repository`});let l=[[m,`created`,`added TaskGraph entries`],[u,`optional settings`,`updated`],[`CLAUDE.md`,`loads TaskGraph's instructions in Claude Code`,`now imports TaskGraph's instructions`],[`.mcp.json`,`TaskGraph MCP server for Claude Code`,`added the TaskGraph MCP server`]];for(let[e,t,n]of l){let o=r(e);i(o)?s.push({path:e,note:t}):a(o)&&s.push({path:e,note:n})}let d=process.env.HOME||process.env.USERPROFILE;for(let e of J()){let r=t.get(e)||``,i=n.get(e)||``;if(i===r)continue;let a=[];i.includes(U)&&!r.includes(U)&&a.push("the `tm` alias"),i.includes(W)&&!r.includes(W)&&a.push(`deferred MCP loading`),a.length!==0&&s.push({path:d?e.replace(d,`~`):e,note:`added ${a.join(` and `)}; open a new terminal`})}return{alreadySetUp:o,changes:s}}function ft(){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 K(`debug`,`Could not determine shell type. Aliases not added.`),!1;try{if(!S.existsSync(t))return K(`debug`,`Shell config file ${t} not found.`),!1;let e=S.readFileSync(t,`utf8`),n=[{name:`tm`,line:U}].filter(t=>!e.includes(t.line));if(n.length===0)return K(`debug`,`All TaskGraph aliases already exist.`),!0;let r=n.map(e=>e.line).join(`
-`),i=`
-# TaskGraph aliases added on ${(/* @__PURE__ */ new Date()).toLocaleDateString()}
-${r}
-`;return S.appendFileSync(t,i),K(`debug`,`Added ${n.length} alias(es): ${n.map(e=>e.name).join(`, `)}`),!0}catch(e){return K(`debug`,`Failed to add aliases: ${e.message}`),!1}}function pt(e){let t=y.join(e,l);if(S.existsSync(t)){K(`debug`,`State file already exists, preserving current configuration`);return}let n={currentTag:`master`,lastSwitched:(/* @__PURE__ */ new Date()).toISOString(),branchTagMapping:{},migrationNoticeShown:!0};try{S.writeFileSync(t,JSON.stringify(n,null,2)),K(`debug`,`Created initial state file: ${t}`)}catch(e){K(`error`,`Failed to create state file: ${e.message}`)}}function mt(e){let t=y.join(e,r);if(S.existsSync(t))return;let n={master:{tasks:[],metadata:{created:(/* @__PURE__ */ new Date()).toISOString(),description:`Tasks for master context`}}};try{S.writeFileSync(t,`${JSON.stringify(n,null,2)}\n`),K(`debug`,`Created empty tasks file: ${t}`)}catch(e){K(`error`,`Failed to create tasks file: ${e.message}`)}}function X(e,t,n={}){if(!ge(e)){K(`error`,`Source file not found: ${e}`);return}let r=F(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`){K(`debug`,`${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),K(`debug`,`Updated ${t} with additional entries`)}else K(`debug`,`No new content to add to ${t}`);return}if(e===`README-taskgraph.md`){K(`debug`,`${t} already exists`);let e=y.join(y.dirname(t),`README-taskgraph.md`);S.writeFileSync(e,r),K(`debug`,`Created ${e} (preserved original README-taskgraph.md)`);return}K(`debug`,`${t} already exists, skipping.`)}else S.writeFileSync(t,r),K(`debug`,`Created file: ${t}`)}async function ht(e={}){s()||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){e.name,e.description,e.version,e.author;let t=e.dryRun||!1,r=e.initGit===void 0||e.initGit,i=e.storeTasksInGit??pe(y.join(process.cwd(),`.gitignore`))??!0;if(t)return $(r,i),{dryRun:!0};await Q(e.aliases!==!1,r,i,t,{...e,preferredLanguage:`English`},n)}else{K(`debug`,`Required options not provided, proceeding with prompts.`);let t;try{K(`debug`,`Init started - taskgraph_id: ${gt()}`),t=w.createInterface({input:process.stdin,output:process.stdout});let r=!0,i=!0;r=e.initGit===void 0?h()?!0:(await Z(t,_.cyan(`Initialize a Git repository in project root? (Y/n): `),e=>{let t=e.trim().toLowerCase()!==`n`,n=t?_.green(`✓`):_.dim(`–`);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 Z(t,_.cyan(`Store tasks in Git (tasks.json and tasks/ directory)? (Y/n): `),e=>{let t=e.trim().toLowerCase()!==`n`,n=t?_.green(`✓`):_.dim(`–`);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?K(`debug`,`Using rule profiles provided via command line: ${n.join(`, `)}`):a=(await Z(t,_.cyan(`Set up Claude Code integration (CLAUDE.md import)? (y/N): `),e=>{let t=e.trim().toLowerCase()===`y`,n=t?_.green(`✓`):_.dim(`–`);return _.cyan(`Set up Claude Code integration?`)+` `+n+` `+_.dim(t?`Yes`:`No`)})).trim().toLowerCase()===`y`;let o=(await Z(t,_.cyan(`Language for AI responses (English): `),e=>`${_.cyan(`Language for AI responses?`)} ${_.dim(e.trim()||`English`)}`)).trim()||`English`,s=e.dryRun||!1;if(s)return t.close(),$(r,i),{dryRun:!0};await Q(e.aliases!==!1,r,i,s,{...e,shouldSetupRules:a,preferredLanguage:o},a?T:n),t.close()}catch(e){t&&t.close(),K(`error`,`Error during initialization process: ${e.message}`),process.exit(1)}}}function Z(e,t,n){return new Promise(r=>{e.question(t,e=>{w.moveCursor(process.stdout,0,-1),w.cursorTo(process.stdout,0),w.clearLine(process.stdout,0),n&&process.stdout.write(n(e)+`
-`),r(e)})})}function gt(){return re()}function _t(e){try{if(!S.existsSync(e)){K(`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`,K(`debug`,`Configured storage for local file storage`),S.writeFileSync(e,JSON.stringify(n,null,2)),K(`debug`,`Storage configuration updated in config.json`)}catch(e){K(`error`,`Failed to update storage configuration: ${e.message}`)}}async function Q(e,t,r,a,l,d=T){let g=process.cwd();K(`debug`,`Initializing project in ${g}`);let _=s()?[]:ut(g),v=Y(_);q(y.join(g,c)),q(y.join(g,i)),q(y.join(g,n)),q(y.join(g,ee)),q(y.join(g,o)),pt(g),mt(g);let x={year:(/* @__PURE__ */ new Date()).getFullYear()};function S(e){let t=it(e);t?at(g,t):K(`warn`,`Unknown rule profile: ${e}`)}X(`env.example`,y.join(g,u),x),X(`config.json`,y.join(g,p),{...x});let C=y.join(g,p);ot(C)?K(`debug`,`Updated config with correct maxTokens values`):K(`debug`,`Could not update maxTokens in config`),_t(C);try{let e=F(`gitignore`,`utf8`);me(y.join(g,m),e,r,lt)}catch(e){K(`error`,`Failed to create .gitignore: ${e.message}`)}X(`example_prd.txt`,y.join(g,f)),X(`example_prd_rpg.txt`,y.join(g,o,`example_prd_rpg.txt`));try{t===!1?K(`debug`,`Git initialization skipped due to --no-git flag.`):h()?K(`debug`,`Existing Git repository detected; skipping git init.`):(b(`git init`,{cwd:g,stdio:`ignore`}),K(`debug`,`Git repository initialized`))}catch{K(`warn`,`Git not available, skipping repository initialization`)}if(d.length>0){K(`debug`,`Setting up Claude Code integration...`);for(let e of d)S(e)}if(l.preferredLanguage&&!a)try{let e=(await import(`./response-language-D9UxmXBp.js`)).default;e(l.preferredLanguage,{projectRoot:g,silent:!0}),K(`debug`,`Response language set to: ${l.preferredLanguage}`)}catch(e){K(`warn`,`Failed to set response language: ${e.message}`)}if(!s()&&!a&&!l?.yes){console.log(``);try{b(`"${process.execPath}" "${process.argv[1]}" models --setup --no-banner`,{stdio:`inherit`,cwd:g}),console.log(``)}catch{K(`warn`,"Model setup did not finish; run `taskgraph models --setup` to retry")}}else s()&&!a&&K(`debug`,`Skipping interactive model setup in silent (MCP) mode.`);if(e&&!a&&ft(),!s()){let{alreadySetUp:e,changes:t}=dt(g,v,Y(_));console.log(`${te({folder:y.basename(g),changes:t,alreadySetUp:e,claudeCode:d.includes(`claude`),defaultModels:!!l?.yes})}\n`)}}function $(e,t){if(s())return;let n=[`Dry run; nothing was changed. Init would:`,`  create ${c}/ with tasks, settings and PRD templates`,`  create or update ${m} and ${u}`];e!==!1&&!h()&&n.push(`  start a Git repository`),n.push(t?`  keep tasks in Git`:`  keep tasks out of Git`),console.log(n.join(`
-`))}export{T as n,ie as r,ht as t};