@simonfestl/husky-cli 0.7.2 → 0.8.2

package/dist/commands/config.d.ts

@@ -2,8 +2,10 @@ import { Command } from "commander";
 interface Config {
     apiUrl?: string;
     apiKey?: string;
+    workerId?: string;
+    workerName?: string;
 }
 export declare function getConfig(): Config;
-export declare function setConfig(key: "apiUrl" | "apiKey", value: string): void;
+export declare function setConfig(key: "apiUrl" | "apiKey" | "workerId" | "workerName", value: string): void;
 export declare const configCommand: Command;
 export {};

package/dist/commands/config.js

@@ -46,7 +46,7 @@ function saveConfig(config) {
     }
     writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
-// Helper to set a single config value (used by interactive mode)
+// Helper to set a single config value (used by interactive mode and worker identity)
 export function setConfig(key, value) {
     const config = getConfig();
     config[key] = value;

package/dist/commands/task.js

@@ -3,6 +3,9 @@ import { getConfig } from "./config.js";
 import * as fs from "fs";
 import * as readline from "readline";
 import { paginateList, printPaginated } from "../lib/pagination.js";
+import { ensureWorkerRegistered, generateSessionId, registerSession } from "../lib/worker.js";
+import { WorktreeManager } from "../lib/worktree.js";
+import { execSync } from "child_process";
 export const taskCommand = new Command("task")
     .description("Manage tasks");
 // Helper: Get task ID from --id flag or HUSKY_TASK_ID env var
@@ -36,11 +39,86 @@ async function confirm(message) {
         });
     });
 }
+// Helper: Check if current directory is a git repository
+function isGitRepo() {
+    try {
+        execSync("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Helper: Get current Git remote URL (e.g., "simon-sfxecom/huskyv0")
+function getGitRepoIdentifier() {
+    if (!isGitRepo())
+        return null;
+    try {
+        const remoteUrl = execSync("git remote get-url origin", { encoding: "utf-8" }).trim();
+        // Extract owner/repo from various URL formats:
+        // https://github.com/owner/repo.git
+        // git@github.com:owner/repo.git
+        const match = remoteUrl.match(/[/:]([\w-]+\/[\w-]+?)(\.git)?$/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Helper: Create worktree for task when starting (auto-isolation)
+function createWorktreeForTask(taskId) {
+    if (!isGitRepo()) {
+        return null;
+    }
+    try {
+        const sessionName = `task-${taskId.slice(0, 8)}`;
+        const manager = new WorktreeManager(process.cwd());
+        const info = manager.createWorktree(sessionName);
+        return { path: info.path, branch: info.branch };
+    }
+    catch (error) {
+        // Worktree creation failed, but don't block task update
+        console.warn("⚠ Could not create worktree:", error instanceof Error ? error.message : error);
+        return null;
+    }
+}
+// Helper: Find project ID by GitHub repo identifier
+async function findProjectByRepo(apiUrl, apiKey, repoIdentifier) {
+    try {
+        const res = await fetch(`${apiUrl}/api/projects`, {
+            headers: apiKey ? { "x-api-key": apiKey } : {},
+        });
+        if (!res.ok)
+            return null;
+        const projects = await res.json();
+        // Extract repo name (e.g., "huskyv0" from "simon-sfxecom/huskyv0")
+        const repoName = repoIdentifier.split("/").pop()?.toLowerCase() || "";
+        // Try to match by:
+        // 1. githubRepo field (exact or partial match)
+        // 2. Project name similarity to repo name
+        const project = projects.find((p) => {
+            // Check githubRepo field first
+            if (p.githubRepo?.toLowerCase().includes(repoIdentifier.toLowerCase())) {
+                return true;
+            }
+            // Fallback: Check if project name matches repo name (case-insensitive)
+            const projectNameLower = p.name.toLowerCase().replace(/[^a-z0-9]/g, "");
+            const repoNameClean = repoName.replace(/[^a-z0-9]/g, "");
+            return projectNameLower === repoNameClean || projectNameLower.includes(repoNameClean) || repoNameClean.includes(projectNameLower);
+        });
+        return project ? { id: project.id, name: project.name } : null;
+    }
+    catch {
+        return null;
+    }
+}
 // husky task list
 taskCommand
     .command("list")
     .description("List all tasks")
     .option("-s, --status <status>", "Filter by status")
+    .option("-a, --all", "Show all tasks (ignore current repo filter)")
+    .option("--project <id>", "Filter by project ID")
     .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")
@@ -56,13 +134,39 @@ taskCommand
         if (options.status) {
             url.searchParams.set("status", options.status);
         }
+        // Auto-detect project from current repo (unless --all or --project specified)
+        let autoDetectedProject = null;
+        let filterProjectId = null;
+        if (!options.all && !options.project) {
+            const repoIdentifier = getGitRepoIdentifier();
+            if (repoIdentifier) {
+                autoDetectedProject = await findProjectByRepo(config.apiUrl, config.apiKey, repoIdentifier);
+                if (autoDetectedProject) {
+                    filterProjectId = autoDetectedProject.id;
+                }
+            }
+        }
+        else if (options.project) {
+            filterProjectId = options.project;
+        }
+        // Note: We don't pass projectId to API to avoid Firestore index requirement
+        // Instead, we filter client-side which is fine for reasonable task counts
         const res = await fetch(url.toString(), {
             headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
         });
         if (!res.ok) {
             throw new Error(`API error: ${res.status}`);
         }
-        const tasks = await res.json();
+        let tasks = await res.json();
+        // Client-side filtering by projectId (avoids Firestore composite index)
+        if (filterProjectId) {
+            tasks = tasks.filter(t => t.projectId === filterProjectId);
+        }
+        // Show filter info if auto-detected project
+        if (autoDetectedProject && !options.json) {
+            console.log(`\n  📁 Filtering by project: ${autoDetectedProject.name}`);
+            console.log(`     Use --all to see all tasks\n`);
+        }
         // JSON output
         if (options.json) {
             console.log(JSON.stringify(tasks, null, 2));
@@ -73,7 +177,7 @@ taskCommand
             await paginateList({
                 items: tasks,
                 pageSize: 10,
-                title: "Tasks",
+                title: autoDetectedProject ? `Tasks (${autoDetectedProject.name})` : "Tasks",
                 emptyMessage: "No tasks found.",
                 renderItem: (task) => {
                     const statusIcon = task.status === "done" ? "✓" : task.status === "in_progress" ? "▶" : "○";
@@ -124,19 +228,29 @@ taskCommand
         process.exit(1);
     }
     try {
+        // Ensure worker is registered and create a session
+        const workerId = await ensureWorkerRegistered(config.apiUrl, config.apiKey || "");
+        const sessionId = generateSessionId();
+        await registerSession(config.apiUrl, config.apiKey || "", workerId, sessionId);
         const res = await fetch(`${config.apiUrl}/api/tasks/${id}/start`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
                 ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
             },
-            body: JSON.stringify({ agent: "claude-code" }),
+            body: JSON.stringify({
+                agent: "claude-code",
+                workerId,
+                sessionId,
+            }),
         });
         if (!res.ok) {
             throw new Error(`API error: ${res.status}`);
         }
         const task = await res.json();
         console.log(`✓ Started: ${task.title}`);
+        console.log(`  Worker: ${workerId}`);
+        console.log(`  Session: ${sessionId}`);
     }
     catch (error) {
         console.error("Error starting task:", error);
@@ -224,6 +338,7 @@ taskCommand
     .option("--priority <priority>", "New priority (low, medium, high, urgent)")
     .option("--assignee <assignee>", "New assignee (human, llm, unassigned)")
     .option("--project <projectId>", "Link to project")
+    .option("--no-worktree", "Skip automatic worktree creation when starting task")
     .option("--json", "Output as JSON")
     .action(async (id, options) => {
     const config = ensureConfig();
@@ -245,6 +360,15 @@ taskCommand
         console.error("Error: No update options provided. Use --help for available options.");
         process.exit(1);
     }
+    // Auto-create worktree when starting a task (unless --no-worktree)
+    let worktreeInfo = null;
+    if (options.status === "in_progress" && options.worktree !== false) {
+        worktreeInfo = createWorktreeForTask(id);
+        if (worktreeInfo) {
+            updates.worktreePath = worktreeInfo.path;
+            updates.worktreeBranch = worktreeInfo.branch;
+        }
+    }
     try {
         const res = await fetch(`${config.apiUrl}/api/tasks/${id}`, {
             method: "PATCH",
@@ -269,8 +393,13 @@ taskCommand
         }
         else {
             console.log(`✓ Updated: ${task.title}`);
-            const changedFields = Object.keys(updates).join(", ");
+            const changedFields = Object.keys(updates).filter(k => k !== 'worktreePath' && k !== 'worktreeBranch').join(", ");
             console.log(`  Changed: ${changedFields}`);
+            // Show worktree info if created
+            if (worktreeInfo) {
+                console.log(`  ⎇ Worktree: ${worktreeInfo.branch}`);
+                console.log(`    cd ${worktreeInfo.path}`);
+            }
         }
     }
     catch (error) {
@@ -416,6 +545,41 @@ taskCommand
         process.exit(1);
     }
 });
+// husky task message [--id <id>] -m <text>
+taskCommand
+    .command("message")
+    .description("Post a status message to a task")
+    .option("--id <id>", "Task ID (or use HUSKY_TASK_ID env var)")
+    .option("-m, --message <text>", "Status message", "")
+    .action(async (options) => {
+    const config = ensureConfig();
+    const taskId = getTaskId(options);
+    if (!options.message) {
+        console.error("Error: Message required. Use -m or --message");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/tasks/${taskId}/status`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                message: options.message,
+                timestamp: new Date().toISOString(),
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        console.log("✓ Status message posted");
+    }
+    catch (error) {
+        console.error("Error posting message:", error);
+        process.exit(1);
+    }
+});
 // husky task plan [--summary <text>] [--file <path>] [--stdin] [--id <id>]
 taskCommand
     .command("plan")
@@ -915,12 +1079,15 @@ function printTasks(tasks) {
         if (statusTasks.length === 0)
             continue;
         console.log(`\n  ${label}`);
-        console.log("  " + "─".repeat(50));
+        console.log("  " + "─".repeat(85));
+        console.log(`  ${"ID".padEnd(10)}  ${"Title".padEnd(30)}  ${"Project".padEnd(15)}  ${"Project ID".padEnd(12)}  ${"Priority".padEnd(6)}`);
+        console.log("  " + "─".repeat(85));
         for (const task of statusTasks) {
             const agentStr = task.agent ? ` (${task.agent})` : "";
             const doneStr = status === "done" ? " ✓" : "";
-            const projectStr = (task.projectName || task.projectId)?.slice(0, 15).padEnd(15) || "—".padEnd(15);
-            console.log(`  ${task.id.slice(0, 10).padEnd(10)}  ${task.title.slice(0, 25).padEnd(25)}  ${projectStr}  ${task.priority.padEnd(6)}${agentStr}${doneStr}`);
+            const projectName = task.projectName?.slice(0, 15).padEnd(15) || "—".padEnd(15);
+            const projectId = task.projectId?.slice(0, 12).padEnd(12) || "—".padEnd(12);
+            console.log(`  ${task.id.slice(0, 10).padEnd(10)}  ${task.title.slice(0, 30).padEnd(30)}  ${projectName}  ${projectId}  ${task.priority.padEnd(6)}${agentStr}${doneStr}`);
         }
     }
     console.log("");

package/dist/commands/worker.d.ts

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

package/dist/commands/worker.js

@@ -0,0 +1,210 @@
+import { Command } from "commander";
+import { getConfig } from "./config.js";
+import { getWorkerIdentity, ensureWorkerRegistered } from "../lib/worker.js";
+export const workerCommand = new Command("worker")
+    .description("Manage workers and sessions");
+// husky worker whoami - Show current worker identity
+workerCommand
+    .command("whoami")
+    .description("Show current worker identity")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const identity = getWorkerIdentity();
+    if (options.json) {
+        console.log(JSON.stringify(identity, null, 2));
+    }
+    else {
+        console.log("\n  Worker Identity");
+        console.log("  " + "─".repeat(40));
+        console.log(`  ID:       ${identity.workerId}`);
+        console.log(`  Name:     ${identity.workerName}`);
+        console.log(`  Host:     ${identity.hostname}`);
+        console.log(`  User:     ${identity.username}`);
+        console.log(`  Platform: ${identity.platform}`);
+        console.log(`  Version:  ${identity.agentVersion}`);
+        console.log("");
+    }
+});
+// husky worker register - Register worker with API
+workerCommand
+    .command("register")
+    .description("Register this worker with the API")
+    .action(async () => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    try {
+        const workerId = await ensureWorkerRegistered(config.apiUrl, config.apiKey || "");
+        const identity = getWorkerIdentity();
+        console.log(`✓ Worker registered: ${workerId}`);
+        console.log(`  Name: ${identity.workerName}`);
+    }
+    catch (error) {
+        console.error("Error registering worker:", error);
+        process.exit(1);
+    }
+});
+// husky worker list - List all registered workers
+workerCommand
+    .command("list")
+    .description("List all registered workers")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured.");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/workers`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        const workers = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(workers, null, 2));
+            return;
+        }
+        if (workers.length === 0) {
+            console.log("No workers registered.");
+            return;
+        }
+        console.log("\n  Registered Workers");
+        console.log("  " + "─".repeat(60));
+        for (const worker of workers) {
+            const statusIcon = worker.lastSeen && isRecent(worker.lastSeen) ? "🟢" : "⚪";
+            const typeIcon = worker.type === "claude-code" ? "🤖" : "👤";
+            console.log(`  ${statusIcon} ${typeIcon} ${worker.id.slice(0, 12).padEnd(12)} │ ${worker.name?.slice(0, 30).padEnd(30)} │ ${worker.hostname || "—"}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error fetching workers:", error);
+        process.exit(1);
+    }
+});
+// husky worker sessions - List active sessions
+workerCommand
+    .command("sessions")
+    .description("List active worker sessions")
+    .option("--all", "Show all sessions (not just active)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured.");
+        process.exit(1);
+    }
+    try {
+        const endpoint = options.all
+            ? `${config.apiUrl}/api/workers/sessions`
+            : `${config.apiUrl}/api/workers/sessions/active`;
+        const res = await fetch(endpoint, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        const sessions = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(sessions, null, 2));
+            return;
+        }
+        if (sessions.length === 0) {
+            console.log(options.all ? "No sessions found." : "No active sessions.");
+            return;
+        }
+        console.log(`\n  ${options.all ? "All" : "Active"} Sessions`);
+        console.log("  " + "─".repeat(70));
+        for (const session of sessions) {
+            const statusIcon = session.status === "active" ? "🟢" : "⚪";
+            const taskInfo = session.currentTaskId ? `Task: ${session.currentTaskId.slice(0, 8)}` : "No task";
+            const timeAgo = session.lastHeartbeat ? formatTimeAgo(session.lastHeartbeat) : "—";
+            console.log(`  ${statusIcon} ${session.id.slice(0, 12).padEnd(12)} │ ${session.workerId.slice(0, 12).padEnd(12)} │ ${taskInfo.padEnd(20)} │ ${timeAgo}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error fetching sessions:", error);
+        process.exit(1);
+    }
+});
+// husky worker activity - Show who is working on what
+workerCommand
+    .command("activity")
+    .description("Show current activity (who is working on what)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured.");
+        process.exit(1);
+    }
+    try {
+        // Fetch active sessions and in-progress tasks in parallel
+        const [sessionsRes, tasksRes] = await Promise.all([
+            fetch(`${config.apiUrl}/api/workers/sessions/active`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            }),
+            fetch(`${config.apiUrl}/api/tasks?status=in_progress`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            }),
+        ]);
+        if (!sessionsRes.ok || !tasksRes.ok) {
+            throw new Error("API error fetching activity");
+        }
+        const sessions = await sessionsRes.json();
+        const tasks = await tasksRes.json();
+        if (options.json) {
+            console.log(JSON.stringify({ sessions, tasks }, null, 2));
+            return;
+        }
+        console.log("\n  Current Activity");
+        console.log("  " + "═".repeat(70));
+        if (tasks.length === 0) {
+            console.log("  No tasks currently in progress.");
+        }
+        else {
+            for (const task of tasks) {
+                const agentIcon = task.agent?.includes("claude") ? "🤖" : task.agent ? "👤" : "❓";
+                const workerInfo = task.workerId ? `Worker: ${task.workerId.slice(0, 8)}` : "No worker";
+                console.log(`\n  ${agentIcon} ${task.title.slice(0, 50)}`);
+                console.log(`     ID: ${task.id.slice(0, 12)} │ ${task.agent || "unassigned"} │ ${workerInfo}`);
+                if (task.projectName) {
+                    console.log(`     Project: ${task.projectName}`);
+                }
+            }
+        }
+        console.log("\n  " + "─".repeat(70));
+        console.log(`  Active Sessions: ${sessions.length}`);
+        console.log(`  Tasks In Progress: ${tasks.length}`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error fetching activity:", error);
+        process.exit(1);
+    }
+});
+// Helper: Check if timestamp is recent (within 5 minutes)
+function isRecent(timestamp) {
+    const diff = Date.now() - new Date(timestamp).getTime();
+    return diff < 5 * 60 * 1000; // 5 minutes
+}
+// Helper: Format time ago
+function formatTimeAgo(timestamp) {
+    const diff = Date.now() - new Date(timestamp).getTime();
+    const minutes = Math.floor(diff / 60000);
+    const hours = Math.floor(diff / 3600000);
+    const days = Math.floor(diff / 86400000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    if (hours < 24)
+        return `${hours}h ago`;
+    return `${days}d ago`;
+}

package/dist/index.js

@@ -13,17 +13,17 @@ import { workflowCommand } from "./commands/workflow.js";
 import { julesCommand } from "./commands/jules.js";
 import { vmCommand } from "./commands/vm.js";
 import { vmConfigCommand } from "./commands/vm-config.js";
-import { processCommand } from "./commands/process.js";
 import { settingsCommand } from "./commands/settings.js";
 import { strategyCommand } from "./commands/strategy.js";
 import { completionCommand } from "./commands/completion.js";
 import { worktreeCommand } from "./commands/worktree.js";
+import { workerCommand } from "./commands/worker.js";
 import { runInteractiveMode } from "./commands/interactive.js";
 const program = new Command();
 program
     .name("husky")
     .description("CLI for Huskyv0 Task Orchestration with Claude Agent")
-    .version("0.7.1");
+    .version("0.8.1");
 program.addCommand(taskCommand);
 program.addCommand(configCommand);
 program.addCommand(agentCommand);
@@ -37,11 +37,11 @@ program.addCommand(workflowCommand);
 program.addCommand(julesCommand);
 program.addCommand(vmCommand);
 program.addCommand(vmConfigCommand);
-program.addCommand(processCommand);
 program.addCommand(settingsCommand);
 program.addCommand(strategyCommand);
 program.addCommand(completionCommand);
 program.addCommand(worktreeCommand);
+program.addCommand(workerCommand);
 // Check if no command was provided - run interactive mode
 if (process.argv.length <= 2) {
     runInteractiveMode();

package/dist/lib/worker.d.ts

@@ -0,0 +1,14 @@
+interface WorkerIdentity {
+    workerId: string;
+    workerName: string;
+    hostname: string;
+    username: string;
+    platform: string;
+    agentVersion: string;
+}
+export declare function getWorkerIdentity(): WorkerIdentity;
+export declare function generateSessionId(): string;
+export declare function ensureWorkerRegistered(apiUrl: string, apiKey: string): Promise<string>;
+export declare function registerSession(apiUrl: string, apiKey: string, workerId: string, sessionId: string): Promise<void>;
+export declare function sessionHeartbeat(apiUrl: string, apiKey: string, sessionId: string, currentTaskId?: string | null): Promise<void>;
+export {};

package/dist/lib/worker.js

@@ -0,0 +1,113 @@
+import { getConfig, setConfig } from "../commands/config.js";
+import { hostname, userInfo, platform } from "os";
+import { randomUUID } from "crypto";
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+// Get or generate persistent worker identity (stored in ~/.husky/config.json)
+export function getWorkerIdentity() {
+    const config = getConfig();
+    // Generate worker ID if not exists
+    if (!config.workerId) {
+        const newId = `cli-${randomUUID().slice(0, 8)}`;
+        setConfig("workerId", newId);
+        config.workerId = newId;
+    }
+    // Generate worker name if not exists
+    if (!config.workerName) {
+        const name = `Claude Code @ ${hostname()}`;
+        setConfig("workerName", name);
+        config.workerName = name;
+    }
+    // Get agent version from package.json
+    let agentVersion = "unknown";
+    try {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf-8"));
+        agentVersion = pkg.version;
+    }
+    catch {
+        // Ignore errors reading package.json
+    }
+    return {
+        workerId: config.workerId,
+        workerName: config.workerName,
+        hostname: hostname(),
+        username: userInfo().username,
+        platform: platform(),
+        agentVersion,
+    };
+}
+// Generate a unique session ID for this CLI instance
+export function generateSessionId() {
+    return `sess-${randomUUID().slice(0, 8)}`;
+}
+// Register or update worker with API, return workerId
+export async function ensureWorkerRegistered(apiUrl, apiKey) {
+    const identity = getWorkerIdentity();
+    // Try to get existing worker
+    const getRes = await fetch(`${apiUrl}/api/workers/${identity.workerId}`, {
+        headers: { "x-api-key": apiKey },
+    });
+    if (getRes.ok) {
+        // Worker exists, just return the ID
+        return identity.workerId;
+    }
+    if (getRes.status === 404) {
+        // Register new worker
+        const registerRes = await fetch(`${apiUrl}/api/workers`, {
+            method: "POST",
+            headers: { "x-api-key": apiKey, "Content-Type": "application/json" },
+            body: JSON.stringify({
+                name: identity.workerName,
+                type: "claude-code",
+                hostname: identity.hostname,
+                username: identity.username,
+                platform: identity.platform,
+                agentVersion: identity.agentVersion,
+            }),
+        });
+        if (!registerRes.ok) {
+            console.error(`Warning: Failed to register worker: ${registerRes.status}`);
+            return identity.workerId;
+        }
+        const worker = await registerRes.json();
+        // Update local config with server-assigned ID if different
+        if (worker.id !== identity.workerId) {
+            setConfig("workerId", worker.id);
+            return worker.id;
+        }
+    }
+    return identity.workerId;
+}
+// Register a new session with API
+export async function registerSession(apiUrl, apiKey, workerId, sessionId) {
+    try {
+        await fetch(`${apiUrl}/api/workers/sessions`, {
+            method: "POST",
+            headers: { "x-api-key": apiKey, "Content-Type": "application/json" },
+            body: JSON.stringify({
+                id: sessionId,
+                workerId,
+                pid: process.pid,
+                workingDirectory: process.cwd(),
+            }),
+        });
+    }
+    catch {
+        // Silently fail - session registration is optional
+    }
+}
+// Send session heartbeat
+export async function sessionHeartbeat(apiUrl, apiKey, sessionId, currentTaskId) {
+    try {
+        await fetch(`${apiUrl}/api/workers/sessions/${sessionId}/heartbeat`, {
+            method: "POST",
+            headers: { "x-api-key": apiKey, "Content-Type": "application/json" },
+            body: JSON.stringify({ currentTaskId }),
+        });
+    }
+    catch {
+        // Silently fail
+    }
+}

package/package.json

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