@controlvector/cv-agent 1.10.0 → 1.11.0

package/dist/bundle.cjs

@@ -6,9 +6,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -3019,98 +3026,7 @@ var require_commander = __commonJS({
   }
 });
 
-// node_modules/commander/esm.mjs
-var import_index = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  // deprecated old name
-  Command,
-  Argument,
-  Option,
-  Help
-} = import_index.default;
-
-// 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;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    // 21 isn't widely supported and 22 does the same thing
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    // Bright color
-    blackBright: [90, 39],
-    gray: [90, 39],
-    // Alias of `blackBright`
-    grey: [90, 39],
-    // Alias of `blackBright`
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    // Bright color
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    // Alias of `bgBlackBright`
-    bgGrey: [100, 49],
-    // Alias of `bgBlackBright`
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
 function assembleStyles() {
   const codes = /* @__PURE__ */ new Map();
   for (const [groupName, group] of Object.entries(styles)) {
@@ -3225,26 +3141,89 @@ function assembleStyles() {
   });
   return styles;
 }
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
+var ANSI_BACKGROUND_OFFSET, wrapAnsi16, wrapAnsi256, wrapAnsi16m, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
+var init_ansi_styles = __esm({
+  "node_modules/chalk/source/vendor/ansi-styles/index.js"() {
+    ANSI_BACKGROUND_OFFSET = 10;
+    wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+    wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+    wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+    styles = {
+      modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        gray: [90, 39],
+        // Alias of `blackBright`
+        grey: [90, 39],
+        // Alias of `blackBright`
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgGray: [100, 49],
+        // Alias of `bgBlackBright`
+        bgGrey: [100, 49],
+        // Alias of `bgBlackBright`
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    modifierNames = Object.keys(styles.modifier);
+    foregroundColorNames = Object.keys(styles.color);
+    backgroundColorNames = Object.keys(styles.bgColor);
+    colorNames = [...foregroundColorNames, ...backgroundColorNames];
+    ansiStyles = assembleStyles();
+    ansi_styles_default = ansiStyles;
+  }
+});
 
 // node_modules/chalk/source/vendor/supports-color/index.js
-var import_node_process = __toESM(require("node:process"), 1);
-var import_node_os = __toESM(require("node:os"), 1);
-var import_node_tty = __toESM(require("node:tty"), 1);
 function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
   const position = argv.indexOf(prefix + flag);
   const terminatorPosition = argv.indexOf("--");
   return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
-var { env } = import_node_process.default;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
 function envForceColor() {
   if ("FORCE_COLOR" in env) {
     if (env.FORCE_COLOR === "true") {
@@ -3354,11 +3333,25 @@ function createSupportsColor(stream, options = {}) {
   });
   return translateLevel(level);
 }
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
-};
-var supports_color_default = supportsColor;
+var import_node_process, import_node_os, import_node_tty, env, flagForceColor, supportsColor, supports_color_default;
+var init_supports_color = __esm({
+  "node_modules/chalk/source/vendor/supports-color/index.js"() {
+    import_node_process = __toESM(require("node:process"), 1);
+    import_node_os = __toESM(require("node:os"), 1);
+    import_node_tty = __toESM(require("node:tty"), 1);
+    ({ env } = import_node_process.default);
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      flagForceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      flagForceColor = 1;
+    }
+    supportsColor = {
+      stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
+      stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
+    };
+    supports_color_default = supportsColor;
+  }
+});
 
 // node_modules/chalk/source/utilities.js
 function stringReplaceAll(string, substring, replacer) {
@@ -3389,153 +3382,389 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
   returnValue += string.slice(endIndex);
   return returnValue;
 }
+var init_utilities = __esm({
+  "node_modules/chalk/source/utilities.js"() {
+  }
+});
 
 // node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = /* @__PURE__ */ Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === void 0 ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk2 = (...strings) => strings.join(" ");
-  applyOptions(chalk2, options);
-  Object.setPrototypeOf(chalk2, createChalk.prototype);
-  return chalk2;
-};
 function createChalk(options) {
   return chalkFactory(options);
 }
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
+var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2, applyOptions, chalkFactory, getModelAnsi, usedModels, proto, createStyler, createBuilder, applyStyle, chalk, chalkStderr, source_default;
+var init_source = __esm({
+  "node_modules/chalk/source/index.js"() {
+    init_ansi_styles();
+    init_supports_color();
+    init_utilities();
+    ({ stdout: stdoutColor, stderr: stderrColor } = supports_color_default);
+    GENERATOR = Symbol("GENERATOR");
+    STYLER = Symbol("STYLER");
+    IS_EMPTY = Symbol("IS_EMPTY");
+    levelMapping = [
+      "ansi",
+      "ansi",
+      "ansi256",
+      "ansi16m"
+    ];
+    styles2 = /* @__PURE__ */ Object.create(null);
+    applyOptions = (object, options = {}) => {
+      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+        throw new Error("The `level` option should be an integer from 0 to 3");
+      }
+      const colorLevel = stdoutColor ? stdoutColor.level : 0;
+      object.level = options.level === void 0 ? colorLevel : options.level;
+    };
+    chalkFactory = (options) => {
+      const chalk2 = (...strings) => strings.join(" ");
+      applyOptions(chalk2, options);
+      Object.setPrototypeOf(chalk2, createChalk.prototype);
+      return chalk2;
+    };
+    Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+    for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+      styles2[styleName] = {
+        get() {
+          const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+          Object.defineProperty(this, styleName, { value: builder });
+          return builder;
+        }
+      };
     }
-  };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
+    styles2.visible = {
+      get() {
+        const builder = createBuilder(this, this[STYLER], true);
+        Object.defineProperty(this, "visible", { value: builder });
+        return builder;
+      }
+    };
+    getModelAnsi = (model, level, type, ...arguments_) => {
+      if (model === "rgb") {
+        if (level === "ansi16m") {
+          return ansi_styles_default[type].ansi16m(...arguments_);
+        }
+        if (level === "ansi256") {
+          return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+        }
+        return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+      }
+      if (model === "hex") {
+        return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+      }
+      return ansi_styles_default[type][model](...arguments_);
+    };
+    usedModels = ["rgb", "hex", "ansi256"];
+    for (const model of usedModels) {
+      styles2[model] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles2[bgModel] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+    }
+    proto = Object.defineProperties(() => {
+    }, {
+      ...styles2,
+      level: {
+        enumerable: true,
+        get() {
+          return this[GENERATOR].level;
+        },
+        set(level) {
+          this[GENERATOR].level = level;
+        }
+      }
+    });
+    createStyler = (open, close, parent) => {
+      let openAll;
+      let closeAll;
+      if (parent === void 0) {
+        openAll = open;
+        closeAll = close;
+      } else {
+        openAll = parent.openAll + open;
+        closeAll = close + parent.closeAll;
+      }
+      return {
+        open,
+        close,
+        openAll,
+        closeAll,
+        parent
+      };
+    };
+    createBuilder = (self, _styler, _isEmpty) => {
+      const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+      Object.setPrototypeOf(builder, proto);
+      builder[GENERATOR] = self;
+      builder[STYLER] = _styler;
+      builder[IS_EMPTY] = _isEmpty;
+      return builder;
+    };
+    applyStyle = (self, string) => {
+      if (self.level <= 0 || !string) {
+        return self[IS_EMPTY] ? "" : string;
+      }
+      let styler = self[STYLER];
+      if (styler === void 0) {
+        return string;
+      }
+      const { openAll, closeAll } = styler;
+      if (string.includes("\x1B")) {
+        while (styler !== void 0) {
+          string = stringReplaceAll(string, styler.close, styler.open);
+          styler = styler.parent;
+        }
+      }
+      const lfIndex = string.indexOf("\n");
+      if (lfIndex !== -1) {
+        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+      }
+      return openAll + string + closeAll;
+    };
+    Object.defineProperties(createChalk.prototype, styles2);
+    chalk = createChalk();
+    chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+    source_default = chalk;
   }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
+});
+
+// src/utils/org-resolver.ts
+var org_resolver_exports = {};
+__export(org_resolver_exports, {
+  confirmAutoMatch: () => confirmAutoMatch,
+  parseMultiOrgError: () => parseMultiOrgError,
+  persistOrg: () => persistOrg,
+  pickOrg: () => pickOrg,
+  promptPersistScope: () => promptPersistScope,
+  resolveOrg: () => resolveOrg,
+  resolveToUUID: () => resolveToUUID
+});
+function resolveOrg(opts) {
+  if (opts.cliFlag?.trim()) {
+    return { value: opts.cliFlag.trim(), source: "cli" };
+  }
+  const envVal = process.env.CV_HUB_ORG?.trim();
+  if (envVal) {
+    return { value: envVal, source: "env" };
+  }
+  const cwd = opts.cwd || process.cwd();
+  try {
+    const repoConfigPath = (0, import_node_path2.join)(cwd, ".cva", "agent.json");
+    if ((0, import_node_fs3.existsSync)(repoConfigPath)) {
+      const config = JSON.parse((0, import_node_fs3.readFileSync)(repoConfigPath, "utf-8"));
+      if (config.organization?.trim()) {
+        return { value: config.organization.trim(), source: "repo-config" };
+      }
     }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+  } catch {
+  }
+  try {
+    const globalConfigPath = (0, import_node_path2.join)((0, import_node_os3.homedir)(), ".config", "cva", "config.json");
+    if ((0, import_node_fs3.existsSync)(globalConfigPath)) {
+      const config = JSON.parse((0, import_node_fs3.readFileSync)(globalConfigPath, "utf-8"));
+      if (config.organization?.trim()) {
+        return { value: config.organization.trim(), source: "global-config" };
+      }
     }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  } catch {
   }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  return { value: "", source: null };
+}
+function resolveToUUID(identifier, orgs) {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  if (uuidRegex.test(identifier)) {
+    const match = orgs.find((o) => o.id.toLowerCase() === identifier.toLowerCase());
+    if (match) return match.id;
+  }
+  const slugMatch = orgs.find((o) => o.slug.toLowerCase() === identifier.toLowerCase());
+  if (slugMatch) return slugMatch.id;
+  throw new Error(
+    `Organization "${identifier}" not found. Valid options: ${orgs.map((o) => o.slug).join(", ")}`
+  );
+}
+function persistOrg(value, scope, cwd) {
+  let configPath;
+  if (scope === "repo") {
+    const dir = (0, import_node_path2.join)(cwd || process.cwd(), ".cva");
+    (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+    configPath = (0, import_node_path2.join)(dir, "agent.json");
+  } else {
+    const dir = (0, import_node_path2.join)((0, import_node_os3.homedir)(), ".config", "cva");
+    (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+    configPath = (0, import_node_path2.join)(dir, "config.json");
   }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
+  let existing = {};
+  try {
+    if ((0, import_node_fs3.existsSync)(configPath)) {
+      existing = JSON.parse((0, import_node_fs3.readFileSync)(configPath, "utf-8"));
     }
-  };
+  } catch {
+  }
+  existing.organization = value;
+  const tmpPath = configPath + ".tmp";
+  (0, import_node_fs3.writeFileSync)(tmpPath, JSON.stringify(existing, null, 2) + "\n", {
+    mode: scope === "global" ? 384 : 420
+  });
+  (0, import_node_fs3.renameSync)(tmpPath, configPath);
+  return configPath;
 }
-var proto = Object.defineProperties(() => {
-}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
+async function promptPersistScope() {
+  const readline = await import("node:readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  console.log();
+  console.log(source_default.gray("  Save this choice for next time?"));
+  console.log(`    ${source_default.cyan("r")}. Save to this repo's .cva/agent.json ${source_default.gray("(recommended)")}`);
+  console.log(`    ${source_default.cyan("g")}. Save globally to ~/.config/cva/config.json`);
+  console.log(`    ${source_default.cyan("n")}. Don't save \u2014 prompt again next time`);
+  console.log();
+  const input = await new Promise((resolve2) => {
+    rl.question("  Choice [r/g/n] (default: r): ", (answer) => {
+      rl.close();
+      resolve2(answer.trim().toLowerCase() || "r");
+    });
+  });
+  return input === "g" ? "global" : input === "n" ? "none" : "repo";
+}
+async function confirmAutoMatch(match, sourceSlug) {
+  const readline = await import("node:readline");
+  console.log();
+  console.log(`  Auto-matched organization: ${source_default.bold(match.name)} (${match.slug})`);
+  console.log(source_default.gray(`    from repo owner: ${sourceSlug}`));
+  console.log();
+  console.log(`  Register executor under ${match.name}?`);
+  console.log(`    ${source_default.cyan("Y")} \u2014 yes, use ${match.name}`);
+  console.log(`    ${source_default.cyan("n")} \u2014 no, abort`);
+  console.log(`    ${source_default.cyan("p")} \u2014 show the full org list and pick manually`);
+  console.log();
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let attempts = 0;
+  while (attempts < 2) {
+    const input = await new Promise((resolve2) => {
+      rl.question("  Choice [Y/n/p] (default: Y): ", (answer) => {
+        resolve2(answer.trim().toLowerCase() || "y");
+      });
+    });
+    if (input === "y" || input === "yes") {
+      rl.close();
+      return "accept";
+    }
+    if (input === "n" || input === "no") {
+      rl.close();
+      return "abort";
+    }
+    if (input === "p" || input === "pick") {
+      rl.close();
+      return "pick";
+    }
+    attempts++;
+    if (attempts < 2) {
+      console.log(source_default.yellow("  Invalid input. Enter Y, n, or p."));
     }
   }
-});
-var createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === void 0) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
+  rl.close();
+  return "abort";
+}
+async function pickOrg(orgs, opts) {
+  if (!opts.interactive || !process.stdout.isTTY) {
+    throw new Error(
+      `CV-Hub requires organization selection. Set CV_HUB_ORG or pass --org. Valid slugs: ${orgs.map((o) => o.slug).join(", ")}`
+    );
   }
-  return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
-  };
-};
-var createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
-    return self[IS_EMPTY] ? "" : string;
+  const readline = await import("node:readline");
+  console.log();
+  console.log(source_default.bold("  CV-Hub requires organization selection."));
+  console.log(source_default.gray("  Which organization should this executor register under?"));
+  console.log();
+  orgs.forEach((o, i) => {
+    console.log(`    ${source_default.cyan(String(i + 1))}. ${o.name.padEnd(20)} (${source_default.gray(o.slug)})`);
+  });
+  console.log(`    ${source_default.cyan("c")}. Cancel`);
+  console.log();
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const input = await new Promise((resolve2) => {
+    rl.question("  Enter number, slug, or 'c': ", (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+  if (input.toLowerCase() === "c" || !input) {
+    throw new Error("Registration aborted. Set CV_HUB_ORG or use --org to skip this prompt.");
   }
-  let styler = self[STYLER];
-  if (styler === void 0) {
-    return string;
+  let chosen;
+  const num = parseInt(input, 10);
+  if (!isNaN(num) && num >= 1 && num <= orgs.length) {
+    chosen = orgs[num - 1];
+  } else {
+    chosen = orgs.find((o) => o.slug.toLowerCase() === input.toLowerCase());
+  }
+  if (!chosen) {
+    throw new Error(`"${input}" doesn't match any organization. Valid: ${orgs.map((o) => o.slug).join(", ")}`);
   }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== void 0) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
+  console.log();
+  console.log(`  ${source_default.green("\u2713")} ${chosen.name} (${chosen.slug})`);
+  const persistScope = await promptPersistScope();
+  return { chosen, persistScope };
+}
+function parseMultiOrgError(status, body) {
+  if (status !== 400) return null;
+  try {
+    const data = JSON.parse(body);
+    const orgs = data?.error?.organizations;
+    if (Array.isArray(orgs) && orgs.length > 0 && orgs[0]?.id && orgs[0]?.slug) {
+      return orgs;
     }
+  } catch {
   }
-  const lfIndex = string.indexOf("\n");
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  return null;
+}
+var import_node_fs3, import_node_path2, import_node_os3;
+var init_org_resolver = __esm({
+  "src/utils/org-resolver.ts"() {
+    "use strict";
+    import_node_fs3 = require("node:fs");
+    import_node_path2 = require("node:path");
+    import_node_os3 = require("node:os");
+    init_source();
   }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
+});
+
+// node_modules/commander/esm.mjs
+var import_index = __toESM(require_commander(), 1);
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError,
+  // deprecated old name
+  Command,
+  Argument,
+  Option,
+  Help
+} = import_index.default;
+
+// 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");
+init_source();
 
 // src/utils/credentials.ts
 var import_fs = require("fs");
@@ -3665,6 +3894,92 @@ async function validateToken(hubUrl, token) {
     return null;
   }
 }
+var DEVICE_CLIENT_ID = "cv-agent-cli";
+var DEVICE_SCOPES = "repo:read repo:write profile offline_access";
+var POLL_INTERVAL_MS = 5e3;
+var MAX_POLL_ATTEMPTS = 180;
+async function deviceAuthFlow(hubUrl, appUrl) {
+  const authRes = await fetch(`${hubUrl}/oauth/device/authorize`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: DEVICE_CLIENT_ID,
+      scope: DEVICE_SCOPES
+    })
+  });
+  if (!authRes.ok) {
+    const err = await authRes.json().catch(() => ({}));
+    throw new Error(err.error_description || `Device auth failed: ${authRes.status}`);
+  }
+  const auth = await authRes.json();
+  console.log(source_default.bold("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  console.log(source_default.bold("  \u2502     CV-Hub Device Authorization          \u2502"));
+  console.log(source_default.bold("  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524"));
+  console.log(source_default.bold("  \u2502                                          \u2502"));
+  console.log(source_default.bold("  \u2502  Open this URL in your browser:          \u2502"));
+  console.log(source_default.bold(`  \u2502  ${source_default.cyan(auth.verification_uri).padEnd(51)}\u2502`));
+  console.log(source_default.bold("  \u2502                                          \u2502"));
+  console.log(source_default.bold("  \u2502  Then enter this code:                   \u2502"));
+  console.log(source_default.bold(`  \u2502          ${source_default.white.bold(auth.user_code)}                       \u2502`));
+  console.log(source_default.bold("  \u2502                                          \u2502"));
+  console.log(source_default.bold(`  \u2502  ${source_default.gray(`Expires in ${Math.floor(auth.expires_in / 60)} minutes`).padEnd(51)}\u2502`));
+  console.log(source_default.bold("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+  console.log();
+  try {
+    const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    (0, import_node_child_process.execSync)(`${openCmd} "${auth.verification_uri_complete}" 2>/dev/null`, { timeout: 5e3 });
+    console.log(source_default.gray("  Browser opened. Waiting for authorization..."));
+  } catch {
+    console.log(source_default.gray("  Open the URL above in your browser."));
+  }
+  let interval = Math.max(auth.interval * 1e3, POLL_INTERVAL_MS);
+  const expireTime = Date.now() + auth.expires_in * 1e3;
+  for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt++) {
+    await new Promise((r) => setTimeout(r, interval));
+    if (Date.now() > expireTime) {
+      throw new Error("Authorization timed out");
+    }
+    const remaining = Math.ceil((expireTime - Date.now()) / 1e3);
+    const mins = Math.floor(remaining / 60);
+    const secs = remaining % 60;
+    process.stdout.write(`\r  Waiting for authorization... (${mins}:${secs.toString().padStart(2, "0")} remaining) `);
+    const tokenRes = await fetch(`${hubUrl}/oauth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: auth.device_code,
+        client_id: DEVICE_CLIENT_ID
+      })
+    });
+    const tokenData = await tokenRes.json();
+    if (tokenData.access_token) {
+      process.stdout.write("\r" + " ".repeat(60) + "\r");
+      let uname = "user";
+      try {
+        const userRes = await fetch(`${hubUrl}/oauth/userinfo`, {
+          headers: { Authorization: `Bearer ${tokenData.access_token}` }
+        });
+        if (userRes.ok) {
+          const userInfo = await userRes.json();
+          uname = userInfo.preferred_username || userInfo.name || "user";
+        }
+      } catch {
+      }
+      return { token: tokenData.access_token, username: uname };
+    }
+    if (tokenData.error === "slow_down") {
+      interval += 5e3;
+    } else if (tokenData.error === "access_denied") {
+      process.stdout.write("\r" + " ".repeat(60) + "\r");
+      throw new Error("Authorization denied by user");
+    } else if (tokenData.error === "expired_token") {
+      process.stdout.write("\r" + " ".repeat(60) + "\r");
+      throw new Error("Authorization expired");
+    }
+  }
+  throw new Error("Authorization timed out");
+}
 function checkBinary(cmd) {
   try {
     return (0, import_node_child_process.execSync)(`${cmd} 2>&1`, { encoding: "utf8", timeout: 5e3 }).trim().split("\n")[0];
@@ -3724,38 +4039,20 @@ async function runSetup() {
   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."));
+      const deviceResult = await deviceAuthFlow(hubUrl, appUrl);
+      token = deviceResult.token;
+      username = deviceResult.username;
+      console.log(source_default.green("  \u2713") + ` Authenticated as ${source_default.bold(username)}`);
+      writeSharedCreds({ hub_url: hubUrl, token, username, created_at: (/* @__PURE__ */ new Date()).toISOString() });
+      await writeCredentialField("CV_HUB_PAT", token);
+      await writeCredentialField("CV_HUB_API", hubUrl);
+    } catch (err) {
+      console.log(source_default.red(`  Authentication failed: ${err.message}`));
+      console.log(source_default.gray("  You can retry with: cva setup"));
+      console.log(source_default.gray("  Or manually: cva auth login --token <your-pat>"));
       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:");
@@ -3766,18 +4063,84 @@ async function runSetup() {
   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);
+  let cwd = process.cwd();
+  let isGitRepo = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".git"));
+  let 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");
+    const readline = await import("node:readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log("  No git repository found in this directory.");
+    console.log();
+    console.log(`    ${source_default.cyan("a")} \u2014 Initialize a new project here: ${cwd}`);
+    console.log(`    ${source_default.cyan("b")} \u2014 Clone an existing repo from CV-Hub`);
+    console.log();
+    const choice = await new Promise((resolve2) => {
+      rl.question("  Choose [a/b]: ", (answer) => {
+        rl.close();
+        resolve2(answer.trim().toLowerCase() || "a");
+      });
+    });
+    if (choice === "b" && token) {
+      try {
+        console.log(source_default.gray("  Fetching your repositories..."));
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15e3);
+        const res = await fetch(`${hubUrl}/api/v1/repos?limit=50`, {
+          headers: { Authorization: `Bearer ${token}` },
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (res.ok) {
+          const data = await res.json();
+          const repos = data.repositories || [];
+          if (repos.length === 0) {
+            console.log(source_default.yellow("  No repos found on CV-Hub. Initializing a new project instead."));
+          } else {
+            console.log();
+            console.log("  Your CV-Hub repositories:");
+            const displayRepos = repos.slice(0, 20);
+            displayRepos.forEach((r, i) => {
+              const desc = r.description ? source_default.gray(` \u2014 ${r.description.substring(0, 40)}`) : "";
+              console.log(`    ${source_default.cyan(String(i + 1).padStart(2))}. ${r.slug || r.name}${desc}`);
+            });
+            console.log();
+            const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const selection = await new Promise((resolve2) => {
+              rl2.question(`  Select a repo [1-${displayRepos.length}]: `, (answer) => {
+                rl2.close();
+                resolve2(answer.trim());
+              });
+            });
+            const idx = parseInt(selection, 10) - 1;
+            if (idx >= 0 && idx < displayRepos.length) {
+              const repo = displayRepos[idx];
+              const gitHost = "git.hub.controlvector.io";
+              const slug = repo.slug || repo.name;
+              const cloneUrl = `https://${username}:${token}@${gitHost}/${username}/${slug}.git`;
+              console.log(source_default.gray(`  Cloning ${username}/${slug}...`));
+              (0, import_node_child_process.execSync)(`git clone ${cloneUrl} ${slug}`, { cwd, stdio: "pipe", timeout: 6e4 });
+              cwd = (0, import_node_path.join)(cwd, slug);
+              process.chdir(cwd);
+              repoName = slug;
+              isGitRepo = true;
+              console.log(source_default.green("  \u2713") + ` Cloned ${username}/${slug}`);
+            }
+          }
+        }
+      } catch (err) {
+        console.log(source_default.yellow(`  Could not fetch repos: ${err.message}. Initializing instead.`));
+      }
+    }
+    if (!isGitRepo) {
+      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");
+    }
   }
+  const hasClaudeMd = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "CLAUDE.md"));
+  const hasCVDir = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".cv"));
   if (!hasClaudeMd) {
     const template = `# ${repoName}
 
@@ -3795,6 +4158,41 @@ async function runSetup() {
   } else {
     console.log(source_default.green("  \u2713") + " CLAUDE.md present");
   }
+  const gitignorePath = (0, import_node_path.join)(cwd, ".gitignore");
+  const CREDENTIAL_PATTERNS = [
+    "# Credentials and secrets (auto-added by cv-agent)",
+    ".env",
+    ".env.*",
+    ".claude/",
+    ".claude.json",
+    ".credentials*",
+    "*.pem",
+    "*.key",
+    ".ssh/",
+    ".gnupg/",
+    ".npm/",
+    ".config/",
+    ".zsh_history",
+    ".bash_history",
+    ".zsh_sessions/",
+    "node_modules/",
+    ".DS_Store"
+  ];
+  try {
+    let gitignoreContent = "";
+    if ((0, import_node_fs.existsSync)(gitignorePath)) {
+      gitignoreContent = (0, import_node_fs.readFileSync)(gitignorePath, "utf-8");
+    }
+    const missing = CREDENTIAL_PATTERNS.filter((p) => !gitignoreContent.includes(p));
+    if (missing.length > 0) {
+      const addition = (gitignoreContent && !gitignoreContent.endsWith("\n") ? "\n" : "") + missing.join("\n") + "\n";
+      (0, import_node_fs.writeFileSync)(gitignorePath, gitignoreContent + addition);
+      console.log(source_default.green("  \u2713") + " .gitignore updated with credential protection");
+    } else {
+      console.log(source_default.green("  \u2713") + " .gitignore has credential protection");
+    }
+  } catch {
+  }
   if (!hasCVDir) {
     (0, import_node_fs.mkdirSync)((0, import_node_path.join)(cwd, ".cv"), { recursive: true });
   }
@@ -3804,6 +4202,22 @@ async function runSetup() {
     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) {
+        try {
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), 15e3);
+          await fetch(`${hubUrl}/api/v1/user/repos`, {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${token}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({ name: repoName, auto_init: false }),
+            signal: controller.signal
+          });
+          clearTimeout(timeout);
+          console.log(source_default.green("  \u2713") + ` Repo created on CV-Hub: ${username}/${repoName}`);
+        } catch {
+        }
         (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 {
@@ -3811,6 +4225,99 @@ async function runSetup() {
       }
     } catch {
     }
+    try {
+      const credStorePath = (0, import_node_path.join)((0, import_node_os2.homedir)(), ".git-credentials");
+      const credLine = `https://${username}:${token}@${gitHost}`;
+      let existing = "";
+      try {
+        existing = (0, import_node_fs.readFileSync)(credStorePath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes(gitHost)) {
+        (0, import_node_fs.writeFileSync)(credStorePath, existing + credLine + "\n", { mode: 384 });
+      }
+      (0, import_node_child_process.execSync)(`git config --global credential.helper store`, { stdio: "pipe" });
+    } catch {
+    }
+    try {
+      (0, import_node_child_process.execSync)("git log --oneline -1", { cwd, stdio: "pipe" });
+      const status = (0, import_node_child_process.execSync)("git status --porcelain", { cwd, encoding: "utf8" }).trim();
+      if (status) {
+        (0, import_node_child_process.execSync)("git add -A", { cwd, stdio: "pipe" });
+        (0, import_node_child_process.execSync)('git commit -m "chore: cv-agent setup"', { cwd, stdio: "pipe" });
+        console.log(source_default.green("  \u2713") + " Changes committed");
+      }
+    } catch {
+      try {
+        (0, import_node_child_process.execSync)("git add -A", { cwd, stdio: "pipe" });
+        (0, import_node_child_process.execSync)('git commit -m "Initial commit via cv-agent"', { cwd, stdio: "pipe" });
+        console.log(source_default.green("  \u2713") + " Initial commit created");
+      } catch {
+      }
+    }
+    try {
+      (0, import_node_child_process.execSync)("git push -u cv-hub main 2>&1", { cwd, stdio: "pipe", timeout: 3e4 });
+      console.log(source_default.green("  \u2713") + " Pushed to CV-Hub");
+    } catch {
+      console.log(source_default.gray("  (Push skipped \u2014 you can push later with: git push cv-hub main)"));
+    }
+  }
+  console.log();
+  let agentStatus = "";
+  const pidFile = (0, import_node_path.join)((0, import_node_os2.homedir)(), ".config", "controlvector", "agent.pid");
+  let agentRunning = false;
+  try {
+    const pid = parseInt((0, import_node_fs.readFileSync)(pidFile, "utf-8").trim(), 10);
+    if (pid > 0) {
+      process.kill(pid, 0);
+      agentRunning = true;
+      agentStatus = `running (PID ${pid})`;
+      console.log(source_default.green("  \u2713") + ` Agent already running (PID ${pid})`);
+    }
+  } catch {
+  }
+  if (!agentRunning) {
+    const readline = await import("node:readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve2) => {
+      rl.question("  Start the CV-Agent daemon? (Y/n): ", (a) => {
+        rl.close();
+        resolve2(a.trim().toLowerCase() || "y");
+      });
+    });
+    if (answer === "y" || answer === "yes" || answer === "") {
+      const machName = (0, import_node_os2.hostname)().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
+      console.log(source_default.gray(`  Starting agent as "${machName}"...`));
+      try {
+        const { spawn: spawnChild } = await import("node:child_process");
+        const child = spawnChild("cva", [
+          "agent",
+          "--auto-approve",
+          "--machine",
+          machName,
+          "--working-dir",
+          cwd
+        ], {
+          detached: true,
+          stdio: "ignore",
+          env: { ...process.env }
+        });
+        child.unref();
+        if (child.pid) {
+          (0, import_node_fs.mkdirSync)((0, import_node_path.join)((0, import_node_os2.homedir)(), ".config", "controlvector"), { recursive: true });
+          (0, import_node_fs.writeFileSync)(pidFile, String(child.pid), { mode: 384 });
+          agentStatus = `running (PID ${child.pid})`;
+          console.log(source_default.green("  \u2713") + ` Agent started (PID ${child.pid}) \u2014 executor "${machName}"`);
+        }
+      } catch (err) {
+        console.log(source_default.yellow(`  Could not start agent: ${err.message}`));
+        console.log(source_default.gray("  Start manually with: cva agent --auto-approve"));
+        agentStatus = "not started";
+      }
+    } else {
+      agentStatus = "not started";
+      console.log(source_default.gray("  Start anytime with: cva agent --auto-approve"));
+    }
   }
   console.log();
   console.log(source_default.bold("  Setup Complete"));
@@ -3818,11 +4325,14 @@ async function runSetup() {
   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`);
+  if (agentStatus.startsWith("running")) {
+    console.log(`  ${source_default.green("\u2713")} Agent daemon: ${source_default.cyan(agentStatus)}`);
+  }
   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("    Open Claude.ai and try:");
+  console.log(source_default.cyan(`    "Create a task in ${repoName} to add a hello world index.html"`));
   console.log();
   console.log(source_default.gray(`  Dashboard: ${appUrl}`));
   console.log();
@@ -3838,6 +4348,7 @@ function setupCommand() {
 var import_node_child_process5 = require("node:child_process");
 var os3 = __toESM(require("node:os"));
 var path2 = __toESM(require("node:path"));
+init_source();
 
 // src/utils/event-queue.ts
 var import_node_fs2 = require("node:fs");
@@ -3966,6 +4477,7 @@ function sleep(ms) {
 }
 
 // src/utils/api.ts
+init_source();
 async function apiCall(creds, method, path3, body) {
   const url = `${creds.CV_HUB_API}${path3}`;
   const headers = {
@@ -3978,7 +4490,16 @@ async function apiCall(creds, method, path3, body) {
     body: body ? JSON.stringify(body) : void 0
   });
 }
-async function registerExecutor(creds, machineName, workingDir, repositoryId, metadata) {
+async function registerExecutor(creds, machineName, workingDir, repositoryId, metadata, orgOptions) {
+  const {
+    resolveOrg: resolveOrg2,
+    resolveToUUID: resolveToUUID2,
+    pickOrg: pickOrg2,
+    confirmAutoMatch: confirmAutoMatch2,
+    promptPersistScope: promptPersistScope2,
+    persistOrg: persistOrg2,
+    parseMultiOrgError: parseMultiOrgError2
+  } = await Promise.resolve().then(() => (init_org_resolver(), org_resolver_exports));
   const body = {
     name: `cva:${machineName}`,
     machine_name: machineName,
@@ -3997,7 +4518,70 @@ async function registerExecutor(creds, machineName, workingDir, repositoryId, me
   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);
+  const resolved = resolveOrg2({
+    cliFlag: orgOptions?.cliFlag,
+    cwd: orgOptions?.cwd || workingDir
+  });
+  let res = await apiCall(creds, "POST", "/api/v1/executors", body);
+  if (res.status === 400) {
+    const errBody = await res.text();
+    const orgs = parseMultiOrgError2(res.status, errBody);
+    if (orgs) {
+      if (resolved.value) {
+        try {
+          const orgId = resolveToUUID2(resolved.value, orgs);
+          body.organization_id = orgId;
+          res = await apiCall(creds, "POST", "/api/v1/executors", body);
+        } catch (e) {
+          throw new Error(
+            `Organization "${resolved.value}" (from ${resolved.source}) is invalid. ${e.message}`
+          );
+        }
+      }
+      let autoMatchHandled = false;
+      if (!resolved.value && orgOptions?.repoOwnerSlug) {
+        const match = orgs.find(
+          (o) => o.slug.toLowerCase() === orgOptions.repoOwnerSlug.toLowerCase()
+        );
+        if (match) {
+          if (!process.stdout.isTTY) {
+            throw new Error(
+              `Auto-matched "${match.slug}" from repo owner, but running non-interactively. Set CV_HUB_ORG=${match.slug} or pass --org ${match.slug} to confirm, or pick a different org from: ${orgs.map((o) => o.slug).join(", ")}.`
+            );
+          }
+          const decision = await confirmAutoMatch2(match, orgOptions.repoOwnerSlug);
+          if (decision === "accept") {
+            const scope = await promptPersistScope2();
+            if (scope !== "none") {
+              const savedPath = persistOrg2(match.slug, scope, orgOptions?.cwd || workingDir);
+              console.log(source_default.gray(`  Saved to ${savedPath}`));
+            }
+            body.organization_id = match.id;
+            res = await apiCall(creds, "POST", "/api/v1/executors", body);
+            autoMatchHandled = true;
+          } else if (decision === "abort") {
+            throw new Error(
+              "Registration aborted. Set CV_HUB_ORG or use --org to choose an org non-interactively."
+            );
+          }
+        }
+      }
+      if (!autoMatchHandled && !res.ok) {
+        const picked = await pickOrg2(orgs, {
+          interactive: true,
+          cwd: orgOptions?.cwd || workingDir
+        });
+        if (picked.persistScope !== "none") {
+          const savedPath = persistOrg2(picked.chosen.slug, picked.persistScope, orgOptions?.cwd || workingDir);
+          console.log(source_default.gray(`  Saved to ${savedPath}`));
+        }
+        body.organization_id = picked.chosen.id;
+        res = await apiCall(creds, "POST", "/api/v1/executors", body);
+      }
+    } else {
+      throw new Error(`Failed to register executor: ${res.status} ${errBody}`);
+    }
+  }
   if (!res.ok) {
     const err = await res.text();
     throw new Error(`Failed to register executor: ${res.status} ${err}`);
@@ -4357,6 +4941,7 @@ function verifyGitRemote(cwd, task, gitHost) {
 }
 
 // src/utils/display.ts
+init_source();
 function formatDuration(ms) {
   const s = Math.floor(ms / 1e3);
   if (s < 60) return `${s}s`;
@@ -4393,6 +4978,7 @@ function updateStatusLine(idle, poll, completedCount, failedCount) {
 }
 
 // src/utils/retry.ts
+init_source();
 async function withRetry(fn, label, maxRetries = 3) {
   for (let i = 0; i < maxRetries; i++) {
     try {
@@ -4440,11 +5026,78 @@ async function writeConfig(config) {
 
 // src/commands/git-safety.ts
 var import_node_child_process3 = require("node:child_process");
+var import_node_fs4 = require("node:fs");
+var import_node_path3 = require("node:path");
+var import_node_os4 = require("node:os");
+var DANGEROUS_PATTERNS = [
+  ".claude/",
+  ".claude.json",
+  ".credentials",
+  ".zsh_history",
+  ".bash_history",
+  ".zsh_sessions/",
+  ".ssh/",
+  ".gnupg/",
+  ".npm/",
+  ".config/",
+  ".CFUserTextEncoding",
+  "Library/",
+  "Applications/",
+  ".Trash/",
+  ".DS_Store",
+  "node_modules/",
+  ".env",
+  ".env.local",
+  ".env.production"
+];
 function git(cmd, cwd) {
   return (0, import_node_child_process3.execSync)(cmd, { cwd, encoding: "utf8", timeout: 3e4 }).trim();
 }
+function checkWorkspaceSafety(workspaceRoot) {
+  const resolved = (0, import_node_path3.resolve)(workspaceRoot);
+  const home = (0, import_node_path3.resolve)((0, import_node_os4.homedir)());
+  if (resolved === home) {
+    return `Workspace is user HOME directory (${home}). Refusing to auto-commit to prevent indexing personal files.`;
+  }
+  if (home.startsWith(resolved + "/")) {
+    return `Workspace (${resolved}) is a parent of HOME. Refusing to auto-commit.`;
+  }
+  if (!(0, import_node_fs4.existsSync)((0, import_node_path3.join)(resolved, ".git"))) {
+    return `No .git directory in ${resolved}. Not a git repository.`;
+  }
+  return null;
+}
+function filterDangerousFiles(statusLines) {
+  const safe = [];
+  const blocked = [];
+  for (const line of statusLines) {
+    const filePath = line.substring(3).trim();
+    const isDangerous = DANGEROUS_PATTERNS.some(
+      (pattern) => filePath.startsWith(pattern) || filePath.includes("/" + pattern)
+    );
+    if (isDangerous) {
+      blocked.push(filePath);
+    } else {
+      safe.push(line);
+    }
+  }
+  return { safe, blocked };
+}
 function gitSafetyNet(workspaceRoot, taskTitle, taskId, branch) {
   const targetBranch = branch || "main";
+  const safetyError = checkWorkspaceSafety(workspaceRoot);
+  if (safetyError) {
+    console.log(`  [git-safety] BLOCKED: ${safetyError}`);
+    return {
+      hadChanges: false,
+      filesAdded: 0,
+      filesModified: 0,
+      filesDeleted: 0,
+      pushed: false,
+      skipped: true,
+      skipReason: safetyError
+    };
+  }
   try {
     let statusOutput;
     try {
@@ -4452,8 +5105,8 @@ function gitSafetyNet(workspaceRoot, taskTitle, taskId, branch) {
     } catch {
       return { hadChanges: false, filesAdded: 0, filesModified: 0, filesDeleted: 0, pushed: false, error: "git status failed" };
     }
-    const lines = statusOutput.split("\n").filter(Boolean);
-    if (lines.length === 0) {
+    const allLines = statusOutput.split("\n").filter(Boolean);
+    if (allLines.length === 0) {
       try {
         const unpushed = git(`git log origin/${targetBranch}..HEAD --oneline 2>/dev/null`, workspaceRoot);
         if (unpushed) {
@@ -4465,8 +5118,16 @@ function gitSafetyNet(workspaceRoot, taskTitle, taskId, branch) {
       }
       return { hadChanges: false, filesAdded: 0, filesModified: 0, filesDeleted: 0, pushed: false };
     }
+    const { safe: safeLines, blocked } = filterDangerousFiles(allLines);
+    if (blocked.length > 0) {
+      console.log(`  [git-safety] Blocked ${blocked.length} sensitive file(s) from staging: ${blocked.slice(0, 5).join(", ")}${blocked.length > 5 ? "..." : ""}`);
+    }
+    if (safeLines.length === 0) {
+      console.log(`  [git-safety] All ${allLines.length} changed files were blocked by safety filter`);
+      return { hadChanges: false, filesAdded: 0, filesModified: 0, filesDeleted: 0, pushed: false };
+    }
     let added = 0, modified = 0, deleted = 0;
-    for (const line of lines) {
+    for (const line of safeLines) {
       const code = line.substring(0, 2);
       if (code.includes("?")) added++;
       else if (code.includes("D")) deleted++;
@@ -4474,9 +5135,15 @@ function gitSafetyNet(workspaceRoot, taskTitle, taskId, branch) {
       else added++;
     }
     console.log(
-      `  [git-safety] ${lines.length} uncommitted changes (${added} new, ${modified} modified, ${deleted} deleted) \u2014 committing now`
+      `  [git-safety] ${safeLines.length} safe changes (${added} new, ${modified} modified, ${deleted} deleted) \u2014 committing now`
     );
-    git("git add -A", workspaceRoot);
+    for (const line of safeLines) {
+      const filePath = line.substring(3).trim();
+      try {
+        git(`git add -- ${JSON.stringify(filePath)}`, workspaceRoot);
+      } catch {
+      }
+    }
     const shortId = taskId.substring(0, 8);
     const commitMsg = `task: ${taskTitle} [${shortId}]
 
@@ -4537,8 +5204,8 @@ Files: ${added} added, ${modified} modified, ${deleted} deleted`;
 
 // src/commands/deploy-manifest.ts
 var import_node_child_process4 = require("node:child_process");
-var import_node_fs3 = require("node:fs");
-var import_node_path2 = require("node:path");
+var import_node_fs5 = require("node:fs");
+var import_node_path4 = require("node:path");
 function exec(cmd, cwd, timeoutMs = 3e5, env2) {
   try {
     const stdout = (0, import_node_child_process4.execSync)(cmd, {
@@ -4581,10 +5248,10 @@ function getHeadCommit(cwd) {
   }
 }
 function loadDeployManifest(workspaceRoot) {
-  const manifestPath = (0, import_node_path2.join)(workspaceRoot, ".cva", "deploy.json");
-  if (!(0, import_node_fs3.existsSync)(manifestPath)) return null;
+  const manifestPath = (0, import_node_path4.join)(workspaceRoot, ".cva", "deploy.json");
+  if (!(0, import_node_fs5.existsSync)(manifestPath)) return null;
   try {
-    const raw = (0, import_node_fs3.readFileSync)(manifestPath, "utf8");
+    const raw = (0, import_node_fs5.readFileSync)(manifestPath, "utf8");
     const manifest = JSON.parse(raw);
     if (!manifest.version || manifest.version < 1) {
       console.log("  [deploy] Invalid manifest version");
@@ -4609,7 +5276,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_path2.join)(workspaceRoot, buildStep.working_dir || ".");
+      const cwd = (0, import_node_path4.join)(workspaceRoot, buildStep.working_dir || ".");
       const timeoutMs = (buildStep.timeout_seconds || 300) * 1e3;
       const result = exec(buildStep.command, cwd, timeoutMs);
       if (!result.ok) {
@@ -4700,7 +5367,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_path2.join)(workspaceRoot, step.working_dir || "."), (step.timeout_seconds || 300) * 1e3);
+      exec(step.command, (0, import_node_path4.join)(workspaceRoot, step.working_dir || "."), (step.timeout_seconds || 300) * 1e3);
     }
   }
   if (manifest.service?.restart_command) {
@@ -4858,6 +5525,22 @@ Target repository: ${task.owner}/${task.repo}
 `;
   prompt += `
 
+## Security \u2014 NEVER Commit Secrets
+`;
+  prompt += `Do NOT add, commit, or push any of the following:
+`;
+  prompt += `- API keys, tokens, passwords, or credentials
+`;
+  prompt += `- .env files, .credentials files, .claude/ directory
+`;
+  prompt += `- SSH keys (.ssh/), GPG keys (.gnupg/)
+`;
+  prompt += `- Shell history (.zsh_history, .bash_history)
+`;
+  prompt += `If you need to reference an API key, use an environment variable placeholder.
+`;
+  prompt += `
+
 ---
 `;
   prompt += `When complete, provide a brief summary of what you accomplished.
@@ -4937,7 +5620,7 @@ async function launchAutoApproveMode(prompt, options) {
   let lastProgressBytes = 0;
   let totalBytesStreamed = 0;
   const runOnce = (inputPrompt, isContinue) => {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const args = isContinue ? ["-p", inputPrompt, "--continue", "--allowedTools", ...ALLOWED_TOOLS] : ["-p", inputPrompt, "--allowedTools", ...ALLOWED_TOOLS];
       if (sessionId && !isContinue) {
         args.push("--session-id", sessionId);
@@ -5047,7 +5730,7 @@ ${source_default.red("!")} Claude Code auth failure (stderr): "${authError}"`);
       });
       child.on("close", (code, signal) => {
         _activeChild = null;
-        resolve({
+        resolve2({
           exitCode: signal === "SIGKILL" ? 137 : code ?? 1,
           stderr,
           output: fullOutput,
@@ -5086,7 +5769,7 @@ ${source_default.red("!")} Claude Code auth failure (stderr): "${authError}"`);
   return result;
 }
 async function launchRelayMode(prompt, options) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const child = (0, import_node_child_process5.spawn)("claude", [], {
       cwd: options.cwd,
       stdio: ["pipe", "pipe", "pipe"],
@@ -5291,9 +5974,9 @@ ${source_default.red("!")} Claude Code auth failure (stderr): "${authError}"`);
     child.on("close", (code, signal) => {
       _activeChild = null;
       if (signal === "SIGKILL") {
-        resolve({ exitCode: 137, stderr, output: fullOutput, authFailure });
+        resolve2({ exitCode: 137, stderr, output: fullOutput, authFailure });
       } else {
-        resolve({ exitCode: code ?? 1, stderr, output: fullOutput, authFailure });
+        resolve2({ exitCode: code ?? 1, stderr, output: fullOutput, authFailure });
       }
     });
     child.on("error", (err) => {
@@ -5394,14 +6077,45 @@ async function runAgent(options) {
     console.log();
     process.exit(1);
   }
+  if (process.env.CV_DEBUG) {
+    console.log(source_default.gray(`   PATH: ${process.env.PATH}`));
+    console.log(source_default.gray(`   HOME: ${process.env.HOME}`));
+    console.log(source_default.gray(`   SHELL: ${process.env.SHELL}`));
+  }
+  let claudeBinary = "claude";
   try {
     (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:");
-    console.log(`   ${source_default.cyan("npm install -g @anthropic-ai/claude-code")}`);
-    console.log();
-    process.exit(1);
+    const candidates = [
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude",
+      `${process.env.HOME}/.npm-global/bin/claude`,
+      `${process.env.HOME}/.nvm/versions/node/*/bin/claude`
+    ];
+    let found = false;
+    for (const candidate of candidates) {
+      try {
+        const resolved = (0, import_node_child_process5.execSync)(`ls ${candidate} 2>/dev/null | head -1`, { encoding: "utf8", timeout: 3e3 }).trim();
+        if (resolved) {
+          (0, import_node_child_process5.execSync)(`${resolved} --version`, { stdio: "pipe", timeout: 5e3 });
+          claudeBinary = resolved;
+          found = true;
+          console.log(source_default.yellow("!") + ` Claude Code found at ${resolved} (not on PATH)`);
+          break;
+        }
+      } catch {
+      }
+    }
+    if (!found) {
+      console.log();
+      console.log(source_default.red("Claude Code CLI not found.") + " Install it first:");
+      console.log(`   ${source_default.cyan("npm install -g @anthropic-ai/claude-code")}`);
+      console.log();
+      console.log(source_default.gray(`   Current PATH: ${process.env.PATH}`));
+      console.log(source_default.gray("   If running via Launch Agent, ensure PATH includes the directory where claude is installed."));
+      console.log();
+      process.exit(1);
+    }
   }
   const { env: claudeEnv, usingApiKey } = await getClaudeEnv();
   const authCheck = await checkClaudeAuth();
@@ -5442,7 +6156,82 @@ async function runAgent(options) {
       console.log();
     }
   }
+  {
+    const isGitRepo = require("fs").existsSync(require("path").join(workingDir, ".git"));
+    if (!isGitRepo) {
+      console.log(source_default.gray("   Bootstrap: initializing git repo..."));
+      try {
+        (0, import_node_child_process5.execSync)("git init && git checkout -b main", { cwd: workingDir, stdio: "pipe" });
+      } catch {
+      }
+    }
+    const claudeMdPath = require("path").join(workingDir, "CLAUDE.md");
+    if (!require("fs").existsSync(claudeMdPath)) {
+      const name = require("path").basename(workingDir);
+      const template = `# ${name}
+
+## Overview
+[Describe your project here]
+
+## Build & Run
+[How to build and run this project]
+`;
+      try {
+        require("fs").writeFileSync(claudeMdPath, template);
+        console.log(source_default.gray("   Bootstrap: created CLAUDE.md"));
+      } catch {
+      }
+    }
+    const gitignorePath = require("path").join(workingDir, ".gitignore");
+    try {
+      const fs4 = require("fs");
+      const credPatterns = ".env\n.env.*\n.claude/\n.claude.json\n.credentials*\n*.pem\n*.key\n.ssh/\n.gnupg/\n.npm/\n.config/\n.zsh_history\n.bash_history\nnode_modules/\n.DS_Store\n";
+      let existing = "";
+      try {
+        existing = fs4.readFileSync(gitignorePath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes(".claude/")) {
+        const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
+        fs4.writeFileSync(gitignorePath, existing + prefix + "# Credentials (auto-added by cv-agent)\n" + credPatterns);
+        console.log(source_default.gray("   Bootstrap: .gitignore credential protection added"));
+      }
+    } catch {
+    }
+    const cvDir = require("path").join(workingDir, ".cv");
+    if (!require("fs").existsSync(cvDir)) {
+      try {
+        require("fs").mkdirSync(cvDir, { recursive: true });
+      } catch {
+      }
+    }
+    if (creds.CV_HUB_PAT) {
+      try {
+        const existing = (0, import_node_child_process5.execSync)('git remote get-url cv-hub 2>/dev/null || echo ""', {
+          cwd: workingDir,
+          encoding: "utf8",
+          timeout: 5e3
+        }).trim();
+        if (!existing) {
+          const name = require("path").basename(workingDir);
+          const gitHost = "git.hub.controlvector.io";
+          let user = "user";
+          try {
+            const sharedPath = require("path").join(require("os").homedir(), ".config", "controlvector", "credentials.json");
+            const shared = JSON.parse(require("fs").readFileSync(sharedPath, "utf-8"));
+            if (shared.username) user = shared.username;
+          } catch {
+          }
+          const remoteUrl = `https://${gitHost}/${user}/${name}.git`;
+          (0, import_node_child_process5.execSync)(`git remote add cv-hub ${remoteUrl}`, { cwd: workingDir, stdio: "pipe" });
+          console.log(source_default.gray(`   Bootstrap: remote cv-hub \u2192 ${remoteUrl}`));
+        }
+      } catch {
+      }
+    }
+  }
   let detectedRepoId;
+  let detectedOwnerSlug;
   try {
     const remoteUrl = (0, import_node_child_process5.execSync)("git remote get-url origin 2>/dev/null", {
       cwd: workingDir,
@@ -5454,6 +6243,7 @@ async function runAgent(options) {
     );
     if (cvHubMatch) {
       const [, repoOwner, repoSlug] = cvHubMatch;
+      detectedOwnerSlug = repoOwner;
       try {
         const repoData = await resolveRepoId(creds, repoOwner, repoSlug);
         if (repoData?.id) {
@@ -5465,6 +6255,9 @@ async function runAgent(options) {
     }
   } catch {
   }
+  if (options.org) {
+    detectedOwnerSlug = options.org;
+  }
   const wsConfig = await readWorkspaceConfig(workingDir);
   const globalConfig = await readConfig();
   const role = options.role || wsConfig.role || globalConfig.role || "development";
@@ -5505,7 +6298,11 @@ async function runAgent(options) {
     console.log(source_default.yellow(`   Guard:    ${guardIcon} ${dispatchGuard}`));
   }
   const executor = await withRetry(
-    () => registerExecutor(creds, machineName, workingDir, detectedRepoId, executorMeta),
+    () => registerExecutor(creds, machineName, workingDir, detectedRepoId, executorMeta, {
+      cliFlag: options.org,
+      repoOwnerSlug: detectedOwnerSlug,
+      cwd: workingDir
+    }),
     "Executor registration"
   );
   const mode = options.autoApprove ? "auto-approve" : "relay";
@@ -5873,6 +6670,7 @@ function agentCommand() {
   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.option("--org <slug>", "Organization slug (auto-detected from repo owner if omitted)");
   cmd.action(async (opts) => {
     await runAgent(opts);
   });
@@ -5880,6 +6678,7 @@ function agentCommand() {
 }
 
 // src/commands/auth.ts
+init_source();
 async function authLogin(opts) {
   const token = opts.token || await promptForToken();
   const apiUrl = opts.apiUrl || "https://api.hub.controlvector.io";
@@ -5909,7 +6708,7 @@ async function promptForToken() {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question("Enter your CV-Hub PAT token: ", (answer) => {
       rl.close();
       const token = answer.trim();
@@ -5917,7 +6716,7 @@ async function promptForToken() {
         console.log(source_default.red("No token provided."));
         process.exit(1);
       }
-      resolve(token);
+      resolve2(token);
     });
   });
 }
@@ -5981,6 +6780,7 @@ function authCommand() {
 
 // src/commands/remote.ts
 var import_node_child_process6 = require("node:child_process");
+init_source();
 function getGitHost(apiUrl) {
   return apiUrl.replace(/^https?:\/\//, "").replace(/^api\./, "git.");
 }
@@ -6049,6 +6849,7 @@ function remoteCommand() {
 }
 
 // src/commands/task.ts
+init_source();
 async function taskList(opts) {
   const creds = await readCredentials();
   if (!creds.CV_HUB_PAT) {
@@ -6140,6 +6941,7 @@ function taskCommand() {
 }
 
 // src/commands/status.ts
+init_source();
 async function showStatus() {
   const creds = await readCredentials();
   if (!creds.CV_HUB_PAT) {
@@ -6196,7 +6998,7 @@ 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.\n\nRun "cva setup" to get started.').version(true ? "1.10.0" : "1.6.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.11.0" : "1.6.0");
 program2.addCommand(setupCommand());
 program2.addCommand(agentCommand());
 program2.addCommand(authCommand());