feat: add UUID task ID support for external tool integration

Add --id-format option to scud parse command to generate UUID task IDs
instead of sequential numbers. This enables integration with external
tools like Descartes that expect UUID format.

Key changes:
- Add uuid crate dependency
- Add IdFormat enum (Sequential/Uuid) to Phase struct
- Generate 32-char hex UUIDs when --id-format uuid is specified
- Expand command generates UUID subtasks for UUID phases
- Update natural_sort_ids() to handle UUIDs (lexicographic fallback)
- Truncate long IDs in list output for readability (8 chars + "...")
- Persist id_format in SCG @meta section
- Add comprehensive tests for UUID functionality

The sequential ID format remains the default for backwards compatibility.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: pyrex41

scud-cli/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "scud-cli"
-version = "1.29.1"
+version = "1.30.0"
 edition = "2021"
 authors = ["SCUD Team"]
 description = "Fast, simple task master for AI-driven development"
@@ -32,6 +32,7 @@ dialoguer = "0.11"  # Interactive CLI prompts
 atty = "0.2"  # TTY detection for interactive mode
 futures = "0.3"  # Async utilities for parallel execution
 webbrowser = "1.0"  # Cross-platform browser opening
+uuid = { version = "1", features = ["v4"] }  # UUID generation for task IDs
 
 [dev-dependencies]
 tempfile = "3.8"  # Temporary directories for tests

scud-cli/Cargo.toml

@@ -17,21 +17,20 @@ This is a high-performance Rust rewrite of the SCUD task management system. It r
 scud (Rust Binary)
 ├── Core Commands (No AI - Instant)
 │   ├── init               # Initialize .scud/ and install agents
-│   ├── tags               # List tags
-│   ├── use-tag            # Switch active tag
+│   ├── tags               # List tags or set active tag
 │   ├── list               # List tasks with filters
 │   ├── view               # Open interactive HTML viewer in browser
 │   ├── show               # Show task details
 │   ├── set-status         # Update task status
-│   ├── next               # Find next available task (--claim for dynamic-wave)
+│   ├── next               # Find next available task
 │   ├── stats              # Show statistics
 │   └── doctor             # [EXPERIMENTAL] Diagnose stuck states
 │
-├── AI Commands (Direct Anthropic API)
+├── AI Commands (Direct LLM API)
 │   ├── parse-prd          # Parse PRD markdown into tasks
 │   ├── analyze-complexity # Analyze task complexity
 │   ├── expand             # Break down complex tasks
-│   └── research           # AI-powered research
+│   └── reanalyze-deps     # Analyze cross-tag dependencies
 │
 └── Storage (SCG)
     └── .scud/tasks/tasks.scg
@@ -96,7 +95,7 @@ scud init
 scud tags
 
 # Switch to a tag
-scud use-tag auth
+scud tags auth
 
 # List tasks
 scud list
@@ -118,20 +117,6 @@ scud stats
 scud view
 ```
 
-### [EXPERIMENTAL] Dynamic-Wave Mode
-
-Dynamic-wave mode allows agents to auto-claim tasks and maintain workflow health:
-
-```bash
-# Find and auto-claim the next available task
-scud next --claim --name agent-1
-
-# Release all tasks claimed by an agent
-scud next --release --name agent-1
-```
-
-**IMPORTANT:** When using `--claim`, agents MUST run `scud set-status <id> done` when finishing a task. This ensures dependent tasks become unblocked.
-
 ### [EXPERIMENTAL] Doctor Command
 
 Diagnose stuck workflow states:
@@ -170,10 +155,28 @@ scud analyze-complexity --task 5       # Specific task
 scud expand 7                          # Specific task
 scud expand --all                      # All tasks >13 complexity
 
-# Research a topic
-scud research "OAuth 2.0 best practices"
+# Reanalyze cross-tag dependencies
+scud reanalyze-deps --all-tags
 ```
 
+### UUID Task IDs
+
+For integration with external tools that expect UUID task IDs (like Descartes):
+
+```bash
+# Generate tasks with UUID IDs instead of sequential numbers
+scud parse requirements.md --tag myproject --id-format uuid
+```
+
+This generates tasks with 32-character UUID identifiers (e.g., `a1b2c3d4e5f6789012345678901234ab`) instead of sequential numbers (`1`, `2`, `3`).
+
+**Key behaviors:**
+- Sequential IDs remain the default for backwards compatibility
+- The ID format is stored in the phase metadata and inherited during expansion
+- Subtasks also get UUID IDs when the parent phase uses UUID format
+- Long UUIDs are truncated in CLI output (`a1b2c3d4...`) for readability
+- The `scud show` command displays the full UUID
+
 ## Performance Comparison
 
 | Operation | Old (task-master) | New (Rust) | Improvement |
@@ -249,6 +252,7 @@ struct Task {
 struct Phase {
     name: String,
     tasks: Vec<Task>,
+    id_format: IdFormat,  // sequential (default) or uuid
 }
 ```
 
@@ -274,7 +278,7 @@ Located in `src/llm/prompts.rs`:
 - `parse_prd()` - Converts markdown to structured tasks
 - `analyze_complexity()` - Scores task difficulty
 - `expand_task()` - Breaks down complex tasks
-- `research_topic()` - AI research assistant
+- `reanalyze_dependencies()` - Cross-tag dependency analysis
 
 ## Integration with SCUD
 
@@ -303,7 +307,7 @@ scud-cli/
 │   │       ├── parse_prd.rs
 │   │       ├── analyze_complexity.rs
 │   │       ├── expand.rs
-│   │       └── research.rs
+│   │       └── reanalyze_deps.rs
 │   ├── models/
 │   │   ├── task.rs
 │   │   └── phase.rs

scud-cli/README.md

@@ -1,6 +1,6 @@
 {
   "name": "scud-task",
-  "version": "1.28.1",
+  "version": "1.30.0",
   "description": "Fast, simple task master for AI-driven development - BMAD-TM workflow automation",
   "main": "index.js",
   "bin": {

scud-cli/package.json

@@ -7,9 +7,10 @@ use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use serde::Deserialize;
 use std::path::PathBuf;
 use std::sync::Arc;
+use uuid::Uuid;
 
 use crate::llm::{LLMClient, Prompts};
-use crate::models::{Priority, Task, TaskStatus};
+use crate::models::{IdFormat, Priority, Task, TaskStatus};
 use crate::storage::Storage;
 
 #[derive(Debug, Deserialize)]
@@ -289,10 +290,29 @@ pub async fn run(
                     .get_mut(tag)
                     .expect("Tag should exist since task came from it");
 
+                // Check if this phase uses UUID format
+                let use_uuid = epic.id_format == IdFormat::Uuid;
+
                 // Create subtasks
+                // For UUID format, pre-generate all IDs so we can map dependencies
+                let subtask_ids: Vec<String> = if use_uuid {
+                    expansion
+                        .expanded_tasks
+                        .iter()
+                        .map(|_| Uuid::new_v4().to_string().replace("-", ""))
+                        .collect()
+                } else {
+                    expansion
+                        .expanded_tasks
+                        .iter()
+                        .enumerate()
+                        .map(|(idx, _)| format!("{}.{}", parent_id, idx + 1))
+                        .collect()
+                };
+
                 let mut new_subtask_ids = Vec::new();
                 for (idx, expanded) in expansion.expanded_tasks.iter().enumerate() {
-                    let new_id = format!("{}.{}", parent_id, idx + 1);
+                    let new_id = subtask_ids[idx].clone();
 
                     let priority = if !expanded.priority.is_empty() {
                         match expanded.priority.to_lowercase().as_str() {
@@ -313,18 +333,21 @@ pub async fn run(
                     new_task.complexity = 0;
                     new_task.parent_id = Some(parent_id.clone());
 
-                    // Map dependency references to nested IDs
+                    // Map dependency references to actual subtask IDs
+                    // LLM returns dependencies as 1-indexed references to other subtasks
                     new_task.dependencies = expanded
                         .dependencies
                         .iter()
                         .filter_map(|dep| {
                             if let Ok(dep_idx) = dep.parse::<usize>() {
+                                // Map 1-indexed reference to actual subtask ID
                                 if dep_idx > 0 && dep_idx <= idx + 1 {
-                                    Some(format!("{}.{}", parent_id, dep_idx))
+                                    Some(subtask_ids[dep_idx - 1].clone())
                                 } else {
                                     None
                                 }
                             } else {
+                                // Already a full ID reference
                                 Some(dep.clone())
                             }
                         })

scud-cli/src/commands/ai/expand.rs

@@ -3,9 +3,10 @@ use colored::Colorize;
 use indicatif::{ProgressBar, ProgressStyle};
 use serde::Deserialize;
 use std::path::{Path, PathBuf};
+use uuid::Uuid;
 
 use crate::llm::{LLMClient, Prompts};
-use crate::models::{Phase, Priority, Task};
+use crate::models::{IdFormat, Phase, Priority, Task};
 use crate::storage::Storage;
 
 #[derive(Debug, Deserialize)]
@@ -25,6 +26,7 @@ pub async fn run(
     num_tasks: u32,
     append: bool,
     no_guidance: bool,
+    id_format: &str,
 ) -> Result<()> {
     let storage = Storage::new(project_root.clone());
 
@@ -85,7 +87,15 @@ pub async fn run(
     // Check if other phases exist for cross-tag dependency hint
     let other_phases: Vec<_> = all_tasks.keys().filter(|k| *k != tag).cloned().collect();
 
-    // Determine starting ID based on append mode
+    // Parse ID format from CLI argument
+    let use_uuid = id_format == "uuid";
+    let parsed_id_format = if use_uuid {
+        IdFormat::Uuid
+    } else {
+        IdFormat::Sequential
+    };
+
+    // Determine starting ID based on append mode (only used for sequential format)
     let start_id = if append && all_tasks.contains_key(tag) {
         let existing = all_tasks.get(tag).unwrap();
         existing.tasks.len() + 1
@@ -99,19 +109,41 @@ pub async fn run(
             "{}",
             format!("📎 Appending to existing task group '{}'...", tag).cyan()
         );
-        all_tasks.get(tag).unwrap().clone()
+        let existing = all_tasks.get(tag).unwrap().clone();
+        // When appending, warn if id_format doesn't match existing
+        if existing.id_format != parsed_id_format {
+            println!(
+                "{}",
+                format!(
+                    "⚠ Ignoring --id-format: existing phase uses {} format",
+                    existing.id_format.as_str()
+                )
+                .yellow()
+            );
+        }
+        existing
     } else {
         if all_tasks.contains_key(tag) {
             println!(
                 "{}",
                 format!("⚠ Task group '{}' already exists. Replacing...", tag).yellow()
             );
         }
-        Phase::new(tag.to_string())
+        let mut new_phase = Phase::new(tag.to_string());
+        new_phase.id_format = parsed_id_format;
+        new_phase
     };
 
+    // Determine actual id_format to use (from phase, which may be inherited when appending)
+    let use_uuid = group.id_format == IdFormat::Uuid;
+
     for (idx, parsed) in parsed_tasks.iter().enumerate() {
-        let task_id = (start_id + idx).to_string();
+        let task_id = if use_uuid {
+            // Generate UUID v4 as 32-character hex string (no dashes)
+            Uuid::new_v4().to_string().replace("-", "")
+        } else {
+            (start_id + idx).to_string()
+        };
 
         let priority = match parsed.priority.to_lowercase().as_str() {
             "high" => Priority::High,