jettypod 4.4.118 → 4.4.121

package/crates/jettypod-cli/src/commands.rs

@@ -0,0 +1,1249 @@
+//! Command handler implementations.
+//!
+//! Each function corresponds to a CLI command. They receive a shared
+//! [`CommandContext`] (project root + open database handle), call into
+//! `jettypod_core`, and format output for the terminal.
+
+use std::path::{Path, PathBuf};
+
+use anyhow::{bail, Context, Result};
+use jettypod_core::db::Database;
+use jettypod_core::work::{self, CreateOptions, ItemType, Mode, Status};
+use jettypod_core::{config, git, sessions, skills, worktree};
+
+use crate::{PrototypeAction, TestAction};
+
+// ---------------------------------------------------------------------------
+// Shared context
+// ---------------------------------------------------------------------------
+
+/// Shared context for CLI commands — holds the project root and an open database handle.
+pub struct CommandContext {
+    pub root: PathBuf,
+    pub db: Database,
+}
+
+impl CommandContext {
+    pub fn new(root: &Path) -> Result<Self> {
+        let db = Database::open(root).context("Failed to open project database")?;
+        Ok(Self {
+            root: root.to_path_buf(),
+            db,
+        })
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+fn type_icon(t: &ItemType) -> &'static str {
+    match t {
+        ItemType::Epic => "📦",
+        ItemType::Feature => "✨",
+        ItemType::Chore => "🔧",
+        ItemType::Bug => "🐛",
+    }
+}
+
+fn status_icon(s: &Status) -> &'static str {
+    match s {
+        Status::Backlog => "📋",
+        Status::Todo => "📝",
+        Status::InProgress => "🔄",
+        Status::Blocked => "🚫",
+        Status::Done => "✅",
+        Status::Cancelled => "❌",
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Init
+// ---------------------------------------------------------------------------
+
+pub fn init(name: Option<String>) -> Result<()> {
+    let cwd = std::env::current_dir()?;
+
+    let project_name = name.unwrap_or_else(|| {
+        cwd.file_name()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .to_string()
+    });
+
+    let jettypod_dir = cwd.join(".jettypod");
+    if jettypod_dir.exists() {
+        println!("Project already initialized: {project_name}");
+        // Still sync skills and regenerate CLAUDE.md.
+    } else {
+        std::fs::create_dir_all(&jettypod_dir)?;
+        println!("Created .jettypod/");
+    }
+
+    // Ensure database exists with schema.
+    let _db = Database::open(&cwd)?;
+    println!("Database ready: .jettypod/work.db");
+
+    // Write config if it doesn't exist.
+    let config_path = jettypod_dir.join("config.json");
+    if !config_path.exists() {
+        let cfg = jettypod_core::config::ProjectConfig {
+            name: project_name.clone(),
+            stage: "empty".into(),
+            bundles: vec!["core".into()],
+            project_state: "internal".into(),
+            project_discovery: Default::default(),
+            main_branch: None,
+            extra: Default::default(),
+        };
+        config::write(&cwd, &cfg)?;
+        println!("Created config: .jettypod/config.json");
+    }
+
+    // Sync skills.
+    let source = skills::default_source_dir(&cwd);
+    let dest = skills::default_dest_dir(&cwd);
+    match skills::sync_skills(&skills::SyncOptions {
+        source_dir: source,
+        dest_dir: dest,
+    }) {
+        Ok(result) => {
+            if let Some(warning) = result.warning {
+                println!("Skills: {warning}");
+            } else {
+                println!("Skills: {} files synced", result.files_copied);
+            }
+        }
+        Err(e) => eprintln!("Warning: Skills sync failed: {e}"),
+    }
+
+    println!("\n✅ Initialized JettyPod project: {project_name}");
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Describe / Generate
+// ---------------------------------------------------------------------------
+
+pub fn describe(root: &Path, description: &str) -> Result<()> {
+    let mut cfg = config::read(root);
+    cfg.extra.insert(
+        "description".into(),
+        serde_json::Value::String(description.to_string()),
+    );
+    config::write(root, &cfg)?;
+    println!("Updated project description.");
+    Ok(())
+}
+
+pub fn generate(root: &Path) -> Result<()> {
+    // CLAUDE.md generation is handled by the Node.js template engine.
+    // For now, just confirm config exists.
+    let cfg = config::read(root);
+    println!("Project: {}", cfg.name);
+    println!("State: {}", cfg.project_state);
+    println!("CLAUDE.md regeneration requires the template engine (not yet ported).");
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Create
+// ---------------------------------------------------------------------------
+
+pub fn work_create(
+    ctx: &CommandContext,
+    from: Option<String>,
+    item_type: Option<String>,
+    title: Option<String>,
+    description: Option<String>,
+    parent: Option<i64>,
+    mode: Option<String>,
+    needs_discovery: bool,
+) -> Result<()> {
+    // Parse from JSON file if --from specified.
+    let (typ, ttl, desc, par, md, nd) = if let Some(path) = from {
+        let content = std::fs::read_to_string(&path)
+            .with_context(|| format!("Failed to read {path}"))?;
+        let v: serde_json::Value = serde_json::from_str(&content)
+            .with_context(|| format!("Invalid JSON in {path}"))?;
+
+        let t = v["type"].as_str().unwrap_or("feature").to_string();
+        let ti = v["title"]
+            .as_str()
+            .map(|s| s.to_string())
+            .unwrap_or_default();
+        let d = v["description"].as_str().map(|s| s.to_string());
+        let p = v["parent"].as_i64();
+        let m = v["mode"].as_str().map(|s| s.to_string());
+        let n = v["needsDiscovery"].as_bool().unwrap_or(false);
+        (t, ti, d, p, m, n)
+    } else {
+        let t = item_type.unwrap_or_else(|| "feature".into());
+        let ti = title.unwrap_or_default();
+        (t, ti, description, parent, mode, needs_discovery)
+    };
+
+    if ttl.is_empty() {
+        bail!("Title is required");
+    }
+
+    let item_type = typ.parse::<ItemType>()?;
+    let md_parsed = md.map(|m| m.parse::<Mode>()).transpose()?;
+
+    let id = work::create(
+        &ctx.db,
+        item_type,
+        &ttl,
+        CreateOptions {
+            description: desc.unwrap_or_default(),
+            parent_id: par,
+            mode: md_parsed,
+            needs_discovery: nd,
+            conversational: false,
+        },
+    )?;
+
+    println!(
+        "✅ Created {} #{}: {}",
+        type_icon(&item_type),
+        id,
+        ttl
+    );
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Start (create worktree)
+// ---------------------------------------------------------------------------
+
+pub fn work_start(ctx: &CommandContext, id: i64) -> Result<()> {
+    let item = work::get(&ctx.db, id)?;
+
+    // Check if worktree already exists.
+    if let Some(existing) = worktree::get_for_work_item(&ctx.db, id)? {
+        if existing.status == worktree::WorktreeStatus::Active {
+            println!(
+                "📁 Worktree already exists: {}",
+                existing.worktree_path
+            );
+            println!("Working on: [#{}] {} ({})", item.id, item.title, item.item_type);
+            return Ok(());
+        }
+    }
+
+    // Create worktree.
+    let wt = worktree::create(
+        &ctx.db,
+        &worktree::CreateWorktreeOpts {
+            work_item_id: id,
+            title: &item.title,
+            repo_root: &ctx.root,
+        },
+    )?;
+
+    // Mark as current and in_progress.
+    work::set_current(&ctx.db, id)?;
+    if item.status == Status::Backlog || item.status == Status::Todo {
+        work::update_status(&ctx.db, id, Status::InProgress)?;
+    }
+
+    // Set branch name.
+    work::set_branch(&ctx.db, id, &wt.branch_name)?;
+
+    // Write session file.
+    let epic = work::find_epic(&ctx.db, id)?;
+    if let Err(e) = sessions::write_session_file(
+        &ctx.root,
+        id,
+        &item.title,
+        item.item_type.as_ref(),
+        item.status.as_ref(),
+        item.mode.as_ref().map(|m| m.as_ref()).unwrap_or(""),
+        epic.as_ref().map(|e| e.id),
+        epic.as_ref().map(|e| e.title.as_str()),
+    ) {
+        eprintln!("Warning: Failed to write session file: {e}");
+    }
+
+    println!("✅ Created worktree: {}", wt.worktree_path);
+    println!(
+        "📁 IMPORTANT: Use absolute paths for file operations:\n   {}/lib/file.js (correct)\n   lib/file.js (wrong - creates in main repo)",
+        wt.worktree_path
+    );
+    println!(
+        "Working on: [#{}] {} ({})",
+        item.id, item.title, item.item_type
+    );
+
+    if let Some(parent_id) = item.parent_id {
+        if let Ok(parent) = work::get(&ctx.db, parent_id) {
+            if parent.scenario_file.is_none() {
+                println!(
+                    "\n⚠️  Warning: Parent feature has no scenario file\n\n\
+                     Parent feature #{} \"{}\" does not have\n\
+                     a scenario file set.\n\n\
+                     Suggestion: Create a BDD scenario file for the feature and update scenario_file.",
+                    parent.id, parent.title
+                );
+            }
+        }
+    }
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Stop
+// ---------------------------------------------------------------------------
+
+pub fn work_stop(ctx: &CommandContext, status: Option<String>) -> Result<()> {
+    // Find current work item.
+    let items = work::get_tree(&ctx.db, false)?;
+    let current = items.iter().find(|i| i.current);
+
+    match current {
+        Some(item) => {
+            if let Some(st) = status {
+                let new_status = st.parse::<Status>()?;
+                work::update_status(&ctx.db, item.id, new_status)?;
+                println!("Updated #{} status to {}", item.id, st);
+            }
+            // Clear current.
+            if let Err(e) = ctx.db.conn().execute(
+                "UPDATE work_items SET current = 0 WHERE id = ?",
+                rusqlite::params![item.id],
+            ) {
+                eprintln!("Warning: Failed to clear current work item: {e}");
+            }
+            // Clear session file.
+            if let Err(e) = sessions::clear_session_file(&ctx.root) {
+                eprintln!("Warning: Failed to clear session file: {e}");
+            }
+            println!("Stopped working on #{}: {}", item.id, item.title);
+        }
+        None => {
+            println!("No active work item.");
+        }
+    }
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Status update
+// ---------------------------------------------------------------------------
+
+pub fn work_status(ctx: &CommandContext, id: i64, status: &str) -> Result<()> {
+    let new_status = status.parse::<Status>()?;
+    work::update_status(&ctx.db, id, new_status)?;
+
+    let item = work::get(&ctx.db, id)?;
+    println!(
+        "{} #{} \"{}\" → {}",
+        status_icon(&new_status),
+        id,
+        item.title,
+        status
+    );
+
+    // Mark complete with ready_for_review if done.
+    if new_status == Status::Done {
+        println!("✅ {} #{} marked done.", type_icon(&item.item_type), id);
+    }
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Current
+// ---------------------------------------------------------------------------
+
+pub fn work_current(ctx: &CommandContext) -> Result<()> {
+    let items = work::get_tree(&ctx.db, false)?;
+    let current = items.iter().find(|i| i.current);
+
+    match current {
+        Some(item) => {
+            println!("{} #{}: {}", type_icon(&item.item_type), item.id, item.title);
+            println!("  Status: {} {}", status_icon(&item.status), item.status);
+            if let Some(ref mode) = item.mode {
+                println!("  Mode: {mode}");
+            }
+            if let Some(ref branch) = item.branch_name {
+                println!("  Branch: {branch}");
+            }
+        }
+        None => println!("No active work item."),
+    }
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Show
+// ---------------------------------------------------------------------------
+
+pub fn work_show(ctx: &CommandContext, id: i64) -> Result<()> {
+    let item = work::get(&ctx.db, id)?;
+
+    println!(
+        "{} #{}: {}",
+        type_icon(&item.item_type),
+        item.id,
+        item.title
+    );
+    println!("  Type: {}", item.item_type);
+    println!("  Status: {} {}", status_icon(&item.status), item.status);
+
+    if let Some(ref mode) = item.mode {
+        println!("  Mode: {mode}");
+    }
+    if let Some(ref phase) = item.phase {
+        println!("  Phase: {phase}");
+    }
+    if let Some(parent_id) = item.parent_id {
+        if let Ok(parent) = work::get(&ctx.db, parent_id) {
+            println!(
+                "  Parent: {} #{} {}",
+                type_icon(&parent.item_type),
+                parent.id,
+                parent.title
+            );
+        }
+    }
+    if let Some(ref branch) = item.branch_name {
+        println!("  Branch: {branch}");
+    }
+    if let Some(ref desc) = item.description {
+        if !desc.is_empty() {
+            println!("\n  {desc}");
+        }
+    }
+    if let Some(ref created) = item.created_at {
+        println!("  Created: {created}");
+    }
+    if let Some(ref completed) = item.completed_at {
+        println!("  Completed: {completed}");
+    }
+
+    // Show decisions if epic.
+    if item.item_type == ItemType::Epic {
+        let decisions = work::get_decisions(&ctx.db, id)?;
+        if !decisions.is_empty() {
+            println!("\n  Decisions:");
+            for d in &decisions {
+                println!("    • {}: {}", d.aspect, d.decision);
+                println!("      Rationale: {}", d.rationale);
+            }
+        }
+    }
+
+    // Show children.
+    let children = work::get_children(&ctx.db, id)?;
+    if !children.is_empty() {
+        println!("\n  Children:");
+        for child in &children {
+            println!(
+                "    {} #{}: {} [{}]",
+                type_icon(&child.item_type),
+                child.id,
+                child.title,
+                child.status
+            );
+        }
+    }
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Describe
+// ---------------------------------------------------------------------------
+
+pub fn work_describe(ctx: &CommandContext, id: i64, description: &str) -> Result<()> {
+    work::set_description(&ctx.db, id, description)?;
+    println!("Updated description for #{}.", id);
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Children
+// ---------------------------------------------------------------------------
+
+pub fn work_children(ctx: &CommandContext, id: i64) -> Result<()> {
+    let children = work::get_children(&ctx.db, id)?;
+
+    if children.is_empty() {
+        println!("No children for #{id}.");
+    } else {
+        for child in &children {
+            println!(
+                "{} #{}: {} [{}]{}",
+                type_icon(&child.item_type),
+                child.id,
+                child.title,
+                child.status,
+                child.mode.as_ref().map(|m| format!(" ({m})")).unwrap_or_default()
+            );
+        }
+    }
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Merge
+// ---------------------------------------------------------------------------
+
+pub fn work_merge(ctx: &CommandContext, id: Option<i64>, release_lock: bool) -> Result<()> {
+    // Find work item ID.
+    let work_id = match id {
+        Some(id) => id,
+        None => {
+            // Try to detect from current branch.
+            match sessions::get_current_work_from_branch(&ctx.db, &ctx.root)? {
+                Some(id) => id,
+                None => bail!("No work item ID provided and not in a worktree branch"),
+            }
+        }
+    };
+
+    if release_lock {
+        if let Err(e) = ctx.db.conn().execute(
+            "DELETE FROM merge_locks WHERE work_item_id = ?",
+            rusqlite::params![work_id],
+        ) {
+            eprintln!("Warning: Failed to release merge lock: {e}");
+        }
+        println!("Released merge lock for #{}.", work_id);
+        return Ok(());
+    }
+
+    let item = work::get(&ctx.db, work_id)?;
+    let wt = worktree::get_for_work_item(&ctx.db, work_id)?
+        .ok_or_else(|| anyhow::anyhow!("No worktree found for #{work_id}"))?;
+
+    // Guard: block merge if parent feature has no QA steps set.
+    if item.item_type == ItemType::Chore || item.item_type == ItemType::Bug {
+        if let Some(parent_id) = item.parent_id {
+            let parent = work::get(&ctx.db, parent_id)?;
+            if parent.item_type == ItemType::Feature {
+                let has_qa = parent
+                    .qa_steps
+                    .as_ref()
+                    .map(|s| !s.is_empty() && s != "[]")
+                    .unwrap_or(false);
+                if !has_qa {
+                    bail!(
+                        "Cannot merge: QA steps not set on parent feature #{} \"{}\".\n\
+                         Generate QA steps first:\n\n  \
+                         jettypod work set-qa-steps {} --from=<file>\n",
+                        parent_id, parent.title, parent_id
+                    );
+                }
+            }
+        }
+    }
+
+    println!("⏳ Acquiring merge lock...");
+    let lock_id = worktree::acquire_merge_lock(&ctx.db, work_id, "cli", 300)?;
+    println!("✅ Merge lock acquired");
+
+    println!("Merging work item #{}: {}", work_id, item.title);
+    println!("Branch: {}", wt.branch_name);
+
+    let merge_result = (|| -> Result<()> {
+        // Mark worktree as merging.
+        worktree::mark_status(&ctx.db, wt.id, worktree::WorktreeStatus::Merging)?;
+
+        let default_branch = config::resolve_default_branch(&ctx.root);
+
+        // Push feature branch.
+        println!("Pushing feature branch to remote...");
+        if let Err(e) = git::push_with_upstream(&ctx.root, &wt.branch_name) {
+            eprintln!("Warning: Failed to push feature branch: {e}");
+        }
+
+        // Checkout main.
+        println!("Checking out {default_branch}...");
+        git::run(&ctx.root, &["checkout", &default_branch])?;
+
+        // Pull latest.
+        println!("Updating {default_branch} from remote...");
+        if let Err(e) = git::pull_origin(&ctx.root, &default_branch) {
+            eprintln!("Warning: Failed to pull {}: {e}", default_branch);
+        }
+
+        // Merge.
+        println!("Merging {} into {default_branch}...", wt.branch_name);
+        git::merge_no_ff(&ctx.root, &wt.branch_name)?;
+
+        // Push main.
+        println!("Pushing {default_branch} to remote...");
+        if let Err(e) = git::run(&ctx.root, &["push"]) {
+            eprintln!("Warning: Failed to push {}: {e}", default_branch);
+        }
+
+        // Mark work item status.
+        println!("✓ Successfully merged work item #{work_id}");
+
+        // Update status.
+        if item.item_type == ItemType::Chore || item.item_type == ItemType::Bug {
+            work::update_status(&ctx.db, work_id, Status::Done)?;
+            println!(
+                "✅ {} #{} ready for review",
+                type_icon(&item.item_type),
+                work_id
+            );
+        }
+
+        Ok(())
+    })();
+
+    // Always release lock.
+    if let Err(e) = worktree::release_merge_lock(&ctx.db, lock_id) {
+        eprintln!("Warning: Failed to release merge lock: {e}");
+    }
+    println!("✅ Merge lock released");
+
+    if let Err(e) = merge_result {
+        bail!("Merge failed: {e}");
+    }
+
+    println!(
+        "\n⚠️  CLEANUP REQUIRED - Run these commands NOW:\n\n   cd {}\n   jettypod work cleanup {}\n\n   Worktrees accumulate until cleaned up.",
+        ctx.root.display(),
+        work_id
+    );
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Cleanup
+// ---------------------------------------------------------------------------
+
+pub fn work_cleanup(ctx: &CommandContext, id: Option<i64>, force: bool, dry_run: bool) -> Result<()> {
+    match id {
+        Some(work_id) => {
+            let wt = worktree::get_for_work_item(&ctx.db, work_id)?
+                .ok_or_else(|| anyhow::anyhow!("No worktree found for #{work_id}"))?;
+
+            let item = work::get(&ctx.db, work_id)?;
+            println!("Cleaning up worktree for #{}: {}", work_id, item.title);
+
+            if dry_run {
+                println!("  Would remove: {}", wt.worktree_path);
+                println!("  Would delete branch: {}", wt.branch_name);
+                return Ok(());
+            }
+
+            if !force
+                && wt.status != worktree::WorktreeStatus::Merging
+                && wt.status != worktree::WorktreeStatus::Active
+            {
+                println!("Worktree status is {} — nothing to clean.", wt.status);
+                return Ok(());
+            }
+
+            worktree::cleanup(
+                &ctx.db,
+                wt.id,
+                &worktree::CleanupWorktreeOpts {
+                    repo_root: &ctx.root,
+                    delete_branch: true,
+                },
+            )?;
+
+            println!("✅ Removed worktree directory");
+            println!("✅ Deleted branch");
+            println!("✅ Worktree cleaned up");
+        }
+        None => {
+            // Batch cleanup: find all non-active worktrees.
+            let active = worktree::get_all_active(&ctx.db)?;
+            if active.is_empty() {
+                println!("No active worktrees to clean up.");
+                return Ok(());
+            }
+            println!("Found {} active worktrees.", active.len());
+            for wt in &active {
+                let path = std::path::Path::new(&wt.worktree_path);
+                if !path.exists() {
+                    println!(
+                        "  Cleaning orphan: {} (directory missing)",
+                        wt.worktree_path
+                    );
+                    if !dry_run {
+                        if let Err(e) = worktree::cleanup(
+                            &ctx.db,
+                            wt.id,
+                            &worktree::CleanupWorktreeOpts {
+                                repo_root: &ctx.root,
+                                delete_branch: true,
+                            },
+                        ) {
+                            eprintln!("Warning: Failed to cleanup orphan worktree: {e}");
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Set mode / Elevate
+// ---------------------------------------------------------------------------
+
+pub fn work_set_mode(ctx: &CommandContext, id: i64, mode: &str) -> Result<()> {
+    work::set_mode(&ctx.db, id, mode)?;
+    println!("Set mode for #{} to {}", id, mode);
+    Ok(())
+}
+
+pub fn work_elevate(ctx: &CommandContext, id: i64, mode: &str) -> Result<()> {
+    let item = work::get(&ctx.db, id)?;
+
+    let target = mode.parse::<Mode>()?;
+    let valid_progression = match item.mode {
+        Some(Mode::Speed) => target == Mode::Stable || target == Mode::Production,
+        Some(Mode::Stable) => target == Mode::Production,
+        _ => false,
+    };
+
+    if !valid_progression {
+        bail!(
+            "Cannot elevate #{} from {:?} to {}",
+            id,
+            item.mode,
+            mode
+        );
+    }
+
+    work::set_mode(&ctx.db, id, mode)?;
+    println!(
+        "⬆️  Elevated #{} from {} → {}",
+        id,
+        item.mode.map(|m| m.to_string()).unwrap_or_default(),
+        mode
+    );
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Tests
+// ---------------------------------------------------------------------------
+
+pub fn work_tests(
+    ctx: &CommandContext,
+    action: Option<TestAction>,
+    id: Option<i64>,
+) -> Result<()> {
+    match action {
+        Some(TestAction::Start { id: feature_id }) => {
+            create_test_worktree(ctx, feature_id)
+        }
+        Some(TestAction::Merge { id: feature_id }) => {
+            println!("Merging test worktree for #{}...", feature_id);
+            work_merge(ctx, Some(feature_id), false)
+        }
+        None => {
+            // Shorthand: `jettypod work tests <id>`
+            match id {
+                Some(feature_id) => create_test_worktree(ctx, feature_id),
+                None => bail!("Usage: jettypod work tests <feature-id> OR jettypod work tests start <id>"),
+            }
+        }
+    }
+}
+
+fn create_test_worktree(ctx: &CommandContext, feature_id: i64) -> Result<()> {
+    let item = work::get(&ctx.db, feature_id)?;
+    println!("Creating test worktree for #{}: {}", feature_id, item.title);
+    let wt = worktree::create(
+        &ctx.db,
+        &worktree::CreateWorktreeOpts {
+            work_item_id: feature_id,
+            title: &format!("{}-tests", item.title),
+            repo_root: &ctx.root,
+        },
+    )?;
+    println!("✅ Test worktree created: {}", wt.worktree_path);
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Prototype
+// ---------------------------------------------------------------------------
+
+pub fn work_prototype(ctx: &CommandContext, action: PrototypeAction) -> Result<()> {
+    match action {
+        PrototypeAction::Start { id, approach } => {
+            let item = work::get(&ctx.db, id)?;
+            println!(
+                "Creating prototype worktree for #{}: {} (approach: {})",
+                id, item.title, approach
+            );
+            let wt = worktree::create(
+                &ctx.db,
+                &worktree::CreateWorktreeOpts {
+                    work_item_id: id,
+                    title: &format!("{}-prototype-{}", item.title, approach),
+                    repo_root: &ctx.root,
+                },
+            )?;
+            println!("✅ Prototype worktree created: {}", wt.worktree_path);
+            Ok(())
+        }
+        PrototypeAction::Merge { id } => {
+            println!("Merging prototype worktree for #{}...", id);
+            work_merge(ctx, Some(id), false)
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Work: Epic implement (record decision)
+// ---------------------------------------------------------------------------
+
+pub fn work_epic_implement(
+    ctx: &CommandContext,
+    id: i64,
+    aspect: &str,
+    decision: &str,
+    rationale: &str,
+    _prototypes: Option<String>,
+) -> Result<()> {
+    let item = work::get(&ctx.db, id)?;
+
+    if item.item_type != ItemType::Epic {
+        bail!("#{} is a {} — epic-implement is only for epics", id, item.item_type);
+    }
+
+    work::add_decision(&ctx.db, id, aspect, decision, rationale)?;
+    println!("✅ Architectural decision recorded for epic #{}", id);
+    println!("  Aspect: {aspect}");
+    println!("  Decision: {decision}");
+    println!("  Rationale: {rationale}");
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Set QA Steps
+// ---------------------------------------------------------------------------
+
+pub fn work_set_qa_steps(
+    ctx: &CommandContext,
+    id: i64,
+    from: Option<String>,
+    steps: Option<String>,
+) -> Result<()> {
+    let json = if let Some(path) = from {
+        std::fs::read_to_string(&path)
+            .map_err(|e| anyhow::anyhow!("Failed to read file {}: {}", path, e))?
+    } else if let Some(s) = steps {
+        s
+    } else {
+        anyhow::bail!("Provide QA steps via --from=<file> or as an argument");
+    };
+
+    // Validate it's valid JSON array
+    let parsed: serde_json::Value = serde_json::from_str(&json)
+        .map_err(|e| anyhow::anyhow!("Invalid JSON: {}", e))?;
+    if !parsed.is_array() {
+        anyhow::bail!("QA steps must be a JSON array");
+    }
+
+    work::set_qa_steps(&ctx.db, id, &json)?;
+    let count = parsed.as_array().map(|a| a.len()).unwrap_or(0);
+    println!("✅ Set {} QA steps for work item #{}", count, id);
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Work: Implement (transition discovery → implementation)
+// ---------------------------------------------------------------------------
+
+pub fn work_implement(
+    ctx: &CommandContext,
+    id: i64,
+    _prototypes: Option<String>,
+    winner: Option<String>,
+) -> Result<()> {
+    let item = work::get(&ctx.db, id)?;
+
+    if item.item_type != ItemType::Feature {
+        bail!("#{} is a {} — implement is only for features", id, item.item_type);
+    }
+
+    work::complete_discovery(
+        &ctx.db,
+        id,
+        item.scenario_file.as_deref(),
+        winner.as_deref(),
+        None,
+    )?;
+
+    println!(
+        "✅ Feature #{} transitioned to implementation (mode: speed)",
+        id
+    );
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Backlog
+// ---------------------------------------------------------------------------
+
+pub fn backlog(ctx: &CommandContext, _expand: Option<&str>, expand_all: bool) -> Result<()> {
+    let items = work::get_tree(&ctx.db, false)?;
+
+    if items.is_empty() {
+        println!("Backlog is empty.");
+        return Ok(());
+    }
+
+    // Group by: top-level items (no parent) and their children.
+    let top_level: Vec<_> = items.iter().filter(|i| i.parent_id.is_none()).collect();
+
+    // Recently completed (last 5).
+    let completed = {
+        let all = work::get_tree(&ctx.db, true)?;
+        let mut done: Vec<_> = all.iter().filter(|i| i.status == Status::Done).cloned().collect();
+        done.sort_by(|a, b| b.completed_at.cmp(&a.completed_at));
+        done.truncate(5);
+        done
+    };
+
+    if !completed.is_empty() {
+        println!("Recently completed:");
+        for item in &completed {
+            println!(
+                "  ✅ {} #{}: {}",
+                type_icon(&item.item_type),
+                item.id,
+                item.title
+            );
+        }
+        println!();
+    }
+
+    println!("Backlog:");
+    for item in &top_level {
+        let mode_str = item
+            .mode
+            .as_ref()
+            .map(|m| format!(" ({m})"))
+            .unwrap_or_default();
+        println!(
+            "{} #{}: {} [{}]{}",
+            type_icon(&item.item_type),
+            item.id,
+            item.title,
+            item.status,
+            mode_str
+        );
+
+        // Show children.
+        let children: Vec<_> = items.iter().filter(|c| c.parent_id == Some(item.id)).collect();
+        for child in &children {
+            let child_mode = child
+                .mode
+                .as_ref()
+                .map(|m| format!(" ({m})"))
+                .unwrap_or_default();
+            println!(
+                "  {} #{}: {} [{}]{}",
+                type_icon(&child.item_type),
+                child.id,
+                child.title,
+                child.status,
+                child_mode
+            );
+
+            if expand_all {
+                // Show grandchildren.
+                let grandchildren: Vec<_> =
+                    items.iter().filter(|g| g.parent_id == Some(child.id)).collect();
+                for gc in &grandchildren {
+                    println!(
+                        "    {} #{}: {} [{}]",
+                        type_icon(&gc.item_type),
+                        gc.id,
+                        gc.title,
+                        gc.status
+                    );
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Decisions
+// ---------------------------------------------------------------------------
+
+pub fn decisions(
+    ctx: &CommandContext,
+    all: bool,
+    _project: bool,
+    _epics: bool,
+    epic: Option<i64>,
+    view: bool,
+) -> Result<()> {
+    if view {
+        let decisions_path = ctx.root.join("docs").join("DECISIONS.md");
+        if decisions_path.exists() {
+            let content = std::fs::read_to_string(&decisions_path)?;
+            println!("{content}");
+        } else {
+            println!("No DECISIONS.md found.");
+        }
+        return Ok(());
+    }
+
+    if let Some(epic_id) = epic {
+        let decisions = work::get_decisions(&ctx.db, epic_id)?;
+        let item = work::get(&ctx.db, epic_id)?;
+        println!("Decisions for {} #{}: {}", type_icon(&item.item_type), epic_id, item.title);
+        if decisions.is_empty() {
+            println!("  No decisions recorded.");
+        } else {
+            for d in &decisions {
+                println!("  • {}: {}", d.aspect, d.decision);
+                println!("    Rationale: {}", d.rationale);
+            }
+        }
+        return Ok(());
+    }
+
+    if all {
+        // Show all decisions across all epics.
+        let items = work::get_tree(&ctx.db, true)?;
+        let epics: Vec<_> = items.iter().filter(|i| i.item_type == ItemType::Epic).collect();
+        for ep in &epics {
+            let decisions = work::get_decisions(&ctx.db, ep.id)?;
+            if !decisions.is_empty() {
+                println!("📦 #{}: {}", ep.id, ep.title);
+                for d in &decisions {
+                    println!("  • {}: {}", d.aspect, d.decision);
+                    println!("    Rationale: {}", d.rationale);
+                }
+                println!();
+            }
+        }
+    }
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Project
+// ---------------------------------------------------------------------------
+
+pub fn project_state(ctx: &CommandContext) -> Result<()> {
+    let cfg = config::read(&ctx.root);
+    println!("Project state: {}", cfg.project_state);
+    Ok(())
+}
+
+pub fn project_info(ctx: &CommandContext) -> Result<()> {
+    let cfg = config::read(&ctx.root);
+    println!("Project: {}", cfg.name);
+    println!("State: {}", cfg.project_state);
+    if let Some(desc) = cfg.extra.get("description") {
+        if let Some(s) = desc.as_str() {
+            println!("Description: {s}");
+        }
+    }
+    Ok(())
+}
+
+pub fn project_external(ctx: &CommandContext) -> Result<()> {
+    let mut cfg = config::read(&ctx.root);
+    cfg.project_state = "external".into();
+    config::write(&ctx.root, &cfg)?;
+    println!("✅ Project state updated to: external");
+    Ok(())
+}
+
+pub fn project_discover_start(ctx: &CommandContext) -> Result<()> {
+    let mut cfg = config::read(&ctx.root);
+    cfg.project_discovery.status = "in_progress".into();
+    cfg.project_discovery.started_date = Some(chrono::Utc::now().to_rfc3339());
+    config::write(&ctx.root, &cfg)?;
+    println!("🔍 Project discovery started.");
+    Ok(())
+}
+
+pub fn project_discover_complete(
+    ctx: &CommandContext,
+    winner: &str,
+    rationale: &str,
+    _prototypes: Option<String>,
+) -> Result<()> {
+    if !std::path::Path::new(winner).exists() {
+        bail!("Winner path does not exist: {winner}");
+    }
+
+    let mut cfg = config::read(&ctx.root);
+    cfg.project_discovery.status = "completed".into();
+    cfg.project_discovery.winner = Some(winner.to_string());
+    cfg.project_discovery.rationale = Some(rationale.to_string());
+    cfg.project_discovery.completed_date = Some(chrono::Utc::now().to_rfc3339());
+    config::write(&ctx.root, &cfg)?;
+    println!("✅ Project discovery completed.");
+    println!("  Winner: {winner}");
+    println!("  Rationale: {rationale}");
+    Ok(())
+}
+
+pub fn project_prototype_start(ctx: &CommandContext, approach: &str) -> Result<()> {
+    // Create a special worktree for project prototype.
+    let wt = worktree::create(
+        &ctx.db,
+        &worktree::CreateWorktreeOpts {
+            work_item_id: 0, // Project-level, no work item.
+            title: &format!("project-prototype-{approach}"),
+            repo_root: &ctx.root,
+        },
+    )?;
+    println!("✅ Prototype worktree created: {}", wt.worktree_path);
+    Ok(())
+}
+
+pub fn project_prototype_merge(ctx: &CommandContext) -> Result<()> {
+    println!("Merging project prototype...");
+    // Find and merge the project prototype worktree.
+    let active = worktree::get_all_active(&ctx.db)?;
+    let proto = active.iter().find(|w| w.worktree_path.contains("project-prototype"));
+    match proto {
+        Some(wt) => {
+            work_merge(ctx, Some(wt.work_item_id), false)
+        }
+        None => {
+            bail!("No active project prototype worktree found.");
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Impact
+// ---------------------------------------------------------------------------
+
+pub fn impact(ctx: &CommandContext, file: &str) -> Result<()> {
+    let items = work::get_tree(&ctx.db, false)?;
+
+    // Check which features have scenario files that reference this file.
+    let mut affected = Vec::new();
+    for item in &items {
+        if let Some(ref scenario) = item.scenario_file {
+            let scenario_path = ctx.root.join(scenario);
+            if scenario_path.exists() {
+                if let Ok(content) = std::fs::read_to_string(&scenario_path) {
+                    if content.contains(file) {
+                        affected.push(item);
+                    }
+                }
+            }
+        }
+    }
+
+    if affected.is_empty() {
+        println!("No features/tests reference: {file}");
+    } else {
+        println!("Affected by changes to {file}:");
+        for item in &affected {
+            println!(
+                "  {} #{}: {} [{}]",
+                type_icon(&item.item_type),
+                item.id,
+                item.title,
+                item.status
+            );
+        }
+    }
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Workflow
+// ---------------------------------------------------------------------------
+
+pub fn workflow_start(ctx: &CommandContext, skill: &str, id: i64) -> Result<()> {
+    // Record skill execution.
+    ctx.db.conn().execute(
+        "INSERT INTO skill_executions (work_item_id, skill_name, status) VALUES (?, ?, 'in_progress')",
+        rusqlite::params![id, skill],
+    )?;
+
+    // Set workflow gate.
+    let gate_name = format!("{}_started", skill.replace('-', "_"));
+    ctx.db.conn().execute(
+        "INSERT OR REPLACE INTO workflow_gates (work_item_id, gate_name, passed_at) \
+         VALUES (?, ?, datetime('now'))",
+        rusqlite::params![id, gate_name],
+    )?;
+
+    println!("Started {} for #{}", skill, id);
+    Ok(())
+}
+
+pub fn workflow_complete(ctx: &CommandContext, skill: &str, id: i64) -> Result<()> {
+    // Update skill execution.
+    ctx.db.conn().execute(
+        "UPDATE skill_executions SET status = 'completed', completed_at = datetime('now') \
+         WHERE work_item_id = ? AND skill_name = ? AND status = 'in_progress'",
+        rusqlite::params![id, skill],
+    )?;
+
+    // Set completion gate.
+    let gate_name = format!("{}_complete", skill.replace('-', "_"));
+    ctx.db.conn().execute(
+        "INSERT OR REPLACE INTO workflow_gates (work_item_id, gate_name, passed_at) \
+         VALUES (?, ?, datetime('now'))",
+        rusqlite::params![id, gate_name],
+    )?;
+
+    println!("Completed {} for #{}", skill, id);
+    Ok(())
+}
+
+pub fn workflow_checkpoint(ctx: &CommandContext, id: i64, step: i64) -> Result<()> {
+    let branch = git::current_branch(&ctx.root)?.unwrap_or_else(|| "unknown".to_string());
+
+    ctx.db.conn().execute(
+        "INSERT OR REPLACE INTO workflow_checkpoints (work_item_id, current_step, branch_name, skill_name) \
+         VALUES (?, ?, ?, 'chore-mode')",
+        rusqlite::params![id, step, branch],
+    )?;
+
+    println!("Checkpoint: step {} for #{}", step, id);
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Dashboard
+// ---------------------------------------------------------------------------
+
+pub async fn launch_dashboard(ctx: &CommandContext) -> Result<()> {
+    println!("Starting JettyPod dashboard...");
+
+    // Start WebSocket server for live updates.
+    let config = jettypod_core::ws::WsConfig {
+        port: jettypod_core::ws::DEFAULT_PORT,
+        project_root: ctx.root.clone(),
+    };
+    let _ws_handle = jettypod_core::ws::spawn_server(config);
+
+    println!("WebSocket server started on port {}", jettypod_core::ws::DEFAULT_PORT);
+    println!("Dashboard launch requires the Next.js dev server (not yet ported to Rust).");
+
+    Ok(())
+}