@simonfestl/husky-cli 0.9.5 → 0.9.7

package/dist/commands/llm-context.js

@@ -2,7 +2,7 @@
  * LLM Context Generator
  * Outputs markdown reference for LLM agents
  */
-const VERSION = "0.9.5";
+const VERSION = "0.9.7";
 export function generateLLMContext() {
     return `# Husky CLI Reference (v${VERSION})
 
@@ -54,11 +54,15 @@ husky config test
 husky task list [--status <status>]     # List tasks
 husky task get <id>                     # Get task details
 husky task create                       # Create new task
-husky task start <id>                   # Start working on task
+husky task start <id>                   # Start task (auto-creates worktree!)
+husky task start <id> --no-worktree     # Start without worktree
 husky task done <id> [--pr <url>]       # Mark task as done
 husky task update <id>                  # Update task fields
 husky task assign <id> <assignee>       # Assign task
 husky task log <id>                     # View task activity log
+husky task message <id> "msg"           # Post status message (positional)
+husky task message -m "msg" --id <id>   # Post status message (flags)
+husky task message -m "msg"             # Uses HUSKY_TASK_ID env var
 \`\`\`
 
 ### Projects
@@ -125,8 +129,12 @@ husky changelog list                    # List changelogs
 \`\`\`bash
 husky worktree list                     # List worktrees
 husky worktree create <name>            # Create isolated worktree
-husky worktree delete <name>            # Delete worktree
-husky worktree switch <name>            # Switch to worktree
+husky worktree create <name> --task-id <id>  # Create and register with task
+husky worktree merge <name>             # Merge back to base branch
+husky worktree push <name>              # Push branch to remote
+husky worktree pr <name> -t "Title"     # Create pull request
+husky worktree remove <name>            # Remove worktree
+husky worktree sync-stats <name> --task-id <id>  # Sync stats to dashboard
 \`\`\`
 
 ### VM Sessions (Cloud Agents)

package/dist/commands/service-account.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const serviceAccountCommand: Command;

package/dist/commands/service-account.js

@@ -0,0 +1,180 @@
+import { Command } from "commander";
+const API_URL = process.env.HUSKY_API_URL || "https://huskyv0-dashboard-474966775596.europe-west1.run.app";
+const API_KEY = process.env.HUSKY_API_KEY || "";
+async function fetchApi(path, options = {}) {
+    const response = await fetch(`${API_URL}${path}`, {
+        ...options,
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": API_KEY,
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        throw new Error(error.error || `HTTP ${response.status}`);
+    }
+    return response.json();
+}
+function formatPersona(personaType) {
+    const icons = {
+        "support-agent": "🎧",
+        "research-agent": "🔬",
+        "accounting-agent": "📊",
+        "marketing-agent": "📢",
+        "developer-agent": "💻",
+        "devops-agent": "🔧",
+    };
+    return `${icons[personaType] || "👤"} ${personaType}`;
+}
+function formatPermissionLevel(level) {
+    const colors = {
+        "read-only": "\x1b[90m", // gray
+        "developer": "\x1b[34m", // blue
+        "admin": "\x1b[31m", // red
+    };
+    const reset = "\x1b[0m";
+    return `${colors[level] || ""}${level}${reset}`;
+}
+export const serviceAccountCommand = new Command("sa")
+    .description("Manage Agent Service Accounts")
+    .addHelpText("after", `
+Examples:
+  husky sa list                List all service account bindings
+  husky sa get developer-agent Show binding for developer persona
+  husky sa sync               Sync bindings from GCP config
+  husky sa verify             Verify current VM's service account
+`);
+// List all bindings
+serviceAccountCommand
+    .command("list")
+    .description("List all service account bindings")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        const data = await fetchApi("/api/service-account-bindings");
+        const bindings = (data.bindings || []);
+        if (options.json) {
+            console.log(JSON.stringify(bindings, null, 2));
+            return;
+        }
+        if (bindings.length === 0) {
+            console.log("No service account bindings found.");
+            console.log("Run 'husky sa sync' to create bindings from GCP config.");
+            return;
+        }
+        console.log("\n📋 Service Account Bindings\n");
+        console.log("━".repeat(80));
+        for (const binding of bindings) {
+            console.log(`${formatPersona(binding.personaType)}`);
+            console.log(`  Email: ${binding.serviceAccountEmail}`);
+            console.log(`  Permission: ${formatPermissionLevel(binding.permissionLevel)}`);
+            console.log(`  Roles: ${binding.iamRoles.join(", ") || "none"}`);
+            if (binding.lastSyncedAt) {
+                console.log(`  Last Synced: ${new Date(binding.lastSyncedAt).toLocaleString()}`);
+            }
+            console.log("━".repeat(80));
+        }
+        console.log(`\nTotal: ${bindings.length} bindings`);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// Get specific binding
+serviceAccountCommand
+    .command("get <persona>")
+    .description("Get service account binding for a persona")
+    .option("--json", "Output as JSON")
+    .action(async (persona, options) => {
+    try {
+        // First list all and filter by persona
+        const data = await fetchApi("/api/service-account-bindings");
+        const bindings = (data.bindings || []);
+        const binding = bindings.find((b) => b.personaType === persona);
+        if (!binding) {
+            console.log(`No binding found for persona: ${persona}`);
+            console.log("\nAvailable personas:");
+            bindings.forEach((b) => console.log(`  - ${b.personaType}`));
+            return;
+        }
+        if (options.json) {
+            console.log(JSON.stringify(binding, null, 2));
+            return;
+        }
+        console.log(`\n${formatPersona(binding.personaType)}\n`);
+        console.log(`Email:       ${binding.serviceAccountEmail}`);
+        console.log(`Permission:  ${formatPermissionLevel(binding.permissionLevel)}`);
+        console.log(`Project:     ${binding.projectId}`);
+        console.log(`Roles:`);
+        binding.iamRoles.forEach((role) => console.log(`  - ${role}`));
+        if (binding.lastSyncedAt) {
+            console.log(`Last Synced: ${new Date(binding.lastSyncedAt).toLocaleString()}`);
+        }
+        console.log(`Created:     ${new Date(binding.createdAt).toLocaleString()}`);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// Sync from GCP
+serviceAccountCommand
+    .command("sync")
+    .description("Sync service account bindings from GCP config")
+    .action(async () => {
+    try {
+        console.log("🔄 Syncing service account bindings...\n");
+        const data = await fetchApi("/api/service-account-bindings/sync", {
+            method: "POST",
+        });
+        console.log(`✅ Synced ${data.synced} bindings\n`);
+        for (const result of (data.results || [])) {
+            const icon = result.status === "synced" ? "✓" : "✗";
+            console.log(`  ${icon} ${result.personaType}: ${result.email || result.status}`);
+        }
+        console.log("\nRun 'husky sa list' to see all bindings.");
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// Verify current VM's SA (for use on VMs)
+serviceAccountCommand
+    .command("verify")
+    .description("Verify current VM's service account (run on VM)")
+    .action(async () => {
+    try {
+        // Check if running on GCP by querying metadata service
+        const metadataUrl = "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/email";
+        console.log("🔍 Checking GCP metadata service...\n");
+        const response = await fetch(metadataUrl, {
+            headers: { "Metadata-Flavor": "Google" },
+        }).catch(() => null);
+        if (!response || !response.ok) {
+            console.log("❌ Not running on a GCP VM (metadata service unavailable)");
+            console.log("\nThis command is designed to run on GCP Compute Engine VMs.");
+            return;
+        }
+        const saEmail = await response.text();
+        console.log(`✅ Running as service account: ${saEmail}`);
+        // Try to match to a persona
+        const personaMatch = saEmail.match(/husky-(\w+)@/);
+        if (personaMatch) {
+            const persona = personaMatch[1] + "-agent";
+            console.log(`   Persona: ${formatPersona(persona)}`);
+        }
+        // Report to Husky if we have a task ID
+        const taskId = process.env.HUSKY_TASK_ID;
+        if (taskId) {
+            console.log(`\n📤 Reporting to Husky (task: ${taskId})...`);
+            // The VM startup script handles this, but we can also report here
+        }
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});

package/dist/commands/services.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const servicesCommand: Command;

package/dist/commands/services.js

@@ -0,0 +1,381 @@
+import { Command } from "commander";
+import { getConfig } from "./config.js";
+// Helper: Ensure API is configured
+function ensureConfig() {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    return { apiUrl: config.apiUrl, apiKey: config.apiKey };
+}
+// Helper: Make API request
+async function fetchAPI(apiUrl, apiKey, path, options = {}) {
+    const response = await fetch(`${apiUrl}${path}`, {
+        ...options,
+        headers: {
+            "Content-Type": "application/json",
+            ...(apiKey ? { "x-api-key": apiKey } : {}),
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`API Error: ${response.status} - ${error}`);
+    }
+    return response.json();
+}
+export const servicesCommand = new Command("services")
+    .description("Manage Agent Services (Agentic Workflow Platform)");
+// husky services list
+servicesCommand
+    .command("list")
+    .description("List all agent services")
+    .option("--project <id>", "Filter by project ID")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = ensureConfig();
+    try {
+        const params = new URLSearchParams();
+        if (options.project)
+            params.set("projectId", options.project);
+        const queryString = params.toString();
+        const path = queryString ? `/api/services?${queryString}` : "/api/services";
+        const services = await fetchAPI(config.apiUrl, config.apiKey, path);
+        if (options.json) {
+            console.log(JSON.stringify(services, null, 2));
+            return;
+        }
+        if (services.length === 0) {
+            console.log("No services found.");
+            return;
+        }
+        console.log("\n  Agent Services");
+        console.log("  " + "─".repeat(80));
+        for (const s of services) {
+            const statusIcon = {
+                building: "🔨",
+                deployed: "📦",
+                running: "✅",
+                failed: "❌",
+                disabled: "⏸️",
+            };
+            console.log(`  ${statusIcon[s.status] || "❓"} ${s.name} (${s.type})`);
+            console.log(`     ID: ${s.id}`);
+            console.log(`     Status: ${s.status}`);
+            if (s.schedule)
+                console.log(`     Schedule: ${s.schedule}`);
+            if (s.cloudRunUrl)
+                console.log(`     URL: ${s.cloudRunUrl}`);
+            console.log(`     Runs: ${s.runCount} (${s.successCount} success, ${s.failureCount} failed)`);
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services get <id>
+servicesCommand
+    .command("get <id>")
+    .description("Get service details")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    try {
+        const service = await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}`);
+        if (options.json) {
+            console.log(JSON.stringify(service, null, 2));
+            return;
+        }
+        console.log(`\n  Service: ${service.name}`);
+        console.log("  " + "─".repeat(50));
+        console.log(`  ID:          ${service.id}`);
+        console.log(`  Type:        ${service.type}`);
+        console.log(`  Status:      ${service.status}`);
+        if (service.description)
+            console.log(`  Description: ${service.description}`);
+        if (service.schedule)
+            console.log(`  Schedule:    ${service.schedule}`);
+        if (service.cloudRunUrl)
+            console.log(`  URL:         ${service.cloudRunUrl}`);
+        if (service.dockerImage)
+            console.log(`  Image:       ${service.dockerImage}`);
+        console.log(`  Runs:        ${service.runCount} total`);
+        console.log(`  Success:     ${service.successCount}`);
+        console.log(`  Failures:    ${service.failureCount}`);
+        if (service.avgDurationMs)
+            console.log(`  Avg Duration: ${service.avgDurationMs}ms`);
+        if (service.lastError)
+            console.log(`  Last Error:  ${service.lastError}`);
+        console.log(`  Created:     ${new Date(service.createdAt).toLocaleString()}`);
+        console.log(`  Updated:     ${new Date(service.updatedAt).toLocaleString()}`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services create <name>
+servicesCommand
+    .command("create <name>")
+    .description("Create a new agent service")
+    .option("-t, --type <type>", "Service type (cloud-run, cloud-function, scheduled-job)", "cloud-run")
+    .option("-d, --description <desc>", "Service description")
+    .option("-s, --schedule <cron>", 'Cron schedule (e.g., "0 6 * * *")')
+    .option("--project <id>", "Link to project")
+    .option("--repo <url>", "Source repository URL")
+    .option("--path <path>", "Source path in repository")
+    .action(async (name, options) => {
+    const config = ensureConfig();
+    try {
+        const service = await fetchAPI(config.apiUrl, config.apiKey, "/api/services", {
+            method: "POST",
+            body: JSON.stringify({
+                name,
+                type: options.type,
+                description: options.description,
+                schedule: options.schedule,
+                projectId: options.project,
+                sourceRepo: options.repo,
+                sourcePath: options.path,
+            }),
+        });
+        console.log(`✓ Created service: ${service.name} (${service.id})`);
+        console.log(`  Type: ${service.type}`);
+        console.log(`  Status: ${service.status}`);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services update <id>
+servicesCommand
+    .command("update <id>")
+    .description("Update a service")
+    .option("-d, --description <desc>", "Update description")
+    .option("-s, --schedule <cron>", "Update schedule")
+    .option("--status <status>", "Update status")
+    .option("--url <url>", "Set Cloud Run URL")
+    .option("--image <image>", "Set Docker image")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    const updates = {};
+    if (options.description)
+        updates.description = options.description;
+    if (options.schedule)
+        updates.schedule = options.schedule;
+    if (options.status)
+        updates.status = options.status;
+    if (options.url)
+        updates.cloudRunUrl = options.url;
+    if (options.image)
+        updates.dockerImage = options.image;
+    if (Object.keys(updates).length === 0) {
+        console.log("No updates specified. Use --help for available options.");
+        return;
+    }
+    try {
+        const service = await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(updates),
+        });
+        console.log(`✓ Updated service: ${service.name}`);
+        const changedFields = Object.keys(updates).join(", ");
+        console.log(`  Changed: ${changedFields}`);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services delete <id>
+servicesCommand
+    .command("delete <id>")
+    .description("Delete a service")
+    .option("-f, --force", "Skip confirmation")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    if (!options.force) {
+        console.log("Use --force to confirm deletion.");
+        return;
+    }
+    try {
+        await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}`, { method: "DELETE" });
+        console.log(`✓ Deleted service: ${id}`);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services health
+servicesCommand
+    .command("health")
+    .description("Check health of all services")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = ensureConfig();
+    try {
+        const services = await fetchAPI(config.apiUrl, config.apiKey, "/api/services");
+        if (options.json) {
+            const healthData = services
+                .filter((s) => s.status !== "disabled")
+                .map((s) => ({
+                id: s.id,
+                name: s.name,
+                healthStatus: s.healthStatus || "unknown",
+                status: s.status,
+                lastError: s.lastError,
+            }));
+            console.log(JSON.stringify(healthData, null, 2));
+            return;
+        }
+        console.log("\n  Service Health");
+        console.log("  " + "─".repeat(50));
+        let healthy = 0;
+        let unhealthy = 0;
+        let unknown = 0;
+        for (const s of services) {
+            if (s.status === "disabled")
+                continue;
+            const icon = s.healthStatus === "healthy"
+                ? "✅"
+                : s.healthStatus === "unhealthy"
+                    ? "❌"
+                    : "❓";
+            console.log(`  ${icon} ${s.name}: ${s.healthStatus || "unknown"}`);
+            if (s.lastError && s.healthStatus === "unhealthy") {
+                console.log(`     Last Error: ${s.lastError}`);
+            }
+            if (s.healthStatus === "healthy")
+                healthy++;
+            else if (s.healthStatus === "unhealthy")
+                unhealthy++;
+            else
+                unknown++;
+        }
+        console.log("");
+        console.log(`  Summary: ${healthy} healthy, ${unhealthy} unhealthy, ${unknown} unknown`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services run <id>
+servicesCommand
+    .command("run <id>")
+    .description("Trigger a service run")
+    .option("--input <json>", "Input data as JSON")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    let inputData = {};
+    if (options.input) {
+        try {
+            inputData = JSON.parse(options.input);
+        }
+        catch {
+            console.error("Error: --input must be valid JSON");
+            process.exit(1);
+        }
+    }
+    try {
+        const result = await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}/run`, {
+            method: "POST",
+            body: JSON.stringify({ input: inputData }),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`✓ Service run triggered: ${id}`);
+        if (result.runId)
+            console.log(`  Run ID: ${result.runId}`);
+        if (result.status)
+            console.log(`  Status: ${result.status}`);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services logs <id>
+servicesCommand
+    .command("logs <id>")
+    .description("View service logs")
+    .option("-n, --lines <num>", "Number of log lines", "50")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    try {
+        const logs = await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}/logs?limit=${options.lines}`);
+        if (options.json) {
+            console.log(JSON.stringify(logs, null, 2));
+            return;
+        }
+        if (!logs.entries || logs.entries.length === 0) {
+            console.log(`No logs found for service ${id}`);
+            return;
+        }
+        console.log(`\n  Logs for service: ${id}`);
+        console.log("  " + "─".repeat(70));
+        for (const entry of logs.entries) {
+            const timestamp = new Date(entry.timestamp).toLocaleString();
+            const level = entry.level?.toUpperCase() || "INFO";
+            console.log(`  [${timestamp}] ${level}: ${entry.message}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services runs <id>
+servicesCommand
+    .command("runs <id>")
+    .description("List recent runs for a service")
+    .option("-n, --limit <num>", "Number of runs to show", "10")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    try {
+        const runs = await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}/runs?limit=${options.limit}`);
+        if (options.json) {
+            console.log(JSON.stringify(runs, null, 2));
+            return;
+        }
+        if (!runs || runs.length === 0) {
+            console.log(`No runs found for service ${id}`);
+            return;
+        }
+        console.log(`\n  Recent Runs for service: ${id}`);
+        console.log("  " + "─".repeat(70));
+        for (const run of runs) {
+            const statusIcon = run.status === "success"
+                ? "✅"
+                : run.status === "failed"
+                    ? "❌"
+                    : run.status === "running"
+                        ? "▶"
+                        : "⏸️";
+            const timestamp = new Date(run.startedAt).toLocaleString();
+            const duration = run.durationMs ? `${run.durationMs}ms` : "—";
+            console.log(`  ${statusIcon} ${run.id.slice(0, 12)} │ ${timestamp} │ ${duration} │ ${run.status}`);
+            if (run.error) {
+                console.log(`     Error: ${run.error}`);
+            }
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});

package/dist/commands/task.js

@@ -221,7 +221,8 @@ taskCommand
 taskCommand
     .command("start <id>")
     .description("Start working on a task")
-    .action(async (id) => {
+    .option("--no-worktree", "Skip worktree creation")
+    .action(async (id, options) => {
     const config = getConfig();
     if (!config.apiUrl) {
         console.error("Error: API URL not configured.");
@@ -232,6 +233,15 @@ taskCommand
         const workerId = await ensureWorkerRegistered(config.apiUrl, config.apiKey || "");
         const sessionId = generateSessionId();
         await registerSession(config.apiUrl, config.apiKey || "", workerId, sessionId);
+        // Create worktree for isolation (unless --no-worktree)
+        let worktreeInfo = null;
+        if (options.worktree !== false) {
+            worktreeInfo = createWorktreeForTask(id);
+            if (worktreeInfo) {
+                console.log(`✓ Created worktree: ${worktreeInfo.path}`);
+                console.log(`  Branch: ${worktreeInfo.branch}`);
+            }
+        }
         const res = await fetch(`${config.apiUrl}/api/tasks/${id}/start`, {
             method: "POST",
             headers: {
@@ -242,6 +252,11 @@ taskCommand
                 agent: "claude-code",
                 workerId,
                 sessionId,
+                // Include worktree info if created
+                ...(worktreeInfo ? {
+                    worktreePath: worktreeInfo.path,
+                    worktreeBranch: worktreeInfo.branch,
+                } : {}),
             }),
         });
         if (!res.ok) {
@@ -251,6 +266,10 @@ taskCommand
         console.log(`✓ Started: ${task.title}`);
         console.log(`  Worker: ${workerId}`);
         console.log(`  Session: ${sessionId}`);
+        // Show hint to cd into worktree
+        if (worktreeInfo) {
+            console.log(`\n💡 To work in isolation: cd ${worktreeInfo.path}`);
+        }
     }
     catch (error) {
         console.error("Error starting task:", error);
@@ -547,11 +566,23 @@ taskCommand
 });
 // husky task message <id> "message" - post status message to task
 taskCommand
-    .command("message <id> <message>")
+    .command("message [id] [message]")
     .description("Post a status message to a task")
-    .action(async (id, message) => {
+    .option("-m, --message <text>", "Message text (alternative to positional arg)")
+    .option("--id <taskId>", "Task ID (alternative to positional arg, or use HUSKY_TASK_ID)")
+    .action(async (idArg, messageArg, options) => {
     const config = ensureConfig();
-    const taskId = id;
+    // Support both: `husky task message <id> <msg>` and `husky task message -m <msg> --id <id>`
+    const taskId = idArg || options.id || process.env.HUSKY_TASK_ID;
+    const message = messageArg || options.message;
+    if (!taskId) {
+        console.error("Error: Task ID required. Use positional arg, --id, or set HUSKY_TASK_ID");
+        process.exit(1);
+    }
+    if (!message) {
+        console.error("Error: Message required. Use positional arg or -m/--message");
+        process.exit(1);
+    }
     try {
         const res = await fetch(`${config.apiUrl}/api/tasks/${taskId}/status`, {
             method: "POST",