@controlvector/cv-agent 1.5.0 → 1.7.0

package/dist/bundle.cjs

@@ -3036,8 +3036,11 @@ var {
   Help
 } = import_index.default;
 
-// src/commands/agent.ts
-var import_node_child_process4 = require("node:child_process");
+// src/commands/setup.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_os2 = require("node:os");
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -3630,6 +3633,210 @@ function cleanMachineName(name) {
   return name.trim().toLowerCase().replace(/\s+/g, "-");
 }
 
+// src/commands/setup.ts
+var SHARED_CRED_DIR = (0, import_node_path.join)((0, import_node_os2.homedir)(), ".config", "controlvector");
+var SHARED_CRED_PATH = (0, import_node_path.join)(SHARED_CRED_DIR, "credentials.json");
+function readSharedCreds() {
+  try {
+    const data = JSON.parse((0, import_node_fs.readFileSync)(SHARED_CRED_PATH, "utf-8"));
+    if (data.token && data.hub_url) return data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeSharedCreds(creds) {
+  (0, import_node_fs.mkdirSync)(SHARED_CRED_DIR, { recursive: true });
+  (0, import_node_fs.writeFileSync)(SHARED_CRED_PATH, JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
+}
+async function validateToken(hubUrl, token) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const res = await fetch(`${hubUrl}/api/auth/me`, {
+      headers: { Authorization: `Bearer ${token}` },
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.user?.username || data.user?.email || "unknown";
+  } catch {
+    return null;
+  }
+}
+function checkBinary(cmd) {
+  try {
+    return (0, import_node_child_process.execSync)(`${cmd} 2>&1`, { encoding: "utf8", timeout: 5e3 }).trim().split("\n")[0];
+  } catch {
+    return null;
+  }
+}
+async function runSetup() {
+  const hubUrl = "https://api.hub.controlvector.io";
+  const appUrl = "https://hub.controlvector.io";
+  console.log();
+  console.log(source_default.bold("  CV-Agent Setup"));
+  console.log();
+  console.log("  Checking environment...");
+  const nodeVersion = checkBinary("node --version");
+  const gitVersion = checkBinary("git --version");
+  const claudeVersion = checkBinary("claude --version");
+  console.log(`    ${nodeVersion ? source_default.green("\u2713") : source_default.red("\u2717")} Node.js ${nodeVersion || "\u2014 not found"}`);
+  console.log(`    ${gitVersion ? source_default.green("\u2713") : source_default.red("\u2717")} Git ${gitVersion || "\u2014 not found"}`);
+  console.log(`    ${claudeVersion ? source_default.green("\u2713") : source_default.red("\u2717")} Claude Code ${claudeVersion || "\u2014 not found"}`);
+  console.log();
+  if (!nodeVersion || !gitVersion) {
+    if (!nodeVersion) console.log(source_default.red("  Node.js required: https://nodejs.org"));
+    if (!gitVersion) console.log(source_default.red("  Git required: https://git-scm.com"));
+    process.exit(1);
+  }
+  if (!claudeVersion) {
+    console.log(source_default.yellow("  Claude Code not found. Install with:"));
+    console.log(source_default.cyan("    npm install -g @anthropic-ai/claude-code"));
+    console.log();
+    console.log(source_default.gray("  Continuing setup \u2014 you can install Claude Code later."));
+    console.log();
+  }
+  let username;
+  let token;
+  const shared = readSharedCreds();
+  if (shared) {
+    const user = await validateToken(shared.hub_url, shared.token);
+    if (user) {
+      username = user;
+      token = shared.token;
+      console.log(source_default.green("  \u2713") + ` Authenticated as ${source_default.bold(user)}`);
+    }
+  }
+  if (!token) {
+    const creds = await readCredentials();
+    if (creds.CV_HUB_PAT) {
+      const user = await validateToken(hubUrl, creds.CV_HUB_PAT);
+      if (user) {
+        username = user;
+        token = creds.CV_HUB_PAT;
+        console.log(source_default.green("  \u2713") + ` Authenticated as ${source_default.bold(user)} (from cv-hub credentials)`);
+        writeSharedCreds({ hub_url: hubUrl, token, username, created_at: (/* @__PURE__ */ new Date()).toISOString() });
+      }
+    }
+  }
+  if (!token) {
+    console.log("  Let's connect you to CV-Hub.");
+    console.log();
+    const autoName = `${(0, import_node_os2.hostname)()}-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`;
+    const tokenUrl = `${appUrl}/settings/tokens/new?name=${encodeURIComponent(autoName)}&scopes=agent,repo`;
+    console.log(source_default.gray(`  Opening: ${tokenUrl}`));
+    try {
+      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      (0, import_node_child_process.execSync)(`${openCmd} "${tokenUrl}" 2>/dev/null`, { timeout: 5e3 });
+    } catch {
+      console.log(source_default.gray("  (Could not open browser \u2014 copy the URL above)"));
+    }
+    console.log();
+    const readline = await import("node:readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    token = await new Promise((resolve) => {
+      rl.question("  Paste your token here: ", (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+    if (!token) {
+      console.log(source_default.red("  No token provided. Run cva setup again."));
+      process.exit(1);
+    }
+    const user = await validateToken(hubUrl, token);
+    if (!user) {
+      console.log(source_default.red("  Token validation failed. Check your token and try again."));
+      process.exit(1);
+    }
+    username = user;
+    console.log(source_default.green("  \u2713") + ` Authenticated as ${source_default.bold(user)}`);
+    writeSharedCreds({ hub_url: hubUrl, token, username, created_at: (/* @__PURE__ */ new Date()).toISOString() });
+    await writeCredentialField("CV_HUB_PAT", token);
+    await writeCredentialField("CV_HUB_API", hubUrl);
+  }
+  console.log();
+  console.log("  Claude.ai MCP connector:");
+  const mcpUrl = `https://claude.ai/settings/integrations?add_mcp=${encodeURIComponent(`${hubUrl}/mcp`)}`;
+  console.log(source_default.gray(`  To connect Claude.ai to CV-Hub, visit:`));
+  console.log(source_default.cyan(`    ${mcpUrl}`));
+  console.log();
+  console.log(source_default.gray('  Click "Add Integration" \u2192 "Allow" when prompted.'));
+  console.log(source_default.gray("  (You can do this later \u2014 setup will continue.)"));
+  console.log();
+  const cwd = process.cwd();
+  const isGitRepo = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".git"));
+  const hasCVDir = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".cv"));
+  const hasClaudeMd = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "CLAUDE.md"));
+  const repoName = (0, import_node_path.basename)(cwd);
+  if (isGitRepo) {
+    console.log(source_default.green("  \u2713") + ` Git repo found: ${repoName}`);
+  } else {
+    console.log("  Initializing git repository...");
+    (0, import_node_child_process.execSync)("git init && git checkout -b main", { cwd, stdio: "pipe" });
+    console.log(source_default.green("  \u2713") + " Git repo initialized");
+  }
+  if (!hasClaudeMd) {
+    const template = `# ${repoName}
+
+## Overview
+[Describe your project here]
+
+## Tech Stack
+[What languages/frameworks does this project use?]
+
+## Build & Run
+[How to build and run this project]
+`;
+    (0, import_node_fs.writeFileSync)((0, import_node_path.join)(cwd, "CLAUDE.md"), template);
+    console.log(source_default.green("  \u2713") + " CLAUDE.md created");
+  } else {
+    console.log(source_default.green("  \u2713") + " CLAUDE.md present");
+  }
+  if (!hasCVDir) {
+    (0, import_node_fs.mkdirSync)((0, import_node_path.join)(cwd, ".cv"), { recursive: true });
+  }
+  if (token && username) {
+    const gitHost = "git.hub.controlvector.io";
+    const remoteUrl = `https://${gitHost}/${username}/${repoName}.git`;
+    try {
+      const existingRemote = (0, import_node_child_process.execSync)('git remote get-url cv-hub 2>/dev/null || echo ""', { cwd, encoding: "utf8" }).trim();
+      if (!existingRemote) {
+        (0, import_node_child_process.execSync)(`git remote add cv-hub ${remoteUrl}`, { cwd, stdio: "pipe" });
+        console.log(source_default.green("  \u2713") + ` Remote added: cv-hub \u2192 ${remoteUrl}`);
+      } else {
+        console.log(source_default.green("  \u2713") + ` CV-Hub remote exists`);
+      }
+    } catch {
+    }
+  }
+  console.log();
+  console.log(source_default.bold("  Setup Complete"));
+  console.log(source_default.gray("  " + "\u2500".repeat(40)));
+  console.log(`  ${source_default.green("\u2713")} Authenticated as: ${source_default.cyan(username)}`);
+  console.log(`  ${source_default.green("\u2713")} Repository: ${source_default.cyan(repoName)}`);
+  console.log(`  ${source_default.green("\u2713")} CLAUDE.md: present`);
+  console.log(source_default.gray("  " + "\u2500".repeat(40)));
+  console.log();
+  console.log("  What's next:");
+  console.log(`    ${source_default.cyan("cva agent --auto-approve")}  \u2014 Start listening for tasks`);
+  console.log(`    Or open Claude.ai and dispatch a task to this repo.`);
+  console.log();
+  console.log(source_default.gray(`  Dashboard: ${appUrl}`));
+  console.log();
+}
+function setupCommand() {
+  const cmd = new Command("setup");
+  cmd.description("Set up CV-Agent \u2014 authentication, repo, and connections (start here)");
+  cmd.action(runSetup);
+  return cmd;
+}
+
+// src/commands/agent.ts
+var import_node_child_process5 = require("node:child_process");
+
 // src/utils/api.ts
 async function apiCall(creds, method, path, body) {
   const url = `${creds.CV_HUB_API}${path}`;
@@ -3643,7 +3850,7 @@ async function apiCall(creds, method, path, body) {
     body: body ? JSON.stringify(body) : void 0
   });
 }
-async function registerExecutor(creds, machineName, workingDir, repositoryId) {
+async function registerExecutor(creds, machineName, workingDir, repositoryId, metadata) {
   const body = {
     name: `cva:${machineName}`,
     machine_name: machineName,
@@ -3657,6 +3864,11 @@ async function registerExecutor(creds, machineName, workingDir, repositoryId) {
   if (repositoryId) {
     body.repository_id = repositoryId;
   }
+  if (metadata?.role) body.role = metadata.role;
+  if (metadata?.dispatch_guard) body.dispatch_guard = metadata.dispatch_guard;
+  if (metadata?.tags) body.tags = metadata.tags;
+  if (metadata?.owner_project) body.owner_project = metadata.owner_project;
+  if (metadata?.integration) body.integration = metadata.integration;
   const res = await apiCall(creds, "POST", "/api/v1/executors", body);
   if (!res.ok) {
     const err = await res.text();
@@ -3830,10 +4042,10 @@ function parseClaudeCodeOutput(line) {
 }
 
 // src/commands/agent-git.ts
-var import_node_child_process = require("node:child_process");
+var import_node_child_process2 = require("node:child_process");
 function gitExec(cmd, cwd) {
   try {
-    return (0, import_node_child_process.execSync)(cmd, { cwd, encoding: "utf-8", timeout: 1e4 }).trim();
+    return (0, import_node_child_process2.execSync)(cmd, { cwd, encoding: "utf-8", timeout: 1e4 }).trim();
   } catch {
     return null;
   }
@@ -3986,7 +4198,7 @@ function verifyGitRemote(cwd, task, gitHost) {
   const currentRemote = gitExec("git remote get-url origin", cwd);
   if (!currentRemote) {
     try {
-      (0, import_node_child_process.execSync)(`git remote add origin ${expectedRemote}`, { cwd, timeout: 5e3 });
+      (0, import_node_child_process2.execSync)(`git remote add origin ${expectedRemote}`, { cwd, timeout: 5e3 });
     } catch {
     }
     return { remoteName: "origin", remoteUrl: expectedRemote };
@@ -3996,7 +4208,7 @@ function verifyGitRemote(cwd, task, gitHost) {
   }
   if (currentRemote.includes(gitHost)) {
     try {
-      (0, import_node_child_process.execSync)(`git remote set-url origin ${expectedRemote}`, { cwd, timeout: 5e3 });
+      (0, import_node_child_process2.execSync)(`git remote set-url origin ${expectedRemote}`, { cwd, timeout: 5e3 });
     } catch {
     }
     return { remoteName: "origin", remoteUrl: expectedRemote };
@@ -4004,12 +4216,12 @@ function verifyGitRemote(cwd, task, gitHost) {
   const cvRemote = gitExec("git remote get-url cv-hub", cwd);
   if (!cvRemote) {
     try {
-      (0, import_node_child_process.execSync)(`git remote add cv-hub ${expectedRemote}`, { cwd, timeout: 5e3 });
+      (0, import_node_child_process2.execSync)(`git remote add cv-hub ${expectedRemote}`, { cwd, timeout: 5e3 });
     } catch {
     }
   } else if (cvRemote !== expectedRemote) {
     try {
-      (0, import_node_child_process.execSync)(`git remote set-url cv-hub ${expectedRemote}`, { cwd, timeout: 5e3 });
+      (0, import_node_child_process2.execSync)(`git remote set-url cv-hub ${expectedRemote}`, { cwd, timeout: 5e3 });
     } catch {
     }
   }
@@ -4072,6 +4284,15 @@ ${source_default.yellow("\u26A0")} ${label} failed, retrying in ${delay}s... (${
 var import_fs2 = require("fs");
 var import_os2 = require("os");
 var import_path2 = require("path");
+async function readWorkspaceConfig(workspaceRoot) {
+  try {
+    const { readFile } = await import("fs/promises");
+    const content = await readFile((0, import_path2.join)(workspaceRoot, ".cva", "agent.json"), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
 function getConfigPath() {
   return (0, import_path2.join)((0, import_os2.homedir)(), ".config", "cva", "config.json");
 }
@@ -4090,9 +4311,9 @@ async function writeConfig(config) {
 }
 
 // src/commands/git-safety.ts
-var import_node_child_process2 = require("node:child_process");
+var import_node_child_process3 = require("node:child_process");
 function git(cmd, cwd) {
-  return (0, import_node_child_process2.execSync)(cmd, { cwd, encoding: "utf8", timeout: 3e4 }).trim();
+  return (0, import_node_child_process3.execSync)(cmd, { cwd, encoding: "utf8", timeout: 3e4 }).trim();
 }
 function gitSafetyNet(workspaceRoot, taskTitle, taskId, branch) {
   const targetBranch = branch || "main";
@@ -4187,12 +4408,12 @@ Files: ${added} added, ${modified} modified, ${deleted} deleted`;
 }
 
 // src/commands/deploy-manifest.ts
-var import_node_child_process3 = require("node:child_process");
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
+var import_node_child_process4 = require("node:child_process");
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
 function exec(cmd, cwd, timeoutMs = 3e5, env2) {
   try {
-    const stdout = (0, import_node_child_process3.execSync)(cmd, {
+    const stdout = (0, import_node_child_process4.execSync)(cmd, {
       cwd,
       encoding: "utf8",
       timeout: timeoutMs,
@@ -4226,16 +4447,16 @@ async function checkHealth(url, timeoutSeconds) {
 }
 function getHeadCommit(cwd) {
   try {
-    return (0, import_node_child_process3.execSync)("git rev-parse HEAD", { cwd, encoding: "utf8", timeout: 5e3 }).trim();
+    return (0, import_node_child_process4.execSync)("git rev-parse HEAD", { cwd, encoding: "utf8", timeout: 5e3 }).trim();
   } catch {
     return null;
   }
 }
 function loadDeployManifest(workspaceRoot) {
-  const manifestPath = (0, import_node_path.join)(workspaceRoot, ".cva", "deploy.json");
-  if (!(0, import_node_fs.existsSync)(manifestPath)) return null;
+  const manifestPath = (0, import_node_path2.join)(workspaceRoot, ".cva", "deploy.json");
+  if (!(0, import_node_fs2.existsSync)(manifestPath)) return null;
   try {
-    const raw = (0, import_node_fs.readFileSync)(manifestPath, "utf8");
+    const raw = (0, import_node_fs2.readFileSync)(manifestPath, "utf8");
     const manifest = JSON.parse(raw);
     if (!manifest.version || manifest.version < 1) {
       console.log("  [deploy] Invalid manifest version");
@@ -4260,7 +4481,7 @@ async function postTaskDeploy(workspaceRoot, taskId, log) {
       console.log(`  [deploy] Building: ${buildStep.name}`);
       log("lifecycle", `Building: ${buildStep.name}`);
       const start = Date.now();
-      const cwd = (0, import_node_path.join)(workspaceRoot, buildStep.working_dir || ".");
+      const cwd = (0, import_node_path2.join)(workspaceRoot, buildStep.working_dir || ".");
       const timeoutMs = (buildStep.timeout_seconds || 300) * 1e3;
       const result = exec(buildStep.command, cwd, timeoutMs);
       if (!result.ok) {
@@ -4351,7 +4572,7 @@ async function rollback(workspaceRoot, targetCommit, manifest, log) {
   }
   if (manifest.build?.steps) {
     for (const step of manifest.build.steps) {
-      exec(step.command, (0, import_node_path.join)(workspaceRoot, step.working_dir || "."), (step.timeout_seconds || 300) * 1e3);
+      exec(step.command, (0, import_node_path2.join)(workspaceRoot, step.working_dir || "."), (step.timeout_seconds || 300) * 1e3);
     }
   }
   if (manifest.service?.restart_command) {
@@ -4381,7 +4602,7 @@ function containsAuthError(text) {
 }
 async function checkClaudeAuth() {
   try {
-    const output = (0, import_node_child_process4.execSync)("claude --version 2>&1", {
+    const output = (0, import_node_child_process5.execSync)("claude --version 2>&1", {
       encoding: "utf8",
       timeout: 1e4,
       env: { ...process.env }
@@ -4592,7 +4813,7 @@ async function launchAutoApproveMode(prompt, options) {
       if (sessionId && !isContinue) {
         args.push("--session-id", sessionId);
       }
-      const child = (0, import_node_child_process4.spawn)("claude", args, {
+      const child = (0, import_node_child_process5.spawn)("claude", args, {
         cwd: options.cwd,
         stdio: ["inherit", "pipe", "pipe"],
         env: options.spawnEnv || { ...process.env }
@@ -4726,7 +4947,7 @@ ${source_default.red("!")} Claude Code auth failure (stderr): "${authError}"`);
 }
 async function launchRelayMode(prompt, options) {
   return new Promise((resolve, reject) => {
-    const child = (0, import_node_child_process4.spawn)("claude", [], {
+    const child = (0, import_node_child_process5.spawn)("claude", [], {
       cwd: options.cwd,
       stdio: ["pipe", "pipe", "pipe"],
       env: options.spawnEnv || { ...process.env }
@@ -4952,19 +5173,19 @@ async function handleSelfUpdate(task, state, creds) {
     let output = "";
     if (source === "npm" || source.startsWith("npm:")) {
       const pkg = source === "npm" ? "@controlvector/cv-agent@latest" : source.replace("npm:", "");
-      output = (0, import_node_child_process4.execSync)(`npm install -g ${pkg} 2>&1`, { encoding: "utf8", timeout: 12e4 });
+      output = (0, import_node_child_process5.execSync)(`npm install -g ${pkg} 2>&1`, { encoding: "utf8", timeout: 12e4 });
     } else if (source.startsWith("git:")) {
       const repoPath = source.replace("git:", "");
-      output = (0, import_node_child_process4.execSync)(`cd ${repoPath} && git pull && npm install && npm run build && npm link 2>&1`, {
+      output = (0, import_node_child_process5.execSync)(`cd ${repoPath} && git pull && npm install && npm run build && npm link 2>&1`, {
         encoding: "utf8",
         timeout: 3e5
       });
     } else {
-      output = (0, import_node_child_process4.execSync)(`npm install -g @controlvector/cv-agent@latest 2>&1`, { encoding: "utf8", timeout: 12e4 });
+      output = (0, import_node_child_process5.execSync)(`npm install -g @controlvector/cv-agent@latest 2>&1`, { encoding: "utf8", timeout: 12e4 });
     }
     let newVersion = "unknown";
     try {
-      newVersion = (0, import_node_child_process4.execSync)("cva --version 2>/dev/null || echo unknown", { encoding: "utf8" }).trim();
+      newVersion = (0, import_node_child_process5.execSync)("cva --version 2>/dev/null || echo unknown", { encoding: "utf8" }).trim();
     } catch {
     }
     postTaskEvent(creds, task.id, {
@@ -4990,7 +5211,7 @@ async function handleSelfUpdate(task, state, creds) {
     if (task.input?.constraints?.includes("restart")) {
       console.log(source_default.yellow("Restarting agent with updated binary..."));
       const args = process.argv.slice(1).join(" ");
-      (0, import_node_child_process4.execSync)(`nohup cva ${args} > /tmp/cva-restart.log 2>&1 &`, { stdio: "ignore" });
+      (0, import_node_child_process5.execSync)(`nohup cva ${args} > /tmp/cva-restart.log 2>&1 &`, { stdio: "ignore" });
       process.exit(0);
     }
   } catch (err) {
@@ -5022,7 +5243,7 @@ async function runAgent(options) {
     process.exit(1);
   }
   try {
-    (0, import_node_child_process4.execSync)("claude --version", { stdio: "pipe", timeout: 5e3 });
+    (0, import_node_child_process5.execSync)("claude --version", { stdio: "pipe", timeout: 5e3 });
   } catch {
     console.log();
     console.log(source_default.red("Claude Code CLI not found.") + " Install it first:");
@@ -5051,7 +5272,7 @@ async function runAgent(options) {
     currentAuthStatus = "api_key_fallback";
   }
   try {
-    (0, import_node_child_process4.execSync)("cv --version", { stdio: "pipe", timeout: 5e3 });
+    (0, import_node_child_process5.execSync)("cv --version", { stdio: "pipe", timeout: 5e3 });
   } catch {
     console.log(source_default.yellow("!") + " cv-git CLI not found. Claude Code will fall back to raw git commands.");
     console.log(`  Install it: ${source_default.cyan("npm install -g @controlvector/cv-git")}`);
@@ -5071,7 +5292,7 @@ async function runAgent(options) {
   }
   let detectedRepoId;
   try {
-    const remoteUrl = (0, import_node_child_process4.execSync)("git remote get-url origin 2>/dev/null", {
+    const remoteUrl = (0, import_node_child_process5.execSync)("git remote get-url origin 2>/dev/null", {
       cwd: workingDir,
       encoding: "utf8",
       timeout: 5e3
@@ -5092,8 +5313,47 @@ async function runAgent(options) {
     }
   } catch {
   }
+  const wsConfig = await readWorkspaceConfig(workingDir);
+  const globalConfig = await readConfig();
+  const role = options.role || wsConfig.role || globalConfig.role || "development";
+  const dispatchGuard = options.dispatchGuard || wsConfig.dispatch_guard || globalConfig.dispatch_guard || "open";
+  const tags = (options.tags?.split(",") || wsConfig.tags || globalConfig.tags)?.map((t) => t.trim()).filter(Boolean);
+  const ownerProject = options.ownerProject || wsConfig.owner_project || globalConfig.owner_project;
+  let integration;
+  if (options.integration || wsConfig.integration) {
+    if (options.integration) {
+      const safeTasks = options.safeTasks?.split(",").map((t) => t.trim()).filter(Boolean);
+      const unsafeTasks = safeTasks ? ["code_change", "deploy", "test", "custom"].filter((t) => !safeTasks.includes(t)) : void 0;
+      integration = {
+        system: options.integration,
+        description: options.integrationDescription || `Integrated into ${options.integration}`,
+        service_port: options.integrationPort ? parseInt(options.integrationPort, 10) : void 0,
+        safe_task_types: safeTasks,
+        unsafe_task_types: unsafeTasks
+      };
+    } else if (wsConfig.integration) {
+      integration = wsConfig.integration;
+    }
+  }
+  const executorMeta = {
+    role,
+    dispatch_guard: dispatchGuard,
+    tags,
+    owner_project: ownerProject,
+    integration
+  };
+  if (role !== "development") {
+    console.log(source_default.yellow(`   Role:     ${role}`));
+  }
+  if (integration) {
+    console.log(source_default.yellow(`   Integration: ${integration.system}${integration.service_port ? ` (port ${integration.service_port})` : ""}`));
+  }
+  if (dispatchGuard !== "open") {
+    const guardIcon = dispatchGuard === "locked" ? "\u{1F512}" : "\u26A0\uFE0F";
+    console.log(source_default.yellow(`   Guard:    ${guardIcon} ${dispatchGuard}`));
+  }
   const executor = await withRetry(
-    () => registerExecutor(creds, machineName, workingDir, detectedRepoId),
+    () => registerExecutor(creds, machineName, workingDir, detectedRepoId, executorMeta),
     "Executor registration"
   );
   const mode = options.autoApprove ? "auto-approve" : "relay";
@@ -5441,6 +5701,14 @@ function agentCommand() {
   cmd.option("--poll-interval <seconds>", "How often to check for tasks, minimum 3 (default: 5)", "5");
   cmd.option("--working-dir <path>", "Working directory for Claude Code (default: current directory)", ".");
   cmd.option("--auto-approve", "Pre-approve all tool permissions (uses -p mode)", false);
+  cmd.option("--role <role>", "Executor role: development, production, ci, staging");
+  cmd.option("--integration <system>", "System this executor is integrated into (e.g. nyx-forge)");
+  cmd.option("--integration-description <desc>", "Description of the integration");
+  cmd.option("--integration-port <port>", "Port the integrated service runs on");
+  cmd.option("--safe-tasks <types>", "Comma-separated task types safe for this executor (e.g. review,research)");
+  cmd.option("--dispatch-guard <guard>", "Dispatch guard: open, confirm, locked (default: open)");
+  cmd.option("--tags <tags>", "Comma-separated tags for this executor");
+  cmd.option("--owner-project <project>", "Project this executor belongs to");
   cmd.action(async (opts) => {
     await runAgent(opts);
   });
@@ -5548,7 +5816,7 @@ function authCommand() {
 }
 
 // src/commands/remote.ts
-var import_node_child_process5 = require("node:child_process");
+var import_node_child_process6 = require("node:child_process");
 function getGitHost(apiUrl) {
   return apiUrl.replace(/^https?:\/\//, "").replace(/^api\./, "git.");
 }
@@ -5563,16 +5831,16 @@ async function remoteAdd(ownerRepo) {
   }
   const remoteUrl = `https://${gitHost}/${owner}/${repo}.git`;
   try {
-    const existing = (0, import_node_child_process5.execSync)("git remote get-url cvhub", { encoding: "utf-8", timeout: 5e3 }).trim();
+    const existing = (0, import_node_child_process6.execSync)("git remote get-url cvhub", { encoding: "utf-8", timeout: 5e3 }).trim();
     if (existing === remoteUrl) {
       console.log(source_default.gray(`Remote 'cvhub' already set to ${remoteUrl}`));
       return;
     }
-    (0, import_node_child_process5.execSync)(`git remote set-url cvhub ${remoteUrl}`, { timeout: 5e3 });
+    (0, import_node_child_process6.execSync)(`git remote set-url cvhub ${remoteUrl}`, { timeout: 5e3 });
     console.log(source_default.green("Updated") + ` remote 'cvhub' -> ${remoteUrl}`);
   } catch {
     try {
-      (0, import_node_child_process5.execSync)(`git remote add cvhub ${remoteUrl}`, { timeout: 5e3 });
+      (0, import_node_child_process6.execSync)(`git remote add cvhub ${remoteUrl}`, { timeout: 5e3 });
       console.log(source_default.green("Added") + ` remote 'cvhub' -> ${remoteUrl}`);
     } catch (err) {
       console.log(source_default.red("Failed to add remote:") + ` ${err.message}`);
@@ -5764,7 +6032,8 @@ function statusCommand() {
 
 // src/index.ts
 var program2 = new Command();
-program2.name("cva").description("CV-Hub Agent \u2014 bridges Claude Code with CV-Hub task dispatch").version(true ? "1.5.0" : "1.1.0");
+program2.name("cva").description('CV-Hub Agent \u2014 bridges Claude Code with CV-Hub task dispatch.\n\nRun "cva setup" to get started.').version(true ? "1.7.0" : "1.6.0");
+program2.addCommand(setupCommand());
 program2.addCommand(agentCommand());
 program2.addCommand(authCommand());
 program2.addCommand(remoteCommand());