delegate-team 2.0.0

package/dist/cli.js

@@ -0,0 +1,864 @@
+#!/usr/bin/env node
+import {
+  DELEGATE_TEAM_PATH,
+  RELAY_SCRIPT,
+  ROUTER_SCRIPT,
+  VERTEX_CODER_PATH,
+  VERTEX_DIRECT_SCRIPT,
+  VERTEX_INTERACTIVE_SCRIPT,
+  VERTEX_VENV_PYTHON,
+  runServe
+} from "./chunk-VTAPBAJE.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/check.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/utils/index.ts
+import { spawnSync } from "child_process";
+var C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m"
+};
+function runCmd(command, args = []) {
+  try {
+    const res = spawnSync(command, args, { encoding: "utf8" });
+    return { status: res.status, stdout: res.stdout || "", stderr: res.stderr || "" };
+  } catch (err) {
+    return { status: -1, stdout: "", stderr: err.message };
+  }
+}
+
+// src/commands/check.ts
+import { spawnSync as spawnSync2 } from "child_process";
+function runCheck(strict = false) {
+  console.log(`
+${C.bold}${C.cyan}\u{1F50D} Scanning Backend Systems Health & Authentication Status...${C.reset}
+`);
+  const results = [];
+  const gcloudCheck = runCmd("gcloud", ["auth", "print-access-token"]);
+  const gcloudAccount = runCmd("gcloud", ["config", "get-value", "account"]);
+  const vertexPythonCheck = existsSync(VERTEX_VENV_PYTHON);
+  let vertexSdkCheck = false;
+  if (vertexPythonCheck) {
+    const pyRes = spawnSync2(VERTEX_VENV_PYTHON, ["-c", "import google.genai"], { encoding: "utf8" });
+    vertexSdkCheck = pyRes.status === 0;
+  }
+  const isVertexReady = gcloudCheck.status === 0 && vertexPythonCheck && vertexSdkCheck;
+  results.push({
+    backend: "vertexcoder",
+    binary: vertexPythonCheck ? `Python venv \u2705` : `venv Missing \u274C`,
+    auth: gcloudCheck.status === 0 ? `GCP Active: ${gcloudAccount.stdout.trim()}` : `gcloud NOT Logged In \u274C`,
+    status: isVertexReady ? `${C.green}READY \u2705${C.reset}` : `${C.red}NOT READY \u274C${C.reset}`
+  });
+  const codexBin = runCmd("which", ["codex"]);
+  const codexConfig = existsSync(join(homedir(), ".codex-delegate", "config.toml"));
+  results.push({
+    backend: "codex",
+    binary: codexBin.status === 0 ? `Installed \u2705` : `Missing \u274C`,
+    auth: codexConfig ? `config.toml Present \u2705` : `~/.codex-delegate/config.toml Missing \u274C`,
+    status: codexBin.status === 0 && codexConfig ? `${C.green}READY \u2705${C.reset}` : `${C.yellow}UNCONFIGURED \u26A0\uFE0F${C.reset}`
+  });
+  const minimaxBin = runCmd("which", ["claude"]);
+  const minimaxConfig = existsSync(join(homedir(), ".minimax", ".env"));
+  results.push({
+    backend: "minimax",
+    binary: minimaxBin.status === 0 ? `Installed (claude) \u2705` : `Missing \u274C`,
+    auth: minimaxConfig ? `.env Present \u2705` : `~/.minimax/.env Missing \u274C`,
+    status: minimaxBin.status === 0 && minimaxConfig ? `${C.green}READY \u2705${C.reset}` : `${C.yellow}UNCONFIGURED \u26A0\uFE0F${C.reset}`
+  });
+  const opencodeBin = runCmd("which", ["opencode"]);
+  const opencodeConfig = existsSync(join(homedir(), ".local", "share", "opencode", "auth.json"));
+  results.push({
+    backend: "opencode",
+    binary: opencodeBin.status === 0 ? `Installed \u2705` : `Missing \u274C`,
+    auth: opencodeConfig ? `auth.json Present \u2705` : `auth.json Missing \u274C`,
+    status: opencodeBin.status === 0 && opencodeConfig ? `${C.green}READY \u2705${C.reset}` : `${C.yellow}UNCONFIGURED \u26A0\uFE0F${C.reset}`
+  });
+  const geminiBin = runCmd("which", ["gemini"]);
+  const geminiConfig = existsSync(join(homedir(), ".gemini", ".env"));
+  results.push({
+    backend: "gemini",
+    binary: geminiBin.status === 0 ? `Installed \u2705` : `Missing \u274C`,
+    auth: geminiConfig ? `.env Present \u2705` : `~/.gemini/.env Missing \u274C`,
+    status: geminiBin.status === 0 && geminiConfig ? `${C.green}READY \u2705${C.reset}` : `${C.yellow}UNCONFIGURED \u26A0\uFE0F${C.reset}`
+  });
+  results.push({
+    backend: "openrouter",
+    binary: opencodeBin.status === 0 ? `Installed (opencode) \u2705` : `Missing \u274C`,
+    auth: existsSync(join(homedir(), ".openrouter", ".env")) ? `.env Present \u2705` : `~/.openrouter/.env Missing \u274C`,
+    status: opencodeBin.status === 0 && existsSync(join(homedir(), ".openrouter", ".env")) ? `${C.green}READY \u2705${C.reset}` : `${C.yellow}UNCONFIGURED \u26A0\uFE0F${C.reset}`
+  });
+  console.log(`${C.bold}${"Backend".padEnd(15)} | ${"Binary / SDK".padEnd(23)} | ${"Config / Credentials".padEnd(45)} | Status${C.reset}`);
+  console.log("-".repeat(95));
+  for (const row of results) {
+    console.log(`${C.bold}${C.cyan}${row.backend.padEnd(15)}${C.reset} | ${row.binary.padEnd(23)} | ${row.auth.padEnd(45)} | ${row.status}`);
+  }
+  console.log("\n");
+  if (strict) {
+    const anyReady = results.some((r) => r.status.includes("READY \u2705"));
+    if (!anyReady) {
+      process.exit(1);
+    }
+  }
+}
+
+// src/commands/setup.ts
+import { existsSync as existsSync2, mkdirSync, rmSync, symlinkSync, writeFileSync, lstatSync, readlinkSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { spawnSync as spawnSync3 } from "child_process";
+import readline from "readline";
+import { randomBytes } from "crypto";
+function runLinkSkill() {
+  console.log(`
+${C.bold}${C.cyan}\u{1F517} Symlinking Agent Skills to Local Systems...${C.reset}`);
+  const agentSkillsDir = join2(homedir2(), ".agents", "skills");
+  const geminiSkillsDir = join2(homedir2(), ".gemini", "config", "skills");
+  const skillDirs = [agentSkillsDir, geminiSkillsDir];
+  runCmd("chmod", ["+x", RELAY_SCRIPT]);
+  runCmd("chmod", ["+x", VERTEX_DIRECT_SCRIPT]);
+  runCmd("chmod", ["+x", VERTEX_INTERACTIVE_SCRIPT]);
+  runCmd("chmod", ["+x", join2(DELEGATE_TEAM_PATH, "scripts", "opencode-router.mjs")]);
+  let linkedCount = 0;
+  for (const dir of skillDirs) {
+    if (!existsSync2(dir)) {
+      try {
+        mkdirSync(dir, { recursive: true });
+        console.log(`${C.dim}Created skills directory: ${dir}${C.reset}`);
+      } catch (err) {
+        console.error(`${C.red}Failed to create skills directory ${dir}: ${err.message}${C.reset}`);
+        continue;
+      }
+    }
+    const delTarget = join2(dir, "delegate-team");
+    const vtxTarget = join2(dir, "vertex-coder");
+    try {
+      let shouldLink = true;
+      try {
+        const stat = lstatSync(delTarget);
+        if (stat.isSymbolicLink()) {
+          const target = readlinkSync(delTarget);
+          if (target === DELEGATE_TEAM_PATH) {
+            shouldLink = false;
+          } else {
+            rmSync(delTarget, { force: true });
+          }
+        } else {
+          console.log(`  ${C.yellow}\u26A0\uFE0F  Directory ${delTarget} exists and is not a symlink. Skipping to prevent data loss.${C.reset}`);
+          shouldLink = false;
+        }
+      } catch (e) {
+      }
+      if (shouldLink) {
+        symlinkSync(DELEGATE_TEAM_PATH, delTarget, "dir");
+        console.log(`  ${C.green}\u2705 Linked delegate-team${C.reset} -> ${C.dim}${dir}/delegate-team${C.reset}`);
+        linkedCount++;
+      }
+    } catch (err) {
+      console.error(`  ${C.red}\u274C Failed link delegate-team to ${dir}: ${err.message}${C.reset}`);
+    }
+    try {
+      let shouldLink = true;
+      try {
+        const stat = lstatSync(vtxTarget);
+        if (stat.isSymbolicLink()) {
+          const target = readlinkSync(vtxTarget);
+          if (target === VERTEX_CODER_PATH) {
+            shouldLink = false;
+          } else {
+            rmSync(vtxTarget, { force: true });
+          }
+        } else {
+          console.log(`  ${C.yellow}\u26A0\uFE0F  Directory ${vtxTarget} exists and is not a symlink. Skipping to prevent data loss.${C.reset}`);
+          shouldLink = false;
+        }
+      } catch (e) {
+      }
+      if (shouldLink) {
+        symlinkSync(VERTEX_CODER_PATH, vtxTarget, "dir");
+        console.log(`  ${C.green}\u2705 Linked vertex-coder${C.reset}  -> ${C.dim}${dir}/vertex-coder${C.reset}`);
+        linkedCount++;
+      }
+    } catch (err) {
+      console.error(`  ${C.red}\u274C Failed link vertex-coder to ${dir}: ${err.message}${C.reset}`);
+    }
+  }
+  if (linkedCount > 0) {
+    console.log(`
+${C.bold}${C.green}\u{1F389} Skill registration completed successfully! (${linkedCount} symlinks updated)${C.reset}
+`);
+  } else {
+    console.error(`
+${C.bold}${C.red}\u26A0\uFE0F  Skill registration completed with errors.${C.reset}
+`);
+  }
+}
+async function runSetup() {
+  console.log(`
+${C.bold}${C.cyan}\u{1F680} Initiating Autopilot Onboarding Setup Wizard...${C.reset}`);
+  console.log(`${C.dim}This wizard will configure your local environment, authentications, and cloud projects automatically.${C.reset}
+`);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const ask = (query) => new Promise((resolve) => rl.question(query, resolve));
+  const proxyToken = "dt-local-" + randomBytes(8).toString("hex");
+  console.log(`${C.bold}\u{1F4E6} [Step 1/6] Setting up Python Virtual Environment...${C.reset}`);
+  const venvDir = join2(VERTEX_CODER_PATH, ".venv");
+  if (!existsSync2(venvDir)) {
+    console.log(`  ${C.dim}Virtual environment (.venv) not found. Creating a new one...${C.reset}`);
+    let pythonCmd = "python3";
+    const py311Check = spawnSync3("which", ["python3.11"]);
+    if (py311Check.status === 0) {
+      pythonCmd = "python3.11";
+      console.log(`  ${C.dim}Using ${pythonCmd} for compatibility...${C.reset}`);
+    }
+    const venvProc = spawnSync3(pythonCmd, ["-m", "venv", venvDir], { stdio: "inherit" });
+    if (venvProc.status !== 0) {
+      console.error(`  ${C.red}\u274C Failed to create virtual environment. Please install python3-venv.${C.reset}`);
+      rl.close();
+      process.exit(1);
+    }
+    console.log(`  ${C.green}\u2705 Virtual environment created at: ${venvDir}${C.reset}`);
+  } else {
+    console.log(`  ${C.green}\u2705 Existing virtual environment detected.${C.reset}`);
+  }
+  console.log(`  ${C.dim}Installing required Python dependencies...${C.reset}`);
+  const pipPath = join2(venvDir, "bin", "pip");
+  const pipProc = spawnSync3(pipPath, ["install", "--upgrade", "pip", "google-genai", "google-cloud-dialogflow-cx", "google-auth-oauthlib", "pytest"], { stdio: "inherit" });
+  if (pipProc.status !== 0) {
+    console.error(`  ${C.red}\u274C Failed to install core Python dependencies.${C.reset}`);
+    rl.close();
+    process.exit(1);
+  }
+  console.log(`  ${C.green}\u2705 Core Python dependencies installed successfully!${C.reset}
+`);
+  console.log(`  ${C.dim}Attempting to install MetaGPT (requires Python <= 3.11)...${C.reset}`);
+  const metagptProc = spawnSync3(pipPath, ["install", "metagpt"], { stdio: "inherit" });
+  if (metagptProc.status !== 0) {
+    console.log(`  ${C.yellow}\u26A0\uFE0F  MetaGPT installation skipped (often due to Python 3.12+ or Apple Silicon faiss-cpu issues). You can install it manually later if needed.${C.reset}
+`);
+  } else {
+    console.log(`  ${C.green}\u2705 MetaGPT installed successfully!${C.reset}
+`);
+  }
+  console.log(`${C.bold}\u{1F511} [Step 2/6] Verifying Google Cloud SDK (gcloud)...${C.reset}`);
+  const gcloudBinCheck = runCmd("which", ["gcloud"]);
+  if (gcloudBinCheck.status !== 0) {
+    console.log(`  ${C.yellow}\u26A0\uFE0F  Google Cloud CLI (gcloud) was not found in your system PATH.${C.reset}`);
+    console.log(`  ${C.dim}To use Vertex AI, you need to install gcloud. Follow instructions at: https://cloud.google.com/sdk/docs/install${C.reset}`);
+    const proceed = await ask(`  Do you want to skip gcloud checks and continue setting up other components? (y/N): `);
+    if (proceed.trim().toLowerCase() !== "y") {
+      rl.close();
+      process.exit(127);
+    }
+    console.log(`  ${C.dim}Skipping gcloud verification...${C.reset}
+`);
+  } else {
+    console.log(`  ${C.green}\u2705 Google Cloud CLI detected.${C.reset}
+`);
+  }
+  if (gcloudBinCheck.status === 0) {
+    console.log(`${C.bold}\u{1F510} [Step 3/6] Authenticating with Google Cloud...${C.reset}`);
+    const loginChoice = await ask(`  Would you like to log in to gcloud and set up application credentials now? (Y/n): `);
+    if (loginChoice.trim().toLowerCase() !== "n") {
+      await runAuth();
+    } else {
+      console.log(`  ${C.dim}Skipping active authentication...${C.reset}\\n`);
+    }
+  }
+  let selectedProjectId = "";
+  if (gcloudBinCheck.status === 0) {
+    console.log(`${C.bold}\u{1F4BC} [Step 4/6] Resolving Google Cloud Project ID...${C.reset}`);
+    console.log(`  ${C.dim}Fetching active projects from your account...${C.reset}`);
+    const projectsProc = spawnSync3("gcloud", ["projects", "list", "--format=json"], { encoding: "utf8" });
+    let projects = [];
+    if (projectsProc.status === 0) {
+      try {
+        projects = JSON.parse(projectsProc.stdout.trim());
+      } catch (err) {
+      }
+    }
+    if (projects.length > 0) {
+      console.log(`
+  ${C.bold}Available GCP Projects:${C.reset}`);
+      for (let i = 0; i < projects.length; i++) {
+        console.log(`  [${i + 1}] ${C.cyan}${projects[i].projectId}${C.reset} (${projects[i].name || "N/A"})`);
+      }
+      console.log(`  [${projects.length + 1}] Enter Project ID Manually`);
+      const pChoice = await ask(`
+  Select a project by number (1-${projects.length + 1}): `);
+      const choiceIdx = parseInt(pChoice.trim(), 10) - 1;
+      if (choiceIdx >= 0 && choiceIdx < projects.length) {
+        selectedProjectId = projects[choiceIdx].projectId;
+      }
+    }
+    if (!selectedProjectId) {
+      const manualProj = await ask(`  Enter your Google Cloud Project ID manually: `);
+      selectedProjectId = manualProj.trim();
+    }
+    if (!selectedProjectId) {
+      console.error(`  ${C.red}\u274C No Project ID provided. Setup aborted.${C.reset}`);
+      rl.close();
+      process.exit(1);
+    }
+    console.log(`  ${C.green}\u{1F3AF} Bound to GCP Project: ${C.bold}${selectedProjectId}${C.reset}
+`);
+  } else {
+    const manualProj = await ask(`\u{1F4BC} [Step 4/6] Enter your Google Cloud Project ID manually: `);
+    selectedProjectId = manualProj.trim();
+    if (!selectedProjectId) {
+      console.error(`  ${C.red}\u274C No Project ID provided. Setup aborted.${C.reset}`);
+      rl.close();
+      process.exit(1);
+    }
+  }
+  if (gcloudBinCheck.status === 0) {
+    console.log(`${C.bold}\u2699\uFE0F  [Step 5/6] Enabling APIs & Provisioning Agent...${C.reset}`);
+    const apiChoice = await ask(`  Do you want to automatically enable Vertex AI & Dialogflow APIs in project '${selectedProjectId}'? (Y/n): `);
+    if (apiChoice.trim().toLowerCase() !== "n") {
+      await runGcpEnable(selectedProjectId);
+    }
+    const configDir2 = join2(homedir2(), ".config", "dt");
+    if (!existsSync2(configDir2)) {
+      mkdirSync(configDir2, { recursive: true });
+    }
+    const configPath2 = join2(configDir2, "config.json");
+    const configData2 = {
+      project_id: selectedProjectId,
+      location: "us-central1",
+      proxy_token: proxyToken
+    };
+    writeFileSync(configPath2, JSON.stringify(configData2, null, 2), "utf8");
+    const provisionChoice = await ask(`  Do you want to provision the dt agent on GCP? (Y/n): `);
+    if (provisionChoice.trim().toLowerCase() !== "n") {
+      await runVertexProvision();
+    }
+  } else {
+    console.log(`${C.bold}\u2699\uFE0F  [Step 5/6] Skipping API enablement & Agent provisioning (no gcloud).${C.reset}\\n`);
+  }
+  console.log(`${C.bold}\u{1F517} [Step 6/6] Linking Agent Skills & Writing Global Configuration...${C.reset}`);
+  runLinkSkill();
+  const configDir = join2(homedir2(), ".config", "dt");
+  if (!existsSync2(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  const configPath = join2(configDir, "config.json");
+  const configData = {
+    project_id: selectedProjectId,
+    location: "us-central1",
+    proxy_token: proxyToken
+  };
+  writeFileSync(configPath, JSON.stringify(configData, null, 2), "utf8");
+  console.log(`  ${C.green}\u{1F4BE} Written configuration to: ${C.dim}${configPath}${C.reset}`);
+  const metagptDir = join2(homedir2(), ".metagpt");
+  if (!existsSync2(metagptDir)) {
+    mkdirSync(metagptDir, { recursive: true });
+  }
+  const metagptConfigPath = join2(metagptDir, "config2.yaml");
+  const metagptConfigContent = `llm:
+  api_type: "openai"
+  base_url: "http://127.0.0.1:3000/v1"
+  api_key: "${proxyToken}"
+  model: "google/gemini-3.1-pro-custom-tools"
+`;
+  writeFileSync(metagptConfigPath, metagptConfigContent, "utf8");
+  console.log(`  ${C.green}\u{1F4BE} Written MetaGPT configuration to: ${C.dim}${metagptConfigPath}${C.reset}`);
+  console.log(`
+${C.bold}${C.green}\u{1F389} CONGRATULATIONS! AUTOPILOT SETUP COMPLETED SUCCESSFULLY!${C.reset}
+--------------------------------------------------------------
+${C.bold}Your settings:${C.reset}
+  \u{1F3AF} Bound Project: ${C.bold}${C.cyan}${selectedProjectId}${C.reset}
+  \u{1F4CD} Location:      ${C.bold}${C.cyan}us-central1${C.reset}
+  \u{1F4BC} Python env:    ${C.dim}${venvDir}${C.reset}
+  \u{1F4C2} Config Path:   ${C.dim}${configPath}${C.reset}
+
+${C.bold}Ready commands:${C.reset}
+  ${C.cyan}dt check${C.reset}                        Check status of all backends
+  ${C.cyan}dt vx interactive "prompt"${C.reset}     Launch Interactive Vertex Coding Agent
+  ${C.cyan}dt run "prompt"${C.reset}                Dispatch task with routing and failover
+
+Thank you for using dt / delegate-team!
+  `);
+  rl.close();
+}
+async function runAuth() {
+  console.log(`
+${C.bold}${C.cyan}\u{1F510} Authenticating with Google Cloud...${C.reset}`);
+  console.log(`  ${C.dim}Opening browser for user authentication...${C.reset}`);
+  const loginProc = spawnSync3("gcloud", ["auth", "login"], { stdio: "inherit" });
+  if (loginProc.status !== 0) throw new Error("gcloud auth login failed");
+  console.log(`
+  ${C.dim}Opening browser for application-default credentials (ADC) authentication...${C.reset}`);
+  const adcProc = spawnSync3("gcloud", ["auth", "application-default", "login"], { stdio: "inherit" });
+  if (adcProc.status !== 0) throw new Error("gcloud auth application-default login failed");
+  console.log(`  ${C.green}\u2705 Google Cloud authentication completed.${C.reset}
+`);
+}
+async function runGcpEnable(projectId) {
+  console.log(`
+${C.bold}${C.cyan}\u2699\uFE0F  Enabling APIs in project '${projectId}'...${C.reset}`);
+  console.log(`  ${C.dim}Enabling Vertex AI API...${C.reset}`);
+  const aiProc = spawnSync3("gcloud", ["services", "enable", "aiplatform.googleapis.com", "--project", projectId], { stdio: "inherit" });
+  if (aiProc.status !== 0) throw new Error("Failed to enable aiplatform.googleapis.com");
+  console.log(`  ${C.dim}Enabling Dialogflow API...${C.reset}`);
+  const dfProc = spawnSync3("gcloud", ["services", "enable", "dialogflow.googleapis.com", "--project", projectId], { stdio: "inherit" });
+  if (dfProc.status !== 0) throw new Error("Failed to enable dialogflow.googleapis.com");
+  console.log(`  ${C.green}\u2705 GCP APIs enabled successfully.${C.reset}
+`);
+}
+async function runVertexProvision() {
+  console.log(`
+${C.bold}${C.cyan}\u{1F916} Provisioning Vertex AI Agent...${C.reset}`);
+  console.log(`  ${C.dim}Running vertex-coder provisioner...${C.reset}`);
+  const provisionScript = join2(VERTEX_CODER_PATH, "provision_agent.py");
+  const pythonPath = VERTEX_VENV_PYTHON;
+  if (!existsSync2(pythonPath)) {
+    console.error(`  ${C.red}\u274C Python virtual environment not found at ${pythonPath}. Please run 'dt setup' first.${C.reset}`);
+    process.exit(1);
+  }
+  if (!existsSync2(provisionScript)) {
+    console.error(`  ${C.red}\u274C Provision script not found at ${provisionScript}.${C.reset}`);
+    process.exit(1);
+  }
+  const proc = spawnSync3(pythonPath, [provisionScript], { stdio: "inherit" });
+  if (proc.status === 0) {
+    console.log(`  ${C.green}\u2705 Vertex AI Agent provisioned successfully.${C.reset}
+`);
+  } else {
+    console.error(`  ${C.red}\u274C Failed to provision Vertex AI Agent.${C.reset}
+`);
+    throw new Error("Vertex AI Agent provisioning failed");
+  }
+}
+
+// src/commands/run.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { unlinkSync } from "fs";
+import { join as join3 } from "path";
+import { tmpdir } from "os";
+import { spawnSync as spawnSync4 } from "child_process";
+
+// src/fallback/ring.ts
+var FALLBACK_RING = {
+  codex: ["vertexcoder", "minimax", "opencode", "gemini"],
+  minimax: ["vertexcoder", "codex", "opencode", "gemini"],
+  opencode: ["vertexcoder", "codex", "minimax", "gemini"],
+  vertexcoder: ["codex", "minimax", "opencode", "gemini"],
+  gemini: ["vertexcoder", "codex", "minimax", "opencode"],
+  openrouter: ["vertexcoder", "codex", "minimax", "opencode", "gemini"]
+};
+
+// src/commands/run.ts
+function runVertex(mode, args) {
+  if (!existsSync3(VERTEX_VENV_PYTHON)) {
+    console.error(`${C.bold}${C.red}Error: Python virtual environment (.venv) not found at: ${VERTEX_VENV_PYTHON}${C.reset}`);
+    console.error(`${C.dim}Please verify your vertex-coder setup or re-run 'dt check' to inspect.${C.reset}`);
+    process.exit(127);
+  }
+  if (mode === "direct") {
+    if (args.length < 2) {
+      console.error(`${C.bold}${C.red}Usage: dt vx direct <file_path> "<prompt>" [model]${C.reset}`);
+      process.exit(2);
+    }
+    const proc = spawnSync4(VERTEX_VENV_PYTHON, [VERTEX_DIRECT_SCRIPT, ...args], { stdio: "inherit" });
+    process.exit(proc.status ?? 1);
+  } else if (mode === "interactive") {
+    if (args.length < 1) {
+      console.error(`${C.bold}${C.red}Usage: dt vx interactive "<complex_prompt>" [model]${C.reset}`);
+      process.exit(2);
+    }
+    const proc = spawnSync4(VERTEX_VENV_PYTHON, [VERTEX_INTERACTIVE_SCRIPT, ...args], { stdio: "inherit" });
+    process.exit(proc.status ?? 1);
+  } else {
+    console.error(`${C.bold}${C.red}Error: Unknown mode "${mode}". Supported: direct, interactive${C.reset}`);
+    console.error(`  ${C.dim}Example: dt vx direct index.html "Add background transition"`);
+    console.error(`  ${C.dim}Example: dt vx interactive "Setup vitest suite"`);
+    process.exit(2);
+  }
+}
+function runDispatch(rawPrompt, options) {
+  let backend = options.backend;
+  if (options.team) {
+    backend = "metagpt";
+  }
+  let briefFile = options.brief;
+  const forwardArgs = [];
+  let isTempBrief = false;
+  if (rawPrompt && !briefFile) {
+    const tempBriefDir = join3(tmpdir(), "dt-briefs");
+    if (!existsSync3(tempBriefDir)) mkdirSync2(tempBriefDir, { recursive: true });
+    briefFile = join3(tempBriefDir, `brief-${Date.now()}.txt`);
+    const briefContent = `TASK CLI_TASK: ${rawPrompt}
+NAV: use the code graph
+CHANGE:
+${rawPrompt}
+`;
+    writeFileSync2(briefFile, briefContent, "utf8");
+    forwardArgs.push("--brief", briefFile ?? "");
+    isTempBrief = true;
+    console.log(`${C.dim}Generated temporary brief file: ${briefFile}${C.reset}`);
+  } else if (briefFile) {
+    forwardArgs.push("--brief", briefFile);
+  }
+  if (!briefFile) {
+    console.error(`${C.bold}${C.red}Error: Please specify either a prompt or a brief file using --brief <file_path>${C.reset}`);
+    process.exit(2);
+  }
+  const briefText = readFileSync(briefFile, "utf8");
+  let forceMetagpt = false;
+  let autoRouted = false;
+  if (!backend) {
+    console.log(`${C.dim}Running OpenCode Router to evaluate task complexity...${C.reset}`);
+    try {
+      const routerProc = spawnSync4(process.execPath, [ROUTER_SCRIPT, "route"], {
+        input: briefText,
+        encoding: "utf8",
+        timeout: 5e3
+      });
+      if (routerProc.status === 0) {
+        const routeData = JSON.parse(routerProc.stdout.trim());
+        console.log(`${C.bold}${C.cyan}Router Complexity Score: ${routeData.score}${C.reset}`);
+        if (routeData.score >= 8) {
+          backend = "metagpt";
+          autoRouted = true;
+          console.log(`  \u{1F3AF} Routing to: ${C.bold}${C.magenta}metagpt${C.reset} (MetaGPT Team Orchestrator for complex tasks)`);
+        } else if (routeData.score > 5) {
+          backend = "vertexcoder";
+          console.log(`  \u{1F3AF} Routing to: ${C.bold}${C.green}vertexcoder${C.reset} (Premium Gemini AI via GCP SDK)`);
+        } else if (routeData.score > 0) {
+          backend = "opencode";
+          console.log(`  \u{1F3AF} Routing to: ${C.bold}${C.green}opencode${C.reset} (Balanced OpenCode Router)`);
+        } else {
+          backend = "minimax";
+          console.log(`  \u{1F3AF} Routing to: ${C.bold}${C.green}minimax${C.reset} (Fast MiniMax Agent)`);
+        }
+      } else {
+        backend = "vertexcoder";
+        console.log(`Router returned non-zero status, defaulting to: ${C.bold}${C.green}vertexcoder${C.reset}`);
+      }
+    } catch {
+      backend = "vertexcoder";
+      console.log(`Router evaluation failed, defaulting to: ${C.bold}${C.green}vertexcoder${C.reset}`);
+    }
+    if (!backend) {
+      backend = "vertexcoder";
+    }
+  }
+  if (backend === "metagpt") {
+    forceMetagpt = true;
+  } else {
+    forwardArgs.push("--backend", backend);
+  }
+  let success = false;
+  if (forceMetagpt) {
+    console.log(`
+${C.bold}${C.magenta}\u{1F680} Dispatching task to team orchestrator: [METAGPT]${C.reset}`);
+    const dtCli = process.argv[1] || process.argv[0];
+    const metagptArgs = ["metagpt", rawPrompt || briefText];
+    if (autoRouted || !options.allowInstall) {
+      metagptArgs.push("--no-install");
+    }
+    metagptArgs.push("--workspace-only");
+    if (options.approveWrite) {
+      metagptArgs.push("--approve-write");
+    }
+    const proc = spawnSync4(process.execPath, [dtCli, ...metagptArgs], { stdio: "inherit" });
+    success = proc.status === 0;
+  } else {
+    let activeBackend = backend;
+    let currentChain = [activeBackend, ...FALLBACK_RING[activeBackend] || []];
+    for (let attempt = 0; attempt < currentChain.length; attempt++) {
+      activeBackend = currentChain[attempt];
+      console.log(`
+${C.bold}${C.magenta}\u{1F680} Dispatching task to backend: [${activeBackend.toUpperCase()}] (Attempt ${attempt + 1}/${currentChain.length})${C.reset}`);
+      console.log(`${C.dim}relay.mjs ${forwardArgs.filter((a) => a !== "--backend" && a !== activeBackend).join(" ")} --backend ${activeBackend}${C.reset}
+`);
+      const runArgs = [...forwardArgs];
+      const bIndex = runArgs.indexOf("--backend");
+      if (bIndex !== -1) {
+        runArgs[bIndex + 1] = activeBackend;
+      }
+      const start = Date.now();
+      const proc = spawnSync4(process.execPath, [RELAY_SCRIPT, ...runArgs], { stdio: "inherit" });
+      const durationSec = ((Date.now() - start) / 1e3).toFixed(1);
+      if (proc.status === 0) {
+        console.log(`
+${C.bold}${C.green}\u2705 Task completed successfully by [${activeBackend.toUpperCase()}] in ${durationSec}s!${C.reset}
+`);
+        success = true;
+        break;
+      } else {
+        console.log(`
+${C.bold}${C.yellow}\u26A0\uFE0F  Backend [${activeBackend.toUpperCase()}] failed or exited with status code ${proc.status || "N/A"} after ${durationSec}s.${C.reset}`);
+        const nextBackend = currentChain[attempt + 1];
+        if (nextBackend) {
+          console.log(`${C.bold}${C.yellow}\u{1F504} Activating Automated Failover Ring \u2192 Routing to next backup: [${nextBackend.toUpperCase()}]${C.reset}`);
+        }
+      }
+    }
+  }
+  if (isTempBrief && existsSync3(briefFile)) {
+    try {
+      unlinkSync(briefFile);
+    } catch {
+    }
+  }
+  if (!success) {
+    console.error(`
+${C.bold}${C.red}\u274C Failover Ring Exhausted! All available backends have failed to execute this task.${C.reset}`);
+    console.error(`  ${C.bold}${C.yellow}Orchestrator Directive: Please finish the task manually using SELF.${C.reset}
+`);
+    process.exit(1);
+  }
+}
+
+// src/commands/metagpt.ts
+import { spawn } from "child_process";
+import { join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+
+// src/utils/tracer.ts
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync2 } from "fs";
+var TraceManager = class {
+  tracesDir;
+  constructor() {
+    this.tracesDir = join4(homedir3(), ".config", "dt", "traces");
+    if (!existsSync4(this.tracesDir)) {
+      mkdirSync3(this.tracesDir, { recursive: true });
+    }
+  }
+  createTrace(parentId = "claude-code-session") {
+    const inheritedParentId = process.env.DT_TRACE_ID || parentId;
+    const inheritedDepth = process.env.DT_EXECUTION_DEPTH ? parseInt(process.env.DT_EXECUTION_DEPTH, 10) + 1 : 1;
+    const canCallMetagpt = process.env.DT_CAN_CALL_METAGPT ? process.env.DT_CAN_CALL_METAGPT === "true" : true;
+    const inheritedMaxRoles = process.env.DT_MAX_ROLES ? parseInt(process.env.DT_MAX_ROLES, 10) : 5;
+    const traceId = `dt-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}-${Date.now()}`;
+    const trace = {
+      trace_id: traceId,
+      parent_id: inheritedParentId,
+      controller: "claude-code",
+      executor: "metagpt",
+      depth_control: {
+        max_depth: 2,
+        current_depth: inheritedDepth,
+        can_delegate: true,
+        can_call_metagpt: canCallMetagpt
+        // Respect environment restriction
+      },
+      budget: {
+        max_roles: inheritedMaxRoles,
+        max_rounds: 2,
+        max_tokens_total: 12e4,
+        max_runtime_seconds: 900,
+        fallback_budget: 2
+      },
+      roles: [],
+      final_status: "initialized",
+      commit_allowed: false
+      // Enforce Review Gate
+    };
+    if (!canCallMetagpt) {
+      trace.depth_control.current_depth = trace.depth_control.max_depth + 1;
+    }
+    this.saveTrace(trace);
+    return trace;
+  }
+  saveTrace(trace) {
+    const tracePath = join4(this.tracesDir, `${trace.trace_id}.json`);
+    writeFileSync3(tracePath, JSON.stringify(trace, null, 2), "utf8");
+  }
+  loadTrace(traceId) {
+    const tracePath = join4(this.tracesDir, `${traceId}.json`);
+    if (existsSync4(tracePath)) {
+      return JSON.parse(readFileSync2(tracePath, "utf8"));
+    }
+    return null;
+  }
+};
+
+// src/commands/metagpt.ts
+async function runMetaGPTRouter(prompt, options = {}) {
+  const venvDir = join5(VERTEX_CODER_PATH, ".venv");
+  const pythonPath = join5(venvDir, "bin", "python3");
+  const metagptAdapterPath = join5(VERTEX_CODER_PATH, "dt_metagpt_adapter.py");
+  const tracer = new TraceManager();
+  const trace = tracer.createTrace();
+  if (trace.depth_control.current_depth > trace.depth_control.max_depth) {
+    console.error(`
+\u274C Delegation Blocked: Maximum execution depth (${trace.depth_control.max_depth}) exceeded.`);
+    return 1;
+  }
+  console.log(`
+\u{1F916} Launching MetaGPT AI Software Company...`);
+  console.log(`\u{1F4CB} Trace ID: ${trace.trace_id}`);
+  console.log(`\u{1F4CB} Prompt: "${prompt}"
+`);
+  const metagptArgs = [metagptAdapterPath, prompt, "--project-path", process.cwd()];
+  const metagptEnv = {};
+  if (options.planOnly) {
+    console.log(`\u{1F6E1}\uFE0F  Guardrail Active: [--plan-only] MetaGPT will generate plan/architecture only.`);
+    metagptArgs.push("--plan-only");
+    metagptEnv["DT_PLAN_ONLY"] = "true";
+  }
+  if (options.approveWrite) {
+    console.log(`\u{1F6E1}\uFE0F  Guardrail Active: [--approve-write] Requiring human approval before disk writes.`);
+    metagptArgs.push("--approve-write");
+    metagptEnv["DT_APPROVE_WRITE"] = "true";
+  }
+  if (options.workspaceOnly) {
+    console.log(`\u{1F6E1}\uFE0F  Guardrail Active: [--workspace-only] Sandboxing to workspace root.`);
+    metagptArgs.push("--workspace-only");
+    metagptEnv["DT_WORKSPACE_ONLY"] = "true";
+  }
+  if (options.noInstall) {
+    console.log(`\u{1F6E1}\uFE0F  Guardrail Active: [--no-install] Package installation blocked.`);
+    metagptArgs.push("--no-install");
+    metagptEnv["DT_NO_INSTALL"] = "true";
+  }
+  if (options.dryRun) {
+    console.log(`\u{1F6E1}\uFE0F  Guardrail Active: [--dry-run] Simulating workflow safely.`);
+    metagptArgs.push("--dry-run");
+    metagptEnv["DT_DRY_RUN"] = "true";
+  }
+  console.log(`\x1B[90mEnsure your dt proxy server is running (dt serve 3000) for MetaGPT to connect to the backend.\x1B[0m
+`);
+  return new Promise((resolve) => {
+    const execEnv = {
+      ...process.env,
+      ...metagptEnv,
+      DT_TRACE_ID: trace.trace_id,
+      DT_MAX_ROLES: trace.budget.max_roles.toString(),
+      DT_MAX_TOKENS: trace.budget.max_tokens_total.toString(),
+      DT_EXECUTION_DEPTH: trace.depth_control.current_depth.toString(),
+      DT_CAN_CALL_METAGPT: trace.depth_control.can_call_metagpt.toString(),
+      DT_CLI_PATH: process.argv[1] || process.argv[0]
+    };
+    const child = spawn(pythonPath, metagptArgs, {
+      stdio: "inherit",
+      env: execEnv
+    });
+    child.on("error", (err) => {
+      console.error(`
+\u274C Failed to launch MetaGPT: ${err.message}`);
+      console.error(`Did you run 'dt setup' to install metagpt in the virtual environment?`);
+      resolve(1);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        console.log(`
+\u2705 MetaGPT software company completed its work.`);
+        trace.final_status = "ready_for_review";
+      } else {
+        console.log(`
+\u26A0\uFE0F MetaGPT exited with code ${code}.`);
+        trace.final_status = "failed";
+      }
+      const contractPath = join5(process.cwd(), ".dt_aggregation_contract.json");
+      if (existsSync5(contractPath)) {
+        try {
+          const contract = JSON.parse(readFileSync3(contractPath, "utf8"));
+          if (Array.isArray(contract.roles_executed)) {
+            if (contract.roles_executed.length > 0 && typeof contract.roles_executed[0] === "object") {
+              trace.roles = contract.roles_executed;
+            } else {
+              trace.roles = contract.roles_executed.map((r) => ({ role: r, backend: "unknown", status: "completed", files_touched: contract.files_touched || [] }));
+            }
+          }
+        } catch (e) {
+          console.error(`Failed to parse aggregation contract: ${e}`);
+        }
+      }
+      tracer.saveTrace(trace);
+      resolve(code || 0);
+    });
+  });
+}
+
+// src/cli.ts
+import fs from "fs";
+var packageJsonPath = new URL("../package.json", import.meta.url);
+var version = "1.0.0";
+try {
+  const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  version = pkg.version;
+} catch (e) {
+}
+var program = new Command();
+program.name("dt").description("Unified Multi-Backend Developer Agent Dispatch & CLI suite").version(version);
+program.command("check").alias("status").description("Scan health, configs, and credential status of all backends").option("--strict", "Exit with code 1 if no backends are fully ready").action((options) => {
+  runCheck(options.strict);
+});
+program.command("doctor").description("Alias for check command").option("--strict", "Exit with code 1 if no backends are fully ready").action((options) => {
+  runCheck(options.strict);
+});
+program.command("link-skill").description("Automate integration by symlinking tools to local Claude/Gemini folders").action(() => {
+  runLinkSkill();
+});
+program.command("setup").alias("init").description("Run autopilot setup to automatically configure dependencies, auth, GCP & agents").action(() => {
+  runSetup().catch((err) => {
+    console.error("\n\u274C Setup failed:", err);
+    process.exit(1);
+  });
+});
+program.command("auth").description("Authenticate with Google Cloud (gcloud login)").action(() => {
+  runAuth().catch((err) => {
+    console.error("\n\u274C Auth failed:", err);
+    process.exit(1);
+  });
+});
+program.command("gcp-enable <project_id>").description("Enable Vertex AI and Dialogflow APIs in your GCP project").action((projectId) => {
+  runGcpEnable(projectId).catch((err) => {
+    console.error("\n\u274C GCP Enable failed:", err);
+    process.exit(1);
+  });
+});
+program.command("vertex-provision").description("Provision the Vertex AI agent on GCP").action(() => {
+  runVertexProvision().catch((err) => {
+    console.error("\n\u274C Vertex provision failed:", err);
+    process.exit(1);
+  });
+});
+program.command("vx <mode> [args...]").alias("vertex").description("Direct high-performance interface for Google Vertex AI coding agent (modes: direct, interactive)").action((mode, args) => {
+  runVertex(mode, args);
+});
+program.command("metagpt [prompt...]").alias("mg").description("Launch MetaGPT AI Software Company for complex multi-agent architectures").option("--plan-only", "Generate plan and architecture without writing code").option("--approve-write", "Require human approval before writing to disk").option("--workspace-only", "Strictly sandbox MetaGPT to the current workspace root").option("--no-install", "Prevent MetaGPT from installing package dependencies").option("--dry-run", "Simulate workflow without making destructive changes").action(async (promptArray, options) => {
+  const prompt = Array.isArray(promptArray) ? promptArray.join(" ") : promptArray;
+  const code = await runMetaGPTRouter(prompt, options);
+  process.exit(code);
+});
+program.command("run [prompt...]").alias("dispatch").description("Dispatch a task to a backend agent with automatic routing & failover").option("-b, --backend <backend>", "Specify a backend to use directly").option("--brief <file>", "Specify a brief file instead of a direct prompt").option("--team", "Force routing to the MetaGPT team orchestrator").option("--allow-install", "Allow package installation during execution").option("--approve-write", "Require human approval before writing to disk").action((promptArray, options) => {
+  const prompt = Array.isArray(promptArray) ? promptArray.join(" ") : promptArray;
+  runDispatch(prompt, options);
+});
+program.command("serve [port]").alias("proxy").description("Start the LLM Gateway Proxy Server").action((port) => {
+  runServe(port ? parseInt(port, 10) : 3e3);
+});
+if (process.argv.length > 2 && !process.argv[2].startsWith("-")) {
+  const isCommand = ["check", "status", "doctor", "link-skill", "setup", "init", "auth", "gcp-enable", "vertex-provision", "vx", "vertex", "metagpt", "mg", "run", "dispatch", "serve", "proxy", "help"].includes(process.argv[2]);
+  if (!isCommand) {
+    console.error(`\\n\u274C Error: Unknown command '${process.argv[2]}'.`);
+    console.error(`Run 'dt --help' to see available commands.\\n`);
+    process.exit(1);
+  }
+}
+program.parse(process.argv);