@simonfestl/husky-cli 0.6.1 → 0.7.0

package/README.md

@@ -39,6 +39,8 @@ husky
 husky task list                              # List all tasks
 husky task list --status in_progress         # Filter by status
 husky task list --json                       # JSON output
+husky task list -i                           # Interactive pagination
+husky task list --per-page 10 --page 2       # Paginated output
 husky task create "Fix login bug" --priority high
 husky task get <task-id>
 husky task start <task-id>
@@ -50,7 +52,9 @@ husky task delete <task-id>
 ### Project Management
 
 ```bash
-husky project list
+husky project list                           # List all projects
+husky project list -i                        # Interactive pagination
+husky project list --per-page 5 --page 1     # Paginated output
 husky project create "New Project" --description "..."
 husky project get <project-id>
 husky project update <project-id> --status active
@@ -63,7 +67,9 @@ husky project delete-knowledge <project-id> <knowledge-id>
 ### Workflow Management
 
 ```bash
-husky workflow list
+husky workflow list                          # List all workflows
+husky workflow list -i                       # Interactive pagination
+husky workflow list --per-page 5             # Paginated output
 husky workflow create "Onboarding" --department <id>
 husky workflow get <workflow-id>
 husky workflow update <workflow-id> --name "Updated"
@@ -78,7 +84,9 @@ husky workflow generate-mermaid <workflow-id>  # Mermaid diagram
 ### Idea Management
 
 ```bash
-husky idea list
+husky idea list                              # List all ideas
+husky idea list -i                           # Interactive pagination
+husky idea list --per-page 10                # Paginated output
 husky idea create "New feature idea" --category feature
 husky idea get <idea-id>
 husky idea update <idea-id> --status approved
@@ -237,6 +245,35 @@ husky completion zsh >> ~/.zshrc
 husky completion fish > ~/.config/fish/completions/husky.fish
 ```
 
+## Pagination
+
+List commands support pagination with two modes:
+
+### Interactive Pagination (`-i`)
+
+Navigate through results using arrow keys:
+
+```bash
+husky task list -i          # Interactive mode with arrow key navigation
+husky project list -i       # Works for projects, ideas, workflows
+```
+
+Features:
+- Use `↑`/`↓` to navigate items
+- `←` Previous page / `→` Next page
+- Press `Enter` to select and view details
+- Press `Esc` or select "Exit" to return
+
+### Static Pagination (`--page`, `--per-page`)
+
+For scripting or quick page views:
+
+```bash
+husky task list --per-page 10            # Show first 10 items
+husky task list --per-page 10 --page 2   # Show items 11-20
+husky idea list -n 5 -p 3                # Short form: 5 items, page 3
+```
+
 ## Environment Variables
 
 | Variable | Description |
@@ -299,6 +336,15 @@ husky --version
 
 ## Changelog
 
+### v0.6.2 (2026-01-06)
+- Added: Interactive pagination for list commands (`-i` flag)
+- Added: Static pagination (`--page`, `--per-page` flags)
+- Improved: Tasks, projects, ideas, workflows now support pagination
+
+### v0.6.1 (2026-01-06)
+- Added: Roadmap phase management (`update-phase`, `delete-phase`)
+- Fixed: Various bug fixes
+
 ### v0.6.0 (2026-01-06)
 - Added: Git Worktree support for multi-agent isolation
 - Added: `husky worktree` commands (create, list, merge, remove, etc.)

package/dist/commands/idea.js

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { getConfig } from "./config.js";
+import { paginateList, printPaginated } from "../lib/pagination.js";
 export const ideaCommand = new Command("idea")
     .description("Manage ideas");
 // Helper: Ensure API is configured
@@ -11,12 +12,22 @@ function ensureConfig() {
     }
     return config;
 }
+// Status labels and icons
+const STATUS_CONFIG = {
+    draft: { label: "Draft", icon: "📝" },
+    active: { label: "Active", icon: "💡" },
+    archived: { label: "Archived", icon: "📦" },
+    converted: { label: "Converted", icon: "✅" },
+};
 // husky idea list
 ideaCommand
     .command("list")
     .description("List all ideas")
     .option("--status <status>", "Filter by status (draft, active, archived, converted)")
     .option("--json", "Output as JSON")
+    .option("-p, --page <num>", "Page number (starts at 1)", "1")
+    .option("-n, --per-page <num>", "Items per page (default: all)")
+    .option("-i, --interactive", "Interactive pagination with arrow keys")
     .action(async (options) => {
     const config = ensureConfig();
     try {
@@ -33,10 +44,47 @@ ideaCommand
         const ideas = await res.json();
         if (options.json) {
             console.log(JSON.stringify(ideas, null, 2));
+            return;
         }
-        else {
-            printIdeas(ideas);
+        // Interactive pagination mode
+        if (options.interactive) {
+            await paginateList({
+                items: ideas,
+                pageSize: 10,
+                title: "Ideas",
+                emptyMessage: "No ideas found.",
+                renderItem: (idea) => {
+                    const cfg = STATUS_CONFIG[idea.status] || { label: idea.status, icon: "○" };
+                    return `  ${cfg.icon} ${idea.title.slice(0, 40).padEnd(40)} │ ${cfg.label}`;
+                },
+                selectableItems: true,
+                onSelect: async (idea) => {
+                    console.clear();
+                    console.log(`\n  Idea: ${idea.title}`);
+                    console.log("  " + "─".repeat(50));
+                    console.log(`  ID:       ${idea.id}`);
+                    console.log(`  Status:   ${STATUS_CONFIG[idea.status]?.label || idea.status}`);
+                    if (idea.category)
+                        console.log(`  Category: ${idea.category}`);
+                    if (idea.description)
+                        console.log(`  Desc:     ${idea.description}`);
+                    console.log("");
+                },
+            });
+            return;
+        }
+        // Simple pagination mode
+        if (options.perPage) {
+            const pageNum = parseInt(options.page, 10) - 1;
+            const pageSize = parseInt(options.perPage, 10);
+            printPaginated(ideas, pageNum, pageSize, (idea) => {
+                const cfg = STATUS_CONFIG[idea.status] || { label: idea.status, icon: "○" };
+                return `  ${cfg.icon} ${idea.id.slice(0, 8)} │ ${idea.title}`;
+            }, "Ideas");
+            return;
         }
+        // Default list
+        printIdeas(ideas);
     }
     catch (error) {
         console.error("Error fetching ideas:", error);

package/dist/commands/project.js

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { getConfig } from "./config.js";
+import { paginateList, printPaginated } from "../lib/pagination.js";
 export const projectCommand = new Command("project")
     .description("Manage projects and knowledge");
 // Helper: Ensure API is configured
@@ -37,6 +38,9 @@ projectCommand
     .option("--status <status>", "Filter by status (active, archived)")
     .option("--work-status <workStatus>", "Filter by work status (planning, in_progress, review, completed, on_hold)")
     .option("--archived", "Include archived projects")
+    .option("-p, --page <num>", "Page number (starts at 1)", "1")
+    .option("-n, --per-page <num>", "Items per page (default: all)")
+    .option("-i, --interactive", "Interactive pagination with arrow keys")
     .action(async (options) => {
     const config = ensureConfig();
     try {
@@ -60,10 +64,51 @@ projectCommand
         }
         if (options.json) {
             console.log(JSON.stringify(projects, null, 2));
+            return;
         }
-        else {
-            printProjects(projects);
+        // Interactive pagination mode
+        if (options.interactive) {
+            await paginateList({
+                items: projects,
+                pageSize: 10,
+                title: "Projects",
+                emptyMessage: "No projects found.",
+                renderItem: (project) => {
+                    const statusIcon = project.status === "archived" ? "📦" : "📁";
+                    const workStatusLabel = WORK_STATUS_LABELS[project.workStatus] || project.workStatus;
+                    return `  ${statusIcon} ${project.name.slice(0, 30).padEnd(30)} │ ${workStatusLabel}`;
+                },
+                selectableItems: true,
+                onSelect: async (project) => {
+                    console.clear();
+                    console.log(`\n  Project: ${project.name}`);
+                    console.log("  " + "─".repeat(50));
+                    console.log(`  ID:         ${project.id}`);
+                    console.log(`  Status:     ${project.status}`);
+                    console.log(`  Work:       ${WORK_STATUS_LABELS[project.workStatus]}`);
+                    if (project.description)
+                        console.log(`  Desc:       ${project.description}`);
+                    if (project.techStack)
+                        console.log(`  Tech:       ${project.techStack}`);
+                    if (project.githubRepo)
+                        console.log(`  GitHub:     ${project.githubRepo}`);
+                    console.log("");
+                },
+            });
+            return;
+        }
+        // Simple pagination mode
+        if (options.perPage) {
+            const pageNum = parseInt(options.page, 10) - 1;
+            const pageSize = parseInt(options.perPage, 10);
+            printPaginated(projects, pageNum, pageSize, (project) => {
+                const statusIcon = project.status === "archived" ? "📦" : "📁";
+                return `  ${statusIcon} ${project.id.slice(0, 8)} │ ${project.name}`;
+            }, "Projects");
+            return;
         }
+        // Default: standard list
+        printProjects(projects);
     }
     catch (error) {
         console.error("Error fetching projects:", error);

package/dist/commands/task.js

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import { getConfig } from "./config.js";
 import * as fs from "fs";
 import * as readline from "readline";
+import { paginateList, printPaginated } from "../lib/pagination.js";
 export const taskCommand = new Command("task")
     .description("Manage tasks");
 // Helper: Get task ID from --id flag or HUSKY_TASK_ID env var
@@ -40,6 +41,10 @@ taskCommand
     .command("list")
     .description("List all tasks")
     .option("-s, --status <status>", "Filter by status")
+    .option("-p, --page <num>", "Page number (starts at 1)", "1")
+    .option("-n, --per-page <num>", "Items per page (default: all)")
+    .option("-i, --interactive", "Interactive pagination with arrow keys")
+    .option("--json", "Output as JSON")
     .action(async (options) => {
     const config = getConfig();
     if (!config.apiUrl) {
@@ -58,6 +63,49 @@ taskCommand
             throw new Error(`API error: ${res.status}`);
         }
         const tasks = await res.json();
+        // JSON output
+        if (options.json) {
+            console.log(JSON.stringify(tasks, null, 2));
+            return;
+        }
+        // Interactive pagination mode
+        if (options.interactive) {
+            await paginateList({
+                items: tasks,
+                pageSize: 10,
+                title: "Tasks",
+                emptyMessage: "No tasks found.",
+                renderItem: (task) => {
+                    const statusIcon = task.status === "done" ? "✓" : task.status === "in_progress" ? "▶" : "○";
+                    const priorityIcon = task.priority === "urgent" ? "🔴" : task.priority === "high" ? "🟠" : "";
+                    return `  ${statusIcon} ${task.id.slice(0, 8)} │ ${task.title.slice(0, 40).padEnd(40)} ${priorityIcon}`;
+                },
+                selectableItems: true,
+                onSelect: async (task) => {
+                    console.clear();
+                    console.log(`\n  Task: ${task.title}`);
+                    console.log("  " + "─".repeat(50));
+                    console.log(`  ID:       ${task.id}`);
+                    console.log(`  Status:   ${task.status}`);
+                    console.log(`  Priority: ${task.priority}`);
+                    if (task.agent)
+                        console.log(`  Agent:    ${task.agent}`);
+                    console.log("");
+                },
+            });
+            return;
+        }
+        // Simple pagination mode
+        if (options.perPage) {
+            const pageNum = parseInt(options.page, 10) - 1;
+            const pageSize = parseInt(options.perPage, 10);
+            printPaginated(tasks, pageNum, pageSize, (task) => {
+                const statusIcon = task.status === "done" ? "✓" : task.status === "in_progress" ? "▶" : "○";
+                return `  ${statusIcon} ${task.id.slice(0, 8)} │ ${task.title}`;
+            }, "Tasks");
+            return;
+        }
+        // Default: grouped by status (original behavior)
         printTasks(tasks);
     }
     catch (error) {

package/dist/commands/vm.js

@@ -569,6 +569,13 @@ function printVMSessionDetail(session) {
     if (session.workflowId) {
         console.log(`  Workflow ID:  ${session.workflowId}`);
     }
+    // Pool info
+    if (session.sessionType) {
+        console.log(`  Session Type: ${session.sessionType === 'pool' ? 'Pool VM' : 'On-Demand'}`);
+        if (session.poolVmId) {
+            console.log(`  Pool VM ID:   ${session.poolVmId}`);
+        }
+    }
     console.log(`\n  Prompt:`);
     console.log(`    ${session.prompt}`);
     if (session.costEstimate !== undefined) {
@@ -619,3 +626,221 @@ function printLog(log) {
     }
     console.log(`${prefix}${timestamp} ${level} ${source} ${log.message}`);
 }
+// ============================================
+// VM POOL COMMANDS
+// ============================================
+const poolCommand = new Command("pool")
+    .description("Manage VM pool (admin)");
+// husky vm pool status
+poolCommand
+    .command("status")
+    .description("Show VM pool status")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = ensureConfig();
+    try {
+        const res = await fetch(`${config.apiUrl}/api/admin/vm-pool`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            const errorData = await res.json().catch(() => ({}));
+            throw new Error(errorData.error || `API error: ${res.status}`);
+        }
+        const data = await res.json();
+        const vms = data.vms || [];
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+        }
+        else {
+            printPoolStatus(vms);
+        }
+    }
+    catch (error) {
+        console.error("Error fetching VM pool status:", error);
+        process.exit(1);
+    }
+});
+// husky vm pool init
+poolCommand
+    .command("init")
+    .description("Initialize VM pool (1 HOT + 4 COLD VMs)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = ensureConfig();
+    console.log("Initializing VM pool...");
+    console.log("This will create 1 HOT VM + 4 COLD VMs\n");
+    try {
+        const res = await fetch(`${config.apiUrl}/api/admin/vm-pool/initialize`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+        });
+        if (!res.ok) {
+            const errorData = await res.json().catch(() => ({}));
+            throw new Error(errorData.error || `API error: ${res.status}`);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+        }
+        else {
+            console.log(`VM Pool initialized!`);
+            console.log(`  HOT VMs:  ${data.hotCount || 1}`);
+            console.log(`  COLD VMs: ${data.coldCount || 4}`);
+            console.log(`\nRun 'husky vm pool status' to see pool details`);
+        }
+    }
+    catch (error) {
+        console.error("Error initializing VM pool:", error);
+        process.exit(1);
+    }
+});
+// husky vm pool suspend <id>
+poolCommand
+    .command("suspend <id>")
+    .description("Suspend a pool VM")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    console.log(`Suspending VM ${id}...\n`);
+    try {
+        const res = await fetch(`${config.apiUrl}/api/admin/vm-pool/${id}/suspend`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+        });
+        if (!res.ok) {
+            const errorData = await res.json().catch(() => ({}));
+            throw new Error(errorData.error || `API error: ${res.status}`);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+        }
+        else {
+            console.log(`VM suspended successfully`);
+            console.log(`  VM Name: ${data.vmName}`);
+        }
+    }
+    catch (error) {
+        console.error("Error suspending VM:", error);
+        process.exit(1);
+    }
+});
+// husky vm pool resume <id>
+poolCommand
+    .command("resume <id>")
+    .description("Resume a suspended pool VM")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    console.log(`Resuming VM ${id}...\n`);
+    try {
+        const res = await fetch(`${config.apiUrl}/api/admin/vm-pool/${id}/resume`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+        });
+        if (!res.ok) {
+            const errorData = await res.json().catch(() => ({}));
+            throw new Error(errorData.error || `API error: ${res.status}`);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+        }
+        else {
+            console.log(`VM resumed successfully`);
+            console.log(`  VM Name: ${data.vmName}`);
+        }
+    }
+    catch (error) {
+        console.error("Error resuming VM:", error);
+        process.exit(1);
+    }
+});
+// husky vm pool setup <id>
+poolCommand
+    .command("setup <id>")
+    .description("Start Claude subscription setup for a pool VM")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    console.log(`Starting subscription setup for VM ${id}...\n`);
+    try {
+        const res = await fetch(`${config.apiUrl}/api/admin/vm-pool/${id}/setup`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+        });
+        if (!res.ok) {
+            const errorData = await res.json().catch(() => ({}));
+            throw new Error(errorData.error || `API error: ${res.status}`);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+        }
+        else {
+            console.log(`Setup session created!`);
+            console.log(`  Session ID: ${data.sessionId}`);
+            console.log(`  VM Name:    ${data.vmName}`);
+            console.log(`  VM IP:      ${data.vmIpAddress || "pending"}`);
+            console.log(`\nInstructions:`);
+            for (const instruction of data.instructions || []) {
+                console.log(`  ${instruction}`);
+            }
+            console.log(`\nExpires: ${data.expiresAt}`);
+        }
+    }
+    catch (error) {
+        console.error("Error starting setup:", error);
+        process.exit(1);
+    }
+});
+// Print helper for pool status
+function printPoolStatus(vms) {
+    if (vms.length === 0) {
+        console.log("\n  VM Pool is empty.");
+        console.log("  Initialize with: husky vm pool init\n");
+        return;
+    }
+    // Calculate stats
+    const total = vms.length;
+    const available = vms.filter(v => v.status === 'available').length;
+    const inUse = vms.filter(v => v.status === 'in_use').length;
+    const suspended = vms.filter(v => v.status === 'suspended').length;
+    const hotVms = vms.filter(v => v.tier === 'hot').length;
+    const authenticated = vms.filter(v => v.subscriptionAuth).length;
+    // Estimate monthly cost
+    const runningCost = (available + inUse) * 12.24; // $12.24/month for e2-small running
+    const suspendedCost = suspended * 0.30; // $0.30/month for suspended
+    const totalCost = runningCost + suspendedCost;
+    console.log("\n  VM POOL STATUS");
+    console.log("  " + "=".repeat(70));
+    console.log(`  Total: ${total} | Available: ${available} | In Use: ${inUse} | Suspended: ${suspended}`);
+    console.log(`  HOT VMs: ${hotVms} | Authenticated: ${authenticated}/${total}`);
+    console.log(`  Est. Monthly Cost: ~$${totalCost.toFixed(2)}`);
+    console.log("  " + "-".repeat(70));
+    console.log(`  ${"ID".padEnd(24)} ${"NAME".padEnd(18)} ${"STATUS".padEnd(12)} ${"TIER".padEnd(6)} ${"AUTH".padEnd(5)} LAST USED`);
+    console.log("  " + "-".repeat(70));
+    for (const vm of vms) {
+        const status = vm.status.toUpperCase().padEnd(12);
+        const tier = vm.tier.toUpperCase().padEnd(6);
+        const auth = vm.subscriptionAuth ? "Yes" : "No";
+        const lastUsed = new Date(vm.lastUsedAt).toLocaleDateString();
+        const truncatedName = vm.vmName.length > 16 ? vm.vmName.substring(0, 13) + "..." : vm.vmName;
+        console.log(`  ${vm.id.padEnd(24)} ${truncatedName.padEnd(18)} ${status} ${tier} ${auth.padEnd(5)} ${lastUsed}`);
+    }
+    console.log("");
+}
+// Add pool command to vm command
+vmCommand.addCommand(poolCommand);

package/dist/commands/workflow.js

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { getConfig } from "./config.js";
+import { paginateList, printPaginated } from "../lib/pagination.js";
 export const workflowCommand = new Command("workflow")
     .description("Manage workflows and workflow steps");
 // Helper: Ensure API is configured
@@ -11,12 +12,28 @@ function ensureConfig() {
     }
     return config;
 }
+// Status icons
+const STATUS_ICONS = {
+    draft: "📝",
+    active: "▶️",
+    paused: "⏸️",
+    archived: "📦",
+};
+// Action labels
+const ACTION_LABELS = {
+    manual: "Manual",
+    semi_automated: "Semi-Auto",
+    fully_automated: "Auto",
+};
 // husky workflow list
 workflowCommand
     .command("list")
     .description("List all workflows")
     .option("--value-stream <valueStream>", "Filter by value stream")
     .option("--json", "Output as JSON")
+    .option("-p, --page <num>", "Page number (starts at 1)", "1")
+    .option("-n, --per-page <num>", "Items per page (default: all)")
+    .option("-i, --interactive", "Interactive pagination with arrow keys")
     .action(async (options) => {
     const config = ensureConfig();
     try {
@@ -33,10 +50,49 @@ workflowCommand
         const workflows = await res.json();
         if (options.json) {
             console.log(JSON.stringify(workflows, null, 2));
-        }
-        else {
-            printWorkflows(workflows);
-        }
+            return;
+        }
+        // Interactive pagination mode
+        if (options.interactive) {
+            await paginateList({
+                items: workflows,
+                pageSize: 10,
+                title: "Workflows",
+                emptyMessage: "No workflows found.",
+                renderItem: (wf) => {
+                    const icon = STATUS_ICONS[wf.status] || "○";
+                    const action = ACTION_LABELS[wf.action] || wf.action;
+                    return `  ${icon} ${wf.name.slice(0, 35).padEnd(35)} │ ${action}`;
+                },
+                selectableItems: true,
+                onSelect: async (wf) => {
+                    console.clear();
+                    console.log(`\n  Workflow: ${wf.name}`);
+                    console.log("  " + "─".repeat(50));
+                    console.log(`  ID:          ${wf.id}`);
+                    console.log(`  Status:      ${wf.status}`);
+                    console.log(`  Action:      ${ACTION_LABELS[wf.action]}`);
+                    console.log(`  ValueStream: ${wf.valueStream}`);
+                    console.log(`  Autonomy:    ${wf.autonomyWeight}%`);
+                    if (wf.description)
+                        console.log(`  Desc:        ${wf.description}`);
+                    console.log("");
+                },
+            });
+            return;
+        }
+        // Simple pagination mode
+        if (options.perPage) {
+            const pageNum = parseInt(options.page, 10) - 1;
+            const pageSize = parseInt(options.perPage, 10);
+            printPaginated(workflows, pageNum, pageSize, (wf) => {
+                const icon = STATUS_ICONS[wf.status] || "○";
+                return `  ${icon} ${wf.id.slice(0, 8)} │ ${wf.name}`;
+            }, "Workflows");
+            return;
+        }
+        // Default list
+        printWorkflows(workflows);
     }
     catch (error) {
         console.error("Error fetching workflows:", error);
@@ -91,9 +147,9 @@ workflowCommand
     .command("create <name>")
     .description("Create a new workflow")
     .option("-d, --description <description>", "Workflow description")
-    .option("--value-stream <valueStream>", "Value stream", "general")
-    .option("--status <status>", "Workflow status (draft, active, paused, archived)", "draft")
-    .option("--action <action>", "Action type (manual, semi_automated, fully_automated)", "manual")
+    .option("--value-stream <valueStream>", "Value stream (order_to_delivery, procure_to_pay, returns_management, product_lifecycle, customer_service, finance_admin)", "customer_service")
+    .option("--status <status>", "Workflow status (owner_only, approval_needed, supervised, delegated, automated)", "owner_only")
+    .option("--action <action>", "Action type (automate, hire, document, fix, ok)", "document")
     .option("--json", "Output as JSON")
     .action(async (name, options) => {
     const config = ensureConfig();

package/dist/lib/pagination.d.ts

@@ -0,0 +1,36 @@
+export interface PaginationOptions<T> {
+    items: T[];
+    pageSize?: number;
+    renderItem: (item: T, index: number) => string;
+    title?: string;
+    emptyMessage?: string;
+    selectableItems?: boolean;
+    onSelect?: (item: T) => Promise<void>;
+}
+export interface PaginationResult<T> {
+    selectedItem: T | null;
+    action: "select" | "exit";
+}
+/**
+ * Interactive paginated list with arrow key navigation
+ *
+ * @example
+ * await paginateList({
+ *   items: tasks,
+ *   pageSize: 10,
+ *   renderItem: (t, i) => `${t.id} - ${t.title}`,
+ *   title: "Tasks",
+ *   selectableItems: true,
+ *   onSelect: async (task) => console.log(`Selected: ${task.title}`)
+ * });
+ */
+export declare function paginateList<T>(options: PaginationOptions<T>): Promise<PaginationResult<T>>;
+/**
+ * Simple paginated display without interactivity
+ * Useful for CLI commands that just want to show paginated output
+ */
+export declare function printPaginated<T>(items: T[], page: number, pageSize: number, renderItem: (item: T, index: number) => string, title?: string): {
+    hasMore: boolean;
+    totalPages: number;
+    currentPage: number;
+};

package/dist/lib/pagination.js

@@ -0,0 +1,180 @@
+import { select } from "@inquirer/prompts";
+const NAVIGATION_SEPARATOR = "──────────────";
+/**
+ * Interactive paginated list with arrow key navigation
+ *
+ * @example
+ * await paginateList({
+ *   items: tasks,
+ *   pageSize: 10,
+ *   renderItem: (t, i) => `${t.id} - ${t.title}`,
+ *   title: "Tasks",
+ *   selectableItems: true,
+ *   onSelect: async (task) => console.log(`Selected: ${task.title}`)
+ * });
+ */
+export async function paginateList(options) {
+    const { items, pageSize = 10, renderItem, title = "Items", emptyMessage = "No items found.", selectableItems = false, onSelect, } = options;
+    if (items.length === 0) {
+        console.log(`\n  ${emptyMessage}`);
+        return { selectedItem: null, action: "exit" };
+    }
+    const totalPages = Math.ceil(items.length / pageSize);
+    let currentPage = 0;
+    while (true) {
+        const startIndex = currentPage * pageSize;
+        const endIndex = Math.min(startIndex + pageSize, items.length);
+        const pageItems = items.slice(startIndex, endIndex);
+        // Clear screen and show header
+        console.clear();
+        console.log(`\n  ${title} (${items.length} total)`);
+        console.log(`  Page ${currentPage + 1} of ${totalPages}`);
+        console.log("  " + "─".repeat(50));
+        // Build choices for current page
+        const choices = [];
+        // Add page items
+        pageItems.forEach((item, idx) => {
+            const globalIndex = startIndex + idx;
+            const displayText = renderItem(item, globalIndex);
+            choices.push({
+                name: displayText,
+                value: selectableItems ? `item:${globalIndex}` : `view:${globalIndex}`,
+                description: selectableItems ? "Select this item" : undefined,
+            });
+        });
+        // Add separator
+        choices.push({
+            name: NAVIGATION_SEPARATOR,
+            value: "separator",
+            description: "",
+        });
+        // Navigation options
+        const navOptions = [];
+        if (currentPage > 0) {
+            navOptions.push({
+                name: "← Previous Page",
+                value: "prev",
+                description: `Go to page ${currentPage}`,
+            });
+        }
+        if (currentPage < totalPages - 1) {
+            navOptions.push({
+                name: "→ Next Page",
+                value: "next",
+                description: `Go to page ${currentPage + 2}`,
+            });
+        }
+        if (totalPages > 2) {
+            navOptions.push({
+                name: "⇢ Jump to Page...",
+                value: "jump",
+                description: `Go to a specific page (1-${totalPages})`,
+            });
+        }
+        navOptions.push({
+            name: "✕ Exit",
+            value: "exit",
+            description: "Return to previous menu",
+        });
+        choices.push(...navOptions);
+        try {
+            const answer = await select({
+                message: "Navigate with ↑↓, select with Enter:",
+                choices,
+                pageSize: pageSize + 5, // Room for navigation
+            });
+            if (answer === "separator") {
+                // User selected separator, ignore and continue
+                continue;
+            }
+            if (answer === "prev") {
+                currentPage = Math.max(0, currentPage - 1);
+                continue;
+            }
+            if (answer === "next") {
+                currentPage = Math.min(totalPages - 1, currentPage + 1);
+                continue;
+            }
+            if (answer === "jump") {
+                const jumpChoice = await selectPageNumber(totalPages, currentPage);
+                if (jumpChoice !== null) {
+                    currentPage = jumpChoice;
+                }
+                continue;
+            }
+            if (answer === "exit") {
+                return { selectedItem: null, action: "exit" };
+            }
+            // Handle item selection
+            if (answer.startsWith("item:") || answer.startsWith("view:")) {
+                const index = parseInt(answer.split(":")[1], 10);
+                const selectedItem = items[index];
+                if (selectableItems && onSelect && selectedItem) {
+                    await onSelect(selectedItem);
+                }
+                return { selectedItem, action: "select" };
+            }
+        }
+        catch (error) {
+            // User pressed Ctrl+C or escape
+            return { selectedItem: null, action: "exit" };
+        }
+    }
+}
+/**
+ * Helper to select a page number
+ */
+async function selectPageNumber(totalPages, currentPage) {
+    const choices = [];
+    for (let i = 0; i < totalPages; i++) {
+        choices.push({
+            name: `Page ${i + 1}${i === currentPage ? " (current)" : ""}`,
+            value: i.toString(),
+        });
+    }
+    choices.push({
+        name: "Cancel",
+        value: "cancel",
+    });
+    try {
+        const answer = await select({
+            message: "Select page:",
+            choices,
+            pageSize: Math.min(totalPages + 1, 15),
+        });
+        if (answer === "cancel") {
+            return null;
+        }
+        return parseInt(answer, 10);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Simple paginated display without interactivity
+ * Useful for CLI commands that just want to show paginated output
+ */
+export function printPaginated(items, page, pageSize, renderItem, title) {
+    const totalPages = Math.ceil(items.length / pageSize);
+    const currentPage = Math.min(Math.max(0, page), totalPages - 1);
+    const startIndex = currentPage * pageSize;
+    const endIndex = Math.min(startIndex + pageSize, items.length);
+    const pageItems = items.slice(startIndex, endIndex);
+    if (title) {
+        console.log(`\n  ${title}`);
+        console.log("  " + "─".repeat(50));
+    }
+    pageItems.forEach((item, idx) => {
+        console.log(renderItem(item, startIndex + idx));
+    });
+    if (totalPages > 1) {
+        console.log("");
+        console.log(`  Page ${currentPage + 1} of ${totalPages} (${items.length} total)`);
+    }
+    return {
+        hasMore: currentPage < totalPages - 1,
+        totalPages,
+        currentPage,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonfestl/husky-cli",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {