@vectorplane/ctrl-cli 0.1.11 → 0.1.13

package/dist/commands/task.js

@@ -0,0 +1,544 @@
+import { getBooleanOption, getStringOption, parseArgs, requirePositional } from "../core/cli.js";
+import { ensureSessionAvailable, getProfileState } from "../core/config.js";
+import { collectGitContext } from "../core/git.js";
+import { collectMachineContext, collectRuntimeContext } from "../core/machine.js";
+import { loadRuntimeStatus } from "../core/runtime.js";
+import { ensureFreshSession, resolveWorkspaceSlug } from "../core/session.js";
+import { VectorPlaneApiClient } from "../core/api.js";
+import { getBoundWorkspace, resolveWorkspaceRoot } from "../core/workspace-binding.js";
+import { ValidationError } from "../core/errors.js";
+import { executeLocalTaskStep } from "../core/task-runner.js";
+async function resolveAuthenticatedWorkspace(cliVersion, rawArgs) {
+    const runtime = await loadRuntimeStatus();
+    const session = await ensureSessionAvailable(runtime.profile.name);
+    const parsed = parseArgs(rawArgs);
+    const [git, machine, runtimeContext] = await Promise.all([
+        collectGitContext(process.cwd()),
+        collectMachineContext(runtime.device, runtime.config),
+        collectRuntimeContext(cliVersion, "task", process.argv.slice(2)),
+    ]);
+    const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
+    const freshSession = await ensureFreshSession({
+        profileName: runtime.profile.name,
+        session,
+        machine,
+        runtime: runtimeContext,
+        device: runtime.device,
+        apiClient,
+        logger: runtime.logger,
+    });
+    const rootPath = resolveWorkspaceRoot(process.cwd(), git);
+    const boundWorkspace = await getBoundWorkspace(rootPath);
+    const profileState = getProfileState(runtime.state, runtime.profile.name);
+    const workspace = resolveWorkspaceSlug(runtime.profile, freshSession, getStringOption(parsed, "workspace"), boundWorkspace, profileState.lastWorkspace);
+    if (!workspace) {
+        throw new ValidationError("Nenhum workspace resolvido para operar tasks.");
+    }
+    return { parsed, runtime, apiClient, freshSession, git, workspace, rootPath, profileState };
+}
+async function resolveAuthenticatedApi(cliVersion, rawArgs) {
+    const runtime = await loadRuntimeStatus();
+    const session = await ensureSessionAvailable(runtime.profile.name);
+    const [machine, runtimeContext] = await Promise.all([
+        collectMachineContext(runtime.device, runtime.config),
+        collectRuntimeContext(cliVersion, "task", process.argv.slice(2)),
+    ]);
+    const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
+    const freshSession = await ensureFreshSession({
+        profileName: runtime.profile.name,
+        session,
+        machine,
+        runtime: runtimeContext,
+        device: runtime.device,
+        apiClient,
+        logger: runtime.logger,
+    });
+    return { parsed: parseArgs(rawArgs), runtime, apiClient, freshSession };
+}
+function printTask(task) {
+    process.stdout.write(`Task: ${task.id}\n`);
+    process.stdout.write(`Título: ${task.title}\n`);
+    process.stdout.write(`Status: ${task.status}\n`);
+    process.stdout.write(`Risk: ${task.riskLevel} (${task.riskScore})\n`);
+    process.stdout.write(`Policy: ${task.policyStatus}\n`);
+    process.stdout.write(`Conflict: ${task.conflictStatus}\n`);
+    if (task.requiresApproval && !task.approvedBy) {
+        process.stdout.write("Approval: pendente\n");
+    }
+    else if (task.approvedBy) {
+        process.stdout.write(`Approval: aprovado por ${task.approvedBy}\n`);
+    }
+    const approvalTrail = (task.handoffs ?? []).filter((handoff) => handoff.title === "Task approved" || handoff.title === "Approval rejected");
+    if (approvalTrail.length > 0) {
+        const latest = approvalTrail[approvalTrail.length - 1];
+        const rationale = typeof latest.summary?.rationale === "string" ? latest.summary.rationale : null;
+        const approvedBy = typeof latest.summary?.approvedBy === "string" ? latest.summary.approvedBy : null;
+        process.stdout.write(`Última decisão: ${latest.title} em ${latest.createdAt}\n`);
+        if (approvedBy) {
+            process.stdout.write(`Decisor: ${approvedBy}\n`);
+        }
+        if (rationale) {
+            process.stdout.write(`Rationale: ${rationale}\n`);
+        }
+    }
+    if (task.recommendedApproach) {
+        process.stdout.write(`Approach: ${task.recommendedApproach}\n`);
+    }
+    for (const step of task.steps) {
+        process.stdout.write(`- ${step.order}. ${step.name} | ${step.capability} | ${step.status}`);
+        if (step.assignedAgentName) {
+            process.stdout.write(` | ${step.assignedAgentName}`);
+        }
+        process.stdout.write("\n");
+    }
+}
+function printJsonIfRequested(parsed, payload) {
+    if (!getBooleanOption(parsed, "json")) {
+        return false;
+    }
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return true;
+}
+function printClaimableStep(step) {
+    process.stdout.write(`Task: ${step.taskId} | ${step.taskTitle}\n`);
+    process.stdout.write(`Step: ${step.stepId} | ${step.stepName}\n`);
+    process.stdout.write(`Capability: ${step.capability}\n`);
+    process.stdout.write(`Agent: ${step.assignedAgentName} (${step.assignedAgentId})\n`);
+    process.stdout.write(`Status: ${step.status}\n`);
+}
+function printTaskTemplate(template) {
+    process.stdout.write(`${template.slug} | ${template.name} | ${template.defaultCapabilities.join(", ")}`);
+    if (template.archetypeScope) {
+        process.stdout.write(` | archetype=${template.archetypeScope}`);
+    }
+    process.stdout.write("\n");
+}
+function printHandoff(handoff) {
+    process.stdout.write(`Task: ${handoff.taskId}\n`);
+    process.stdout.write(`Título: ${handoff.title}\n`);
+    process.stdout.write(`Status: ${handoff.status}\n`);
+    if (handoff.currentTitle) {
+        process.stdout.write(`Handoff: ${handoff.currentTitle}\n`);
+    }
+    if (handoff.nextSteps?.length) {
+        process.stdout.write(`Próximos passos: ${handoff.nextSteps.join(" | ")}\n`);
+    }
+    if (handoff.risks?.length) {
+        process.stdout.write(`Riscos: ${handoff.risks.join(" | ")}\n`);
+    }
+    if (handoff.memoryLanes?.length) {
+        process.stdout.write(`Lanes de memória: ${handoff.memoryLanes.join(", ")}\n`);
+    }
+}
+function printObservability(payload) {
+    if (payload.taskId) {
+        process.stdout.write(`Task: ${payload.taskId}\n`);
+        if (payload.status) {
+            process.stdout.write(`Status: ${String(payload.status)}\n`);
+        }
+        if (typeof payload.durationMs === "number") {
+            process.stdout.write(`Duração: ${payload.durationMs} ms\n`);
+        }
+        if (typeof payload.delegationCount === "number") {
+            process.stdout.write(`Delegações: ${payload.delegationCount}\n`);
+        }
+        if (Array.isArray(payload.steps)) {
+            for (const step of payload.steps) {
+                process.stdout.write(`- ${String(step.order ?? "?")}. ${String(step.name ?? "step")} | ${String(step.status ?? "unknown")} | attempts=${String(step.attempts ?? 0)}\n`);
+            }
+        }
+        return;
+    }
+    process.stdout.write(`Workspace: ${payload.workspaceId}\n`);
+    process.stdout.write(`Tasks: ${String(payload.totalTasks ?? 0)}\n`);
+    process.stdout.write(`Concluídas: ${String(payload.completedTasks ?? 0)}\n`);
+    process.stdout.write(`Falhas: ${String(payload.failedTasks ?? 0)}\n`);
+    process.stdout.write(`Bloqueadas: ${String(payload.blockedTasks ?? 0)}\n`);
+    process.stdout.write(`Delegadas: ${String(payload.delegatedTasks ?? 0)}\n`);
+    process.stdout.write(`Success rate: ${String(payload.successRate ?? 0)}\n`);
+}
+function printWatchEvent(event) {
+    const scope = event.taskId ? `task=${event.taskId}` : `workspace=${event.workspaceId}`;
+    const step = event.stepId ? ` step=${event.stepId}` : "";
+    const summary = event.summary ? ` ${JSON.stringify(event.summary)}` : "";
+    process.stdout.write(`[${event.timestamp}] ${event.type} ${scope}${step}${summary}\n`);
+}
+async function runTaskList(cliVersion, args) {
+    const { parsed, apiClient, freshSession, workspace } = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const tasks = await apiClient.listTasks(freshSession.accessToken, workspace);
+    if (printJsonIfRequested(parsed, tasks)) {
+        return 0;
+    }
+    if (tasks.length === 0) {
+        process.stdout.write("VectorPlane: nenhuma task encontrada.\n");
+        return 0;
+    }
+    for (const task of tasks) {
+        const approvalMarker = task.requiresApproval && !task.approvedBy ? " | [APPROVAL REQUIRED]" : "";
+        process.stdout.write(`${task.id} | ${task.status} | ${task.riskLevel} | ${task.title}${approvalMarker}\n`);
+    }
+    return 0;
+}
+async function runTaskRun(cliVersion, args) {
+    const { parsed, apiClient, freshSession, git, workspace, runtime } = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const title = getStringOption(parsed, "title")?.trim();
+    const intention = getStringOption(parsed, "intention")?.trim() ?? getStringOption(parsed, "prompt")?.trim();
+    if (!title || !intention) {
+        throw new ValidationError("Informe `--title` e `--intention`.");
+    }
+    const capabilityRaw = getStringOption(parsed, "capability");
+    const pathRaw = getStringOption(parsed, "path");
+    const payload = {
+        title,
+        intention,
+        templateSlug: getStringOption(parsed, "template")?.trim() || undefined,
+        requestedCapabilities: capabilityRaw ? capabilityRaw.split(",").map((value) => value.trim()).filter(Boolean) : undefined,
+        targetPaths: pathRaw ? pathRaw.split(",").map((value) => value.trim()).filter(Boolean) : undefined,
+        featureKey: getStringOption(parsed, "feature")?.trim() || undefined,
+        taskKey: getStringOption(parsed, "task")?.trim() || undefined,
+    };
+    if (!payload.targetPaths && git.branch) {
+        payload.targetPaths = [];
+    }
+    const task = await apiClient.createTask(freshSession.accessToken, workspace, payload);
+    runtime.logger.success("task enviada ao orchestrator.");
+    printTask(task);
+    return 0;
+}
+async function runTaskTemplates(cliVersion, args) {
+    const { parsed, apiClient, freshSession } = await resolveAuthenticatedApi(cliVersion, args);
+    const templates = await apiClient.listTaskTemplates(freshSession.accessToken);
+    if (printJsonIfRequested(parsed, templates)) {
+        return 0;
+    }
+    if (templates.length === 0) {
+        process.stdout.write("VectorPlane: nenhum template cadastrado.\n");
+        return 0;
+    }
+    for (const template of templates) {
+        printTaskTemplate(template);
+    }
+    return 0;
+}
+async function runTaskInspect(cliVersion, args) {
+    const { apiClient, freshSession, workspace } = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const parsed = parseArgs(args);
+    const taskId = requirePositional(parsed, 0, "Uso: vp task inspect <taskId>");
+    const task = await apiClient.getTask(freshSession.accessToken, workspace, taskId);
+    if (!printJsonIfRequested(parsed, task)) {
+        printTask(task);
+    }
+    return 0;
+}
+async function resolveTaskClaimContext(cliVersion, args) {
+    const context = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const agentName = getStringOption(context.parsed, "agent-name")?.trim() || "vp-cli";
+    const clientInstanceId = getStringOption(context.parsed, "client-instance-id")?.trim();
+    return { ...context, agentName, clientInstanceId: clientInstanceId || undefined };
+}
+async function runTaskClaim(cliVersion, args) {
+    const { parsed, apiClient, freshSession, workspace, runtime, profileState, agentName, clientInstanceId } = await resolveTaskClaimContext(cliVersion, args);
+    const capability = getStringOption(parsed, "capability")?.trim();
+    if (!capability) {
+        throw new ValidationError("Informe `--capability` para buscar um step claimable.");
+    }
+    const claimables = await apiClient.listClaimableTaskSteps(freshSession.accessToken, workspace, {
+        capability,
+        agentName,
+    });
+    if (claimables.length === 0) {
+        runtime.logger.info("nenhum step claimable encontrado.");
+        return 0;
+    }
+    const selected = claimables[0];
+    const claimed = await apiClient.claimTaskStep(freshSession.accessToken, workspace, selected.taskId, selected.stepId, {
+        sessionId: profileState.lastSessionId ?? undefined,
+        clientInstanceId,
+        agentName,
+    });
+    runtime.logger.success("step claimado pelo agente CLI.");
+    if (!printJsonIfRequested(parsed, claimed)) {
+        printClaimableStep(claimed.claim);
+    }
+    return 0;
+}
+async function runTaskExecute(cliVersion, args) {
+    const { parsed, apiClient, freshSession, workspace, runtime, rootPath, profileState, agentName, clientInstanceId } = await resolveTaskClaimContext(cliVersion, args);
+    const taskId = requirePositional(parsed, 0, "Uso: vp task execute <taskId> --step <stepId> [--json]");
+    const stepId = getStringOption(parsed, "step");
+    if (!stepId) {
+        throw new ValidationError("Informe `--step`.");
+    }
+    const task = await apiClient.getTask(freshSession.accessToken, workspace, taskId);
+    const step = task.steps.find((item) => item.id === stepId);
+    if (!step) {
+        throw new ValidationError("Step não encontrado para a task informada.");
+    }
+    if (step.status !== "claimed" && step.status !== "pending_claim" && step.status !== "running") {
+        throw new ValidationError("O step informado não está disponível para execução local.");
+    }
+    const claim = step.status === "pending_claim"
+        ? (await apiClient.claimTaskStep(freshSession.accessToken, workspace, taskId, stepId, {
+            sessionId: profileState.lastSessionId ?? undefined,
+            clientInstanceId,
+            agentName,
+        })).claim
+        : {
+            workspaceId: workspace,
+            taskId,
+            taskTitle: task.title,
+            stepId,
+            stepName: step.name,
+            capability: step.capability,
+            status: step.status,
+            assignedAgentId: String(step.assignedAgentId ?? ""),
+            assignedAgentName: String(step.assignedAgentName ?? ""),
+            execution: step.output && typeof step.output === "object" && "execution" in step.output
+                ? step.output.execution
+                : null,
+            createdAt: task.createdAt ?? new Date().toISOString(),
+            updatedAt: task.updatedAt ?? new Date().toISOString(),
+        };
+    await apiClient.callbackTaskStep(freshSession.accessToken, workspace, taskId, stepId, {
+        status: "running",
+        agentId: claim.assignedAgentId || undefined,
+        output: {
+            executionMode: "cli_command",
+            startedBy: "vp task execute",
+        },
+    });
+    const result = await executeLocalTaskStep({
+        execution: claim.execution,
+        workspaceRoot: rootPath,
+        workspaceRef: workspace,
+        taskId,
+        stepId,
+        capability: step.capability,
+    });
+    const callbackPayload = result.exitCode === 0
+        ? {
+            status: "completed",
+            agentId: claim.assignedAgentId || undefined,
+            output: {
+                executionMode: "cli_command",
+                command: result.command,
+                args: result.args,
+                cwd: result.cwd,
+                exitCode: result.exitCode,
+                stdout: result.stdout || null,
+                stderr: result.stderr || null,
+            },
+        }
+        : {
+            status: "failed",
+            agentId: claim.assignedAgentId || undefined,
+            output: {
+                executionMode: "cli_command",
+                command: result.command,
+                args: result.args,
+                cwd: result.cwd,
+                exitCode: result.exitCode,
+                stdout: result.stdout || null,
+                stderr: result.stderr || null,
+            },
+            error: result.stderr || `Comando finalizou com exit code ${result.exitCode}.`,
+        };
+    const updatedTask = await apiClient.callbackTaskStep(freshSession.accessToken, workspace, taskId, stepId, callbackPayload);
+    runtime.logger.success(callbackPayload.status === "completed" ? "step executado com sucesso." : "step executado com falha.");
+    if (!printJsonIfRequested(parsed, updatedTask)) {
+        printTask(updatedTask);
+    }
+    return callbackPayload.status === "completed" ? 0 : 1;
+}
+async function runTaskDaemon(cliVersion, args) {
+    const { parsed, apiClient, freshSession, workspace, runtime, profileState, agentName, clientInstanceId } = await resolveTaskClaimContext(cliVersion, args);
+    const capability = getStringOption(parsed, "capability")?.trim();
+    if (!capability) {
+        throw new ValidationError("Informe `--capability`.");
+    }
+    const maxSteps = Number(getStringOption(parsed, "max-steps") ?? "10");
+    let processed = 0;
+    while (processed < maxSteps) {
+        const claimables = await apiClient.listClaimableTaskSteps(freshSession.accessToken, workspace, { capability, agentName });
+        if (claimables.length === 0) {
+            break;
+        }
+        const selected = claimables[0];
+        await apiClient.claimTaskStep(freshSession.accessToken, workspace, selected.taskId, selected.stepId, {
+            sessionId: profileState.lastSessionId ?? undefined,
+            clientInstanceId,
+            agentName,
+        });
+        const exitCode = await runTaskExecute(cliVersion, [selected.taskId, "--step", selected.stepId, "--agent-name", agentName]);
+        processed += 1;
+        if (exitCode !== 0) {
+            return exitCode;
+        }
+    }
+    runtime.logger.success(`daemon finalizado após ${processed} step(s).`);
+    return 0;
+}
+async function runTaskDelegate(cliVersion, args) {
+    const { apiClient, freshSession, workspace, runtime } = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const parsed = parseArgs(args);
+    const taskId = requirePositional(parsed, 0, "Uso: vp task delegate <taskId> --step <stepId> --agent-id <agentId> --reason <texto>");
+    const stepId = getStringOption(parsed, "step");
+    const agentId = getStringOption(parsed, "agent-id");
+    const reason = getStringOption(parsed, "reason");
+    if (!stepId || !agentId || !reason) {
+        throw new ValidationError("Informe `--step`, `--agent-id` e `--reason`.");
+    }
+    const task = await apiClient.delegateTask(freshSession.accessToken, workspace, taskId, stepId, agentId, reason);
+    runtime.logger.success("delegação registrada.");
+    if (!printJsonIfRequested(parsed, task)) {
+        printTask(task);
+    }
+    return 0;
+}
+async function runTaskStepUpdate(cliVersion, args) {
+    const { apiClient, freshSession, workspace, runtime } = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const parsed = parseArgs(args);
+    const taskId = requirePositional(parsed, 0, "Uso: vp task step-update <taskId> --step <stepId> --status <status>");
+    const stepId = getStringOption(parsed, "step");
+    const status = getStringOption(parsed, "status");
+    if (!stepId || !status) {
+        throw new ValidationError("Informe `--step` e `--status`.");
+    }
+    const output = getStringOption(parsed, "output");
+    const error = getStringOption(parsed, "error");
+    const task = await apiClient.callbackTaskStep(freshSession.accessToken, workspace, taskId, stepId, {
+        status,
+        output: output ? JSON.parse(output) : undefined,
+        error: error ?? undefined,
+    });
+    runtime.logger.success("estado do step atualizado.");
+    if (!printJsonIfRequested(parsed, task)) {
+        printTask(task);
+    }
+    return 0;
+}
+async function runTaskHandoff(cliVersion, args) {
+    const { apiClient, freshSession, workspace } = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const parsed = parseArgs(args);
+    const taskId = requirePositional(parsed, 0, "Uso: vp task handoff <taskId>");
+    const handoff = await apiClient.getTaskHandoff(freshSession.accessToken, workspace, taskId);
+    if (!printJsonIfRequested(parsed, handoff)) {
+        printHandoff(handoff);
+    }
+    return 0;
+}
+async function runTaskObservability(cliVersion, args) {
+    const { apiClient, freshSession, workspace } = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const parsed = parseArgs(args);
+    const taskId = getStringOption(parsed, "task");
+    const payload = taskId
+        ? await apiClient.getTaskObservability(freshSession.accessToken, workspace, taskId)
+        : await apiClient.getWorkspaceTaskObservability(freshSession.accessToken, workspace);
+    if (!printJsonIfRequested(parsed, payload)) {
+        printObservability(payload);
+    }
+    return 0;
+}
+async function runTaskWatch(cliVersion, args) {
+    const { apiClient, freshSession, workspace } = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const parsed = parseArgs(args);
+    const taskId = requirePositional(parsed, 0, "Uso: vp task watch <taskId> [--json]");
+    const task = await apiClient.getTask(freshSession.accessToken, workspace, taskId);
+    if (printJsonIfRequested(parsed, task)) {
+        return 0;
+    }
+    printTask(task);
+    const controller = new AbortController();
+    let exitCode = 0;
+    await apiClient.streamWorkspaceEvents(freshSession.accessToken, workspace, {
+        taskId,
+        signal: controller.signal,
+        onEvent: (event) => {
+            if (event.type === "ready" || event.type === "heartbeat") {
+                return;
+            }
+            printWatchEvent(event);
+            if (event.type === "task.failed" || event.type === "task.blocked") {
+                exitCode = 1;
+            }
+            if (event.type === "task.completed" || event.type === "task.failed" || event.type === "task.blocked") {
+                controller.abort();
+            }
+        },
+    }).catch((error) => {
+        if (controller.signal.aborted) {
+            return;
+        }
+        throw error;
+    });
+    return exitCode;
+}
+async function runTaskHealth(cliVersion, args) {
+    const { apiClient, freshSession, workspace } = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const parsed = parseArgs(args);
+    const payload = await apiClient.getWorkspaceHealth(freshSession.accessToken, workspace);
+    if (!printJsonIfRequested(parsed, payload)) {
+        process.stdout.write(`Workspace: ${workspace}\n`);
+        process.stdout.write(`Health score: ${String(payload.healthScore ?? payload.health_score ?? "n/a")}\n`);
+        process.stdout.write(`Risk level: ${String(payload.riskLevel ?? payload.risk_level ?? "n/a")}\n`);
+    }
+    return 0;
+}
+async function runTaskApproval(cliVersion, args, approved) {
+    const { apiClient, freshSession, workspace, runtime } = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const parsed = parseArgs(args);
+    const taskId = requirePositional(parsed, 0, approved ? "Uso: vp task approve <taskId> [--rationale <texto>]" : "Uso: vp task reject <taskId> --rationale <texto>");
+    const rationale = getStringOption(parsed, "rationale")?.trim();
+    if (!approved && !rationale) {
+        throw new ValidationError("Informe `--rationale` ao rejeitar uma task.");
+    }
+    const task = await apiClient.approveTask(freshSession.accessToken, workspace, taskId, {
+        approved,
+        approvedBy: runtime.profile.name,
+        rationale: rationale || undefined,
+    });
+    runtime.logger.success(approved ? "aprovação registrada." : "rejeição registrada.");
+    if (!printJsonIfRequested(parsed, task)) {
+        printTask(task);
+    }
+    return 0;
+}
+export async function runTaskCommand(cliVersion, args) {
+    const parsed = parseArgs(args);
+    const subcommand = requirePositional(parsed, 0, "Uso: vp task <run|templates|list|inspect|watch|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health> [...]");
+    switch (subcommand) {
+        case "run":
+            return runTaskRun(cliVersion, args.slice(1));
+        case "templates":
+            return runTaskTemplates(cliVersion, args.slice(1));
+        case "list":
+            return runTaskList(cliVersion, args.slice(1));
+        case "inspect":
+            return runTaskInspect(cliVersion, args.slice(1));
+        case "watch":
+            return runTaskWatch(cliVersion, args.slice(1));
+        case "claim":
+            return runTaskClaim(cliVersion, args.slice(1));
+        case "execute":
+            return runTaskExecute(cliVersion, args.slice(1));
+        case "daemon":
+            return runTaskDaemon(cliVersion, args.slice(1));
+        case "approve":
+            return runTaskApproval(cliVersion, args.slice(1), true);
+        case "reject":
+            return runTaskApproval(cliVersion, args.slice(1), false);
+        case "delegate":
+            return runTaskDelegate(cliVersion, args.slice(1));
+        case "step-update":
+            return runTaskStepUpdate(cliVersion, args.slice(1));
+        case "handoff":
+            return runTaskHandoff(cliVersion, args.slice(1));
+        case "observability":
+            return runTaskObservability(cliVersion, args.slice(1));
+        case "health":
+            return runTaskHealth(cliVersion, args.slice(1));
+        default:
+            throw new ValidationError("Uso: vp task <run|templates|list|inspect|watch|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health> [...]");
+    }
+}
+//# sourceMappingURL=task.js.map