@a3t/rapid 0.1.6 → 0.1.8

package/dist/chunk-VWXN2TG5.js

@@ -0,0 +1,3618 @@
+// src/index.ts
+import { Command as Command13 } from "commander";
+import { setLogLevel, logger as logger14 } from "@a3t/rapid-core";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname4, join as join7 } from "path";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import { writeFile, access, readFile, readdir, mkdir } from "fs/promises";
+import { join } from "path";
+import { existsSync } from "fs";
+import {
+  getDefaultConfig,
+  logger,
+  MCP_SERVER_TEMPLATES,
+  addMcpServerFromTemplate,
+  getSecretReferences,
+  writeMcpConfig,
+  writeOpenCodeConfig,
+  RAPID_METHODOLOGY,
+  MCP_USAGE_GUIDELINES,
+  GIT_GUIDELINES
+} from "@a3t/rapid-core";
+import ora from "ora";
+async function detectProjectType(dir) {
+  const files = await readdir(dir).catch(() => []);
+  const fileSet = new Set(files);
+  if (fileSet.has("Cargo.toml")) {
+    return { language: "rust", confidence: "high" };
+  }
+  if (fileSet.has("go.mod")) {
+    return { language: "go", confidence: "high" };
+  }
+  if (fileSet.has("pyproject.toml")) {
+    const content = await readFile(join(dir, "pyproject.toml"), "utf-8").catch(() => "");
+    const framework = content.includes("fastapi") ? "fastapi" : content.includes("django") ? "django" : content.includes("flask") ? "flask" : void 0;
+    if (framework) {
+      return { language: "python", framework, confidence: "high" };
+    }
+    return { language: "python", confidence: "high" };
+  }
+  if (fileSet.has("requirements.txt") || fileSet.has("setup.py") || fileSet.has("Pipfile")) {
+    return { language: "python", confidence: "medium" };
+  }
+  if (fileSet.has("Gemfile")) {
+    return { language: "ruby", confidence: "high" };
+  }
+  if (fileSet.has("pom.xml") || fileSet.has("build.gradle") || fileSet.has("build.gradle.kts")) {
+    return { language: "java", confidence: "high" };
+  }
+  if (fileSet.has("tsconfig.json")) {
+    const pkgManager = fileSet.has("pnpm-lock.yaml") ? "pnpm" : fileSet.has("yarn.lock") ? "yarn" : fileSet.has("bun.lockb") || fileSet.has("bun.lock") ? "bun" : "npm";
+    let framework;
+    if (fileSet.has("package.json")) {
+      const pkg = await readFile(join(dir, "package.json"), "utf-8").catch(() => "{}");
+      try {
+        const parsed = JSON.parse(pkg);
+        const deps = { ...parsed.dependencies, ...parsed.devDependencies };
+        if (deps.next) framework = "nextjs";
+        else if (deps.nuxt) framework = "nuxt";
+        else if (deps.react) framework = "react";
+        else if (deps.vue) framework = "vue";
+        else if (deps.svelte) framework = "svelte";
+        else if (deps.express) framework = "express";
+        else if (deps.fastify) framework = "fastify";
+        else if (deps.hono) framework = "hono";
+      } catch {
+      }
+    }
+    const result = {
+      language: "typescript",
+      packageManager: pkgManager,
+      confidence: "high"
+    };
+    if (framework) {
+      result.framework = framework;
+    }
+    return result;
+  }
+  if (fileSet.has("package.json")) {
+    const pkgManager = fileSet.has("pnpm-lock.yaml") ? "pnpm" : fileSet.has("yarn.lock") ? "yarn" : "npm";
+    return { language: "javascript", packageManager: pkgManager, confidence: "medium" };
+  }
+  return { language: "unknown", confidence: "low" };
+}
+function getSuggestedTemplate(detected) {
+  switch (detected.language) {
+    case "typescript":
+      return "typescript";
+    case "javascript":
+      return "typescript";
+    // Use TS template for JS too
+    case "python":
+      return "python";
+    case "rust":
+      return "rust";
+    case "go":
+      return "go";
+    default:
+      return "universal";
+  }
+}
+function parseTemplateSource(input) {
+  const builtinTemplates = [
+    "typescript",
+    "python",
+    "rust",
+    "go",
+    "universal",
+    "default",
+    "infrastructure"
+  ];
+  if (builtinTemplates.includes(input)) {
+    return { type: "builtin", source: input };
+  }
+  if (input.startsWith("github:") || input.startsWith("gh:")) {
+    const source = input.replace(/^(github|gh):/, "");
+    const parsed = parseRepoPath(source);
+    const result = { type: "github", source: parsed.repo };
+    if (parsed.subdir) result.subdir = parsed.subdir;
+    if (parsed.ref) result.ref = parsed.ref;
+    return result;
+  }
+  if (input.startsWith("gitlab:")) {
+    const source = input.replace(/^gitlab:/, "");
+    const parsed = parseRepoPath(source);
+    const result = { type: "gitlab", source: parsed.repo };
+    if (parsed.subdir) result.subdir = parsed.subdir;
+    if (parsed.ref) result.ref = parsed.ref;
+    return result;
+  }
+  if (input.startsWith("npm:")) {
+    return { type: "npm", source: input.replace(/^npm:/, "") };
+  }
+  if (input.startsWith("https://") || input.startsWith("http://")) {
+    return { type: "url", source: input };
+  }
+  if (/^[\w.-]+\/[\w.-]+/.test(input)) {
+    const parsed = parseRepoPath(input);
+    const result = { type: "github", source: parsed.repo };
+    if (parsed.subdir) result.subdir = parsed.subdir;
+    if (parsed.ref) result.ref = parsed.ref;
+    return result;
+  }
+  return { type: "builtin", source: "universal" };
+}
+function parseRepoPath(input) {
+  let ref;
+  let path = input;
+  if (path.includes("#")) {
+    const parts = path.split("#");
+    path = parts[0];
+    ref = parts[1];
+  }
+  const segments = path.split("/");
+  if (segments.length >= 2) {
+    const repo = `${segments[0]}/${segments[1]}`;
+    const subdir = segments.length > 2 ? segments.slice(2).join("/") : void 0;
+    const result2 = { repo };
+    if (subdir) result2.subdir = subdir;
+    if (ref) result2.ref = ref;
+    return result2;
+  }
+  const result = { repo: path };
+  if (ref) result.ref = ref;
+  return result;
+}
+async function downloadRemoteTemplate(parsed, destDir, spinner) {
+  try {
+    const { downloadTemplate } = await import("giget");
+    let source;
+    switch (parsed.type) {
+      case "github":
+        source = `github:${parsed.source}${parsed.subdir ? "/" + parsed.subdir : ""}${parsed.ref ? "#" + parsed.ref : ""}`;
+        break;
+      case "gitlab":
+        source = `gitlab:${parsed.source}${parsed.subdir ? "/" + parsed.subdir : ""}${parsed.ref ? "#" + parsed.ref : ""}`;
+        break;
+      case "url":
+        source = parsed.source;
+        break;
+      default:
+        return false;
+    }
+    spinner.text = `Downloading template from ${source}...`;
+    await downloadTemplate(source, {
+      dir: destDir,
+      force: true
+    });
+    return true;
+  } catch (error) {
+    logger.debug(
+      `Failed to download template: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return false;
+  }
+}
+var PREBUILT_IMAGE_REGISTRY = "ghcr.io/a3tai/rapid-devcontainer";
+var PREBUILT_IMAGES = {
+  typescript: `${PREBUILT_IMAGE_REGISTRY}-typescript:latest`,
+  javascript: `${PREBUILT_IMAGE_REGISTRY}-typescript:latest`,
+  python: `${PREBUILT_IMAGE_REGISTRY}-python:latest`,
+  rust: `${PREBUILT_IMAGE_REGISTRY}-rust:latest`,
+  go: `${PREBUILT_IMAGE_REGISTRY}-go:latest`,
+  universal: `${PREBUILT_IMAGE_REGISTRY}-universal:latest`,
+  infrastructure: `${PREBUILT_IMAGE_REGISTRY}-infrastructure:latest`
+};
+var TEMPLATE_CUSTOMIZATIONS = {
+  typescript: {
+    vscode: {
+      extensions: [
+        "dbaeumer.vscode-eslint",
+        "esbenp.prettier-vscode",
+        "bradlc.vscode-tailwindcss",
+        "prisma.prisma",
+        "mikestead.dotenv"
+      ],
+      settings: {
+        "editor.formatOnSave": true,
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+      }
+    }
+  },
+  python: {
+    vscode: {
+      extensions: [
+        "ms-python.python",
+        "ms-python.vscode-pylance",
+        "charliermarsh.ruff",
+        "ms-toolsai.jupyter"
+      ],
+      settings: {
+        "[python]": {
+          "editor.formatOnSave": true,
+          "editor.defaultFormatter": "charliermarsh.ruff"
+        }
+      }
+    }
+  },
+  rust: {
+    vscode: {
+      extensions: ["rust-lang.rust-analyzer", "tamasfe.even-better-toml", "vadimcn.vscode-lldb"],
+      settings: { "[rust]": { "editor.formatOnSave": true } }
+    }
+  },
+  go: {
+    vscode: {
+      extensions: ["golang.go", "zxh404.vscode-proto3"],
+      settings: { "[go]": { "editor.formatOnSave": true } }
+    }
+  },
+  universal: {
+    vscode: {
+      extensions: [
+        "dbaeumer.vscode-eslint",
+        "esbenp.prettier-vscode",
+        "ms-python.python",
+        "golang.go"
+      ]
+    }
+  },
+  infrastructure: {
+    vscode: {
+      extensions: [
+        "hashicorp.terraform",
+        "ms-kubernetes-tools.vscode-kubernetes-tools",
+        "redhat.vscode-yaml"
+      ]
+    }
+  }
+};
+function getPrebuiltConfig(templateName, containerEnv, postStartCommand) {
+  const image = PREBUILT_IMAGES[templateName] ?? PREBUILT_IMAGES.universal;
+  const customizations = TEMPLATE_CUSTOMIZATIONS[templateName] ?? TEMPLATE_CUSTOMIZATIONS.universal;
+  const remoteUser = templateName === "typescript" ? "node" : "vscode";
+  return {
+    name: `RAPID ${templateName.charAt(0).toUpperCase() + templateName.slice(1)} (Pre-built)`,
+    image,
+    customizations,
+    containerEnv,
+    postStartCommand,
+    remoteUser
+  };
+}
+function getDevContainerConfig(detected, usePrebuilt = false) {
+  const baseFeatures = {
+    "ghcr.io/devcontainers/features/git:1": {},
+    "ghcr.io/devcontainers-contrib/features/direnv:1": {},
+    "ghcr.io/devcontainers-contrib/features/starship:1": {},
+    "ghcr.io/devcontainers-contrib/features/1password-cli:1": {}
+  };
+  const containerEnv = {
+    OP_SERVICE_ACCOUNT_TOKEN: "${localEnv:OP_SERVICE_ACCOUNT_TOKEN}"
+  };
+  const postCreateBase = "npm install -g @anthropic-ai/claude-code && curl -fsSL https://opencode.ai/install | bash";
+  const postStartCommand = "direnv allow 2>/dev/null || true";
+  const language = detected?.language || "unknown";
+  const templateName = language === "javascript" ? "typescript" : language === "unknown" ? "universal" : language;
+  if (usePrebuilt && PREBUILT_IMAGES[templateName]) {
+    return getPrebuiltConfig(templateName, containerEnv, postStartCommand);
+  }
+  switch (language) {
+    case "typescript":
+    case "javascript":
+      return {
+        name: "RAPID TypeScript",
+        image: "mcr.microsoft.com/devcontainers/typescript-node:22",
+        features: {
+          ...baseFeatures,
+          "ghcr.io/devcontainers-contrib/features/pnpm:2": {}
+        },
+        customizations: {
+          vscode: {
+            extensions: [
+              "dbaeumer.vscode-eslint",
+              "esbenp.prettier-vscode",
+              "bradlc.vscode-tailwindcss",
+              "prisma.prisma",
+              "mikestead.dotenv"
+            ],
+            settings: {
+              "editor.formatOnSave": true,
+              "editor.defaultFormatter": "esbenp.prettier-vscode",
+              "editor.codeActionsOnSave": {
+                "source.fixAll.eslint": "explicit"
+              }
+            }
+          }
+        },
+        containerEnv,
+        postCreateCommand: postCreateBase,
+        postStartCommand,
+        remoteUser: "node"
+      };
+    case "python":
+      return {
+        name: "RAPID Python",
+        image: "mcr.microsoft.com/devcontainers/python:3.12",
+        features: {
+          ...baseFeatures,
+          "ghcr.io/devcontainers/features/node:1": { version: "22" },
+          "ghcr.io/devcontainers-contrib/features/poetry:2": {},
+          "ghcr.io/devcontainers-contrib/features/uv:1": {}
+        },
+        customizations: {
+          vscode: {
+            extensions: [
+              "ms-python.python",
+              "ms-python.vscode-pylance",
+              "ms-python.debugpy",
+              "charliermarsh.ruff",
+              "ms-toolsai.jupyter",
+              "tamasfe.even-better-toml"
+            ],
+            settings: {
+              "python.defaultInterpreterPath": "/usr/local/bin/python",
+              "[python]": {
+                "editor.formatOnSave": true,
+                "editor.defaultFormatter": "charliermarsh.ruff",
+                "editor.codeActionsOnSave": {
+                  "source.fixAll": "explicit",
+                  "source.organizeImports": "explicit"
+                }
+              }
+            }
+          }
+        },
+        containerEnv,
+        postCreateCommand: `${postCreateBase} && pip install aider-chat`,
+        postStartCommand,
+        remoteUser: "vscode"
+      };
+    case "rust":
+      return {
+        name: "RAPID Rust",
+        image: "mcr.microsoft.com/devcontainers/rust:latest",
+        features: {
+          ...baseFeatures,
+          "ghcr.io/devcontainers/features/node:1": { version: "22" }
+        },
+        customizations: {
+          vscode: {
+            extensions: [
+              "rust-lang.rust-analyzer",
+              "tamasfe.even-better-toml",
+              "serayuzgur.crates",
+              "vadimcn.vscode-lldb"
+            ],
+            settings: {
+              "rust-analyzer.checkOnSave.command": "clippy",
+              "[rust]": {
+                "editor.formatOnSave": true,
+                "editor.defaultFormatter": "rust-lang.rust-analyzer"
+              }
+            }
+          }
+        },
+        containerEnv,
+        postCreateCommand: `${postCreateBase} && rustup component add clippy rustfmt`,
+        postStartCommand,
+        remoteUser: "vscode"
+      };
+    case "go":
+      return {
+        name: "RAPID Go",
+        image: "mcr.microsoft.com/devcontainers/go:1.23",
+        features: {
+          ...baseFeatures,
+          "ghcr.io/devcontainers/features/node:1": { version: "22" }
+        },
+        customizations: {
+          vscode: {
+            extensions: ["golang.go", "zxh404.vscode-proto3", "tamasfe.even-better-toml"],
+            settings: {
+              "go.useLanguageServer": true,
+              "go.lintTool": "golangci-lint",
+              "go.lintFlags": ["--fast"],
+              "[go]": {
+                "editor.formatOnSave": true,
+                "editor.codeActionsOnSave": {
+                  "source.organizeImports": "explicit"
+                }
+              }
+            }
+          }
+        },
+        containerEnv,
+        postCreateCommand: `${postCreateBase} && go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest && go install github.com/air-verse/air@latest`,
+        postStartCommand,
+        remoteUser: "vscode"
+      };
+    default:
+      return {
+        name: "RAPID Universal",
+        image: "mcr.microsoft.com/devcontainers/base:ubuntu",
+        features: {
+          ...baseFeatures,
+          "ghcr.io/devcontainers/features/node:1": { version: "22" },
+          "ghcr.io/devcontainers/features/python:1": { version: "3.12" },
+          "ghcr.io/devcontainers/features/go:1": { version: "1.23" },
+          "ghcr.io/devcontainers/features/docker-in-docker:2": {}
+        },
+        customizations: {
+          vscode: {
+            extensions: [
+              "dbaeumer.vscode-eslint",
+              "esbenp.prettier-vscode",
+              "ms-python.python",
+              "ms-python.vscode-pylance",
+              "golang.go",
+              "tamasfe.even-better-toml",
+              "redhat.vscode-yaml"
+            ]
+          }
+        },
+        containerEnv,
+        postCreateCommand: `${postCreateBase} && pip install aider-chat`,
+        postStartCommand,
+        remoteUser: "vscode"
+      };
+  }
+}
+async function createDevContainer(dir, detected, force = false, usePrebuilt = false) {
+  const devcontainerDir = join(dir, ".devcontainer");
+  const devcontainerJsonPath = join(devcontainerDir, "devcontainer.json");
+  if (!force && existsSync(devcontainerJsonPath)) {
+    return false;
+  }
+  await mkdir(devcontainerDir, { recursive: true });
+  const config = getDevContainerConfig(detected, usePrebuilt);
+  await writeFile(devcontainerJsonPath, JSON.stringify(config, null, 2) + "\n");
+  return true;
+}
+var initCommand = new Command("init").description("Initialize RAPID in a project").argument("[template]", "Template: builtin name, github:user/repo, npm:package, or URL").option("--force", "Overwrite existing files", false).option("--agent <name>", "Default agent to configure", "claude").option("--no-devcontainer", "Skip devcontainer creation").option("--prebuilt", "Use pre-built devcontainer images from ghcr.io (faster startup)", false).option("--mcp <servers>", "MCP servers to enable (comma-separated)", "context7,tavily").option("--no-mcp", "Skip MCP server configuration").option("--no-detect", "Skip auto-detection of project type").action(async (templateArg, options) => {
+  const spinner = ora("Initializing RAPID...").start();
+  try {
+    const cwd = process.cwd();
+    const configPath = join(cwd, "rapid.json");
+    if (!options.force) {
+      try {
+        await access(configPath);
+        spinner.fail("rapid.json already exists. Use --force to overwrite.");
+        process.exit(1);
+      } catch {
+      }
+    }
+    let detectedProject;
+    let templateSource = templateArg;
+    if (!templateArg && options.detect !== false) {
+      spinner.text = "Detecting project type...";
+      detectedProject = await detectProjectType(cwd);
+      if (detectedProject.language !== "unknown") {
+        const suggested = getSuggestedTemplate(detectedProject);
+        spinner.succeed(
+          `Detected ${detectedProject.language}${detectedProject.framework ? ` (${detectedProject.framework})` : ""} project`
+        );
+        templateSource = suggested;
+        logger.info(`Using ${logger.brand(suggested)} template`);
+      } else {
+        spinner.info("Could not detect project type, using universal template");
+        templateSource = "universal";
+      }
+      spinner.start("Initializing RAPID...");
+    }
+    const parsed = parseTemplateSource(templateSource || "universal");
+    if (parsed.type !== "builtin") {
+      spinner.text = `Fetching template from ${parsed.source}...`;
+      if (parsed.type === "npm") {
+        spinner.fail("npm template support coming soon. Use github:user/repo instead.");
+        process.exit(1);
+      }
+      const downloaded = await downloadRemoteTemplate(parsed, cwd, spinner);
+      if (!downloaded) {
+        spinner.fail(`Failed to download template from ${parsed.source}`);
+        logger.info("Make sure the repository exists and is accessible.");
+        logger.info("For private repos, set GIGET_AUTH environment variable.");
+        process.exit(1);
+      }
+      spinner.succeed(`Downloaded template from ${parsed.source}`);
+      try {
+        await access(join(cwd, "rapid.json"));
+        logger.blank();
+        logger.info("Template includes rapid.json configuration.");
+        logger.info("Run `rapid dev` to start coding!");
+        return;
+      } catch {
+        spinner.start("Creating RAPID configuration...");
+      }
+    }
+    const mcpServers = options.mcp === false ? [] : options.mcp.split(",").map((s) => s.trim());
+    let config = createConfig(options, detectedProject);
+    if (mcpServers.length > 0) {
+      spinner.text = "Configuring MCP servers...";
+      for (const serverName of mcpServers) {
+        if (MCP_SERVER_TEMPLATES[serverName]) {
+          config = addMcpServerFromTemplate(config, serverName);
+        } else {
+          logger.warn(`Unknown MCP server template: ${serverName}`);
+        }
+      }
+      const secretRefs = getSecretReferences(mcpServers);
+      if (Object.keys(secretRefs).length > 0) {
+        config.secrets = {
+          ...config.secrets,
+          provider: "1password",
+          vault: "Development",
+          items: {
+            ...config.secrets?.items,
+            ...secretRefs
+          }
+        };
+      }
+    }
+    spinner.text = "Writing rapid.json...";
+    await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+    if (mcpServers.length > 0) {
+      spinner.text = "Generating MCP configuration files...";
+      await writeMcpConfig(cwd, config);
+      await writeOpenCodeConfig(cwd, config);
+    }
+    if (config.agents.available.claude) {
+      spinner.text = "Creating CLAUDE.md...";
+      const claudeMdPath = join(cwd, "CLAUDE.md");
+      await writeFile(claudeMdPath, getClaudeMdTemplate(cwd, detectedProject));
+    }
+    spinner.text = "Creating AGENTS.md...";
+    const agentsMdPath = join(cwd, "AGENTS.md");
+    await writeFile(agentsMdPath, getAgentsMdTemplate(cwd, detectedProject));
+    let devcontainerCreated = false;
+    const usePrebuilt = options.prebuilt === true;
+    if (options.devcontainer !== false) {
+      spinner.text = usePrebuilt ? "Creating devcontainer configuration (using pre-built image)..." : "Creating devcontainer configuration...";
+      devcontainerCreated = await createDevContainer(
+        cwd,
+        detectedProject,
+        options.force,
+        usePrebuilt
+      );
+    }
+    spinner.succeed("RAPID initialized successfully!");
+    if (detectedProject && detectedProject.language !== "unknown") {
+      logger.blank();
+      logger.info("Project detected:");
+      console.log(`  ${logger.dim("Language:")}  ${detectedProject.language}`);
+      if (detectedProject.framework) {
+        console.log(`  ${logger.dim("Framework:")} ${detectedProject.framework}`);
+      }
+      if (detectedProject.packageManager) {
+        console.log(`  ${logger.dim("Package Mgr:")} ${detectedProject.packageManager}`);
+      }
+    }
+    logger.blank();
+    logger.info("Created files:");
+    console.log(`  ${logger.dim("\u2022")} rapid.json`);
+    if (mcpServers.length > 0) {
+      console.log(`  ${logger.dim("\u2022")} .mcp.json`);
+      console.log(`  ${logger.dim("\u2022")} opencode.json`);
+    }
+    if (devcontainerCreated) {
+      console.log(`  ${logger.dim("\u2022")} .devcontainer/devcontainer.json`);
+    }
+    console.log(`  ${logger.dim("\u2022")} CLAUDE.md`);
+    console.log(`  ${logger.dim("\u2022")} AGENTS.md`);
+    if (mcpServers.length > 0) {
+      logger.blank();
+      logger.info("MCP servers configured:");
+      for (const serverName of mcpServers) {
+        const template = MCP_SERVER_TEMPLATES[serverName];
+        if (template) {
+          console.log(`  ${logger.brand("\u2022")} ${serverName} - ${template.description}`);
+        }
+      }
+    }
+    logger.blank();
+    logger.info("Next steps:");
+    let stepNum = 1;
+    console.log(
+      `  ${logger.dim(`${stepNum++}.`)} Run ${logger.brand("rapid dev")} to start coding`
+    );
+    console.log(
+      `  ${logger.dim(`${stepNum++}.`)} Edit ${logger.dim("rapid.json")} to customize your setup`
+    );
+    if (mcpServers.length > 0) {
+      console.log(
+        `  ${logger.dim(`${stepNum++}.`)} Add API keys to ${logger.dim("secrets.items")} in rapid.json`
+      );
+    }
+    if (devcontainerCreated) {
+      console.log(
+        `  ${logger.dim(`${stepNum++}.`)} Set ${logger.dim("OP_SERVICE_ACCOUNT_TOKEN")} env var for 1Password secrets`
+      );
+    }
+    logger.blank();
+  } catch (error) {
+    spinner.fail("Failed to initialize RAPID");
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+function createConfig(options, detectedProject) {
+  const defaults = getDefaultConfig();
+  const config = {
+    $schema: "https://getrapid.dev/schema/v1/rapid.json",
+    version: "1.0",
+    agents: {
+      default: options.agent,
+      available: defaults.agents.available
+    },
+    secrets: {
+      provider: "env"
+    },
+    context: {
+      files: ["README.md", "CLAUDE.md", "AGENTS.md"],
+      generateAgentFiles: false
+      // We already created them
+    }
+  };
+  if (detectedProject && detectedProject.language !== "unknown") {
+    config.context = {
+      ...config.context
+      // Store detected info for potential future use
+    };
+  }
+  return config;
+}
+function getClaudeMdTemplate(projectPath, detectedProject) {
+  const projectName = projectPath.split("/").pop() || "project";
+  let languageSection = "";
+  if (detectedProject && detectedProject.language !== "unknown") {
+    languageSection = `## Technology Stack
+
+- **Language**: ${detectedProject.language}${detectedProject.framework ? `
+- **Framework**: ${detectedProject.framework}` : ""}${detectedProject.packageManager ? `
+- **Package Manager**: ${detectedProject.packageManager}` : ""}
+
+`;
+  }
+  return `# Claude Instructions
+
+## Project: ${projectName}
+
+This file contains instructions for Claude Code when working on this project.
+
+## Overview
+
+<!-- Describe your project here -->
+
+${languageSection}${RAPID_METHODOLOGY}
+${MCP_USAGE_GUIDELINES}
+${GIT_GUIDELINES}
+## Key Files
+
+- \`rapid.json\` - RAPID configuration
+- \`README.md\` - Project documentation
+
+## Commands
+
+\`\`\`bash
+# Start development
+rapid dev
+
+# Check status
+rapid status
+\`\`\`
+`;
+}
+function getAgentsMdTemplate(projectPath, detectedProject) {
+  const projectName = projectPath.split("/").pop() || "project";
+  let languageSection = "";
+  if (detectedProject && detectedProject.language !== "unknown") {
+    languageSection = `## Technology Stack
+
+- **Language**: ${detectedProject.language}${detectedProject.framework ? `
+- **Framework**: ${detectedProject.framework}` : ""}${detectedProject.packageManager ? `
+- **Package Manager**: ${detectedProject.packageManager}` : ""}
+
+`;
+  }
+  return `# Agent Instructions
+
+## Project: ${projectName}
+
+This file contains instructions for AI coding agents working on this project.
+
+## Overview
+
+<!-- Describe your project here -->
+
+${languageSection}${RAPID_METHODOLOGY}
+${MCP_USAGE_GUIDELINES}
+${GIT_GUIDELINES}
+## Project Structure
+
+\`\`\`
+.
+\u251C\u2500\u2500 rapid.json          # RAPID configuration
+\u251C\u2500\u2500 CLAUDE.md           # Claude-specific instructions
+\u251C\u2500\u2500 AGENTS.md           # Generic agent instructions
+\u2514\u2500\u2500 ...
+\`\`\`
+
+## Getting Started
+
+1. Review the project structure
+2. Check \`rapid.json\` for configuration
+3. Follow the RAPID methodology above when making changes
+`;
+}
+
+// src/commands/dev.ts
+import { Command as Command2 } from "commander";
+import { writeFile as writeFile3 } from "fs/promises";
+import { isAbsolute, join as join4 } from "path";
+import {
+  loadConfig,
+  getAgent,
+  checkAgentAvailable,
+  logger as logger2,
+  getContainerStatus,
+  startContainer,
+  execInContainer,
+  hasDevcontainerCli,
+  loadSecrets,
+  hasOpCli,
+  isOpAuthenticated,
+  hasVaultCli,
+  isVaultAuthenticated,
+  buildAgentArgs,
+  agentSupportsRuntimeInjection
+} from "@a3t/rapid-core";
+import ora2 from "ora";
+
+// src/utils/worktree.ts
+import { execa } from "execa";
+import { access as access2 } from "fs/promises";
+import { basename, dirname, join as join2, resolve } from "path";
+function getErrorMessage(err) {
+  if (typeof err.stderr === "string" && err.stderr) {
+    return err.stderr;
+  }
+  return err.message;
+}
+async function isGitRepo(dir) {
+  try {
+    await execa("git", ["rev-parse", "--git-dir"], { cwd: dir });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGitRoot(dir) {
+  const { stdout } = await execa("git", ["rev-parse", "--show-toplevel"], { cwd: dir });
+  return stdout.trim();
+}
+async function getCurrentBranch(dir) {
+  try {
+    const { stdout: symbolicRef } = await execa("git", ["symbolic-ref", "-q", "HEAD"], {
+      cwd: dir,
+      reject: false
+    });
+    if (!symbolicRef) {
+      return { name: null, isDefault: false, detached: true };
+    }
+    const branchName = symbolicRef.trim().replace("refs/heads/", "");
+    const isDefault = branchName === "main" || branchName === "master";
+    return { name: branchName, isDefault, detached: false };
+  } catch {
+    return { name: null, isDefault: false, detached: true };
+  }
+}
+async function getDefaultBranch(dir) {
+  try {
+    const { stdout } = await execa("git", ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"], {
+      cwd: dir,
+      reject: false
+    });
+    if (stdout) {
+      return stdout.trim().replace("origin/", "");
+    }
+    const { stdout: branches } = await execa("git", ["branch", "--list", "main", "master"], {
+      cwd: dir
+    });
+    if (branches.includes("main")) return "main";
+    if (branches.includes("master")) return "master";
+    return "main";
+  } catch {
+    return "main";
+  }
+}
+async function listWorktrees(dir) {
+  const { stdout } = await execa("git", ["worktree", "list", "--porcelain"], { cwd: dir });
+  const worktrees = [];
+  let current = {};
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current.path) {
+        worktrees.push(current);
+      }
+      current = {
+        path: line.substring(9),
+        isMain: false,
+        locked: false,
+        exists: true,
+        prunable: false
+      };
+    } else if (line.startsWith("HEAD ")) {
+      current.head = line.substring(5);
+    } else if (line.startsWith("branch ")) {
+      current.branch = line.substring(7).replace("refs/heads/", "");
+    } else if (line === "bare") {
+      current.isMain = true;
+    } else if (line === "locked") {
+      current.locked = true;
+    } else if (line === "prunable") {
+      current.prunable = true;
+      current.exists = false;
+    } else if (line === "detached") {
+      current.branch = null;
+    }
+  }
+  if (current.path) {
+    worktrees.push(current);
+  }
+  if (worktrees.length > 0 && worktrees[0]) {
+    worktrees[0].isMain = true;
+  }
+  for (const wt of worktrees) {
+    try {
+      await access2(wt.path);
+      wt.exists = true;
+    } catch {
+      wt.exists = false;
+      wt.prunable = true;
+    }
+  }
+  return worktrees;
+}
+async function findWorktreeByBranch(dir, branch) {
+  const worktrees = await listWorktrees(dir);
+  return worktrees.find((wt) => wt.branch === branch) ?? null;
+}
+function generateWorktreePath(repoRoot, branchName) {
+  const projectName = basename(repoRoot);
+  const parentDir = dirname(repoRoot);
+  const safeBranchName = branchName.replace(/\//g, "-").replace(/[^a-zA-Z0-9-_]/g, "").toLowerCase();
+  return join2(parentDir, `${projectName}-${safeBranchName}`);
+}
+async function createWorktree(repoRoot, worktreePath, branch, options = {}) {
+  try {
+    const existing = await listWorktrees(repoRoot);
+    const existingAtPath = existing.find((wt) => resolve(wt.path) === resolve(worktreePath));
+    if (existingAtPath && existingAtPath.exists && !options.force) {
+      return { success: true, path: worktreePath };
+    }
+    if (existingAtPath && !existingAtPath.exists) {
+      await execa("git", ["worktree", "remove", "--force", worktreePath], {
+        cwd: repoRoot,
+        reject: false
+      });
+    }
+    const args = ["worktree", "add"];
+    if (options.force) {
+      args.push("--force");
+    }
+    if (options.newBranch) {
+      args.push("-b", options.newBranch);
+    }
+    args.push(worktreePath);
+    if (!options.newBranch) {
+      args.push(branch);
+    } else if (options.startPoint) {
+      args.push(options.startPoint);
+    }
+    await execa("git", args, { cwd: repoRoot });
+    return { success: true, path: worktreePath };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      path: worktreePath,
+      error: getErrorMessage(error)
+    };
+  }
+}
+async function removeWorktree(repoRoot, worktreePath, options = {}) {
+  try {
+    const args = ["worktree", "remove"];
+    if (options.force) {
+      args.push("--force");
+    }
+    args.push(worktreePath);
+    await execa("git", args, { cwd: repoRoot });
+    return { success: true };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      error: getErrorMessage(error)
+    };
+  }
+}
+async function pruneWorktrees(repoRoot) {
+  try {
+    const worktrees = await listWorktrees(repoRoot);
+    const prunable = worktrees.filter((wt) => wt.prunable).map((wt) => wt.path);
+    await execa("git", ["worktree", "prune"], { cwd: repoRoot });
+    return { success: true, pruned: prunable };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      pruned: [],
+      error: getErrorMessage(error)
+    };
+  }
+}
+async function getOrCreateWorktreeForBranch(dir) {
+  const gitRoot = await getGitRoot(dir);
+  const branch = await getCurrentBranch(dir);
+  if (branch.isDefault || branch.detached || !branch.name) {
+    return { path: gitRoot, created: false, isMain: true };
+  }
+  const existing = await findWorktreeByBranch(gitRoot, branch.name);
+  if (existing && existing.exists) {
+    return { path: existing.path, created: false, isMain: existing.isMain };
+  }
+  const worktreePath = generateWorktreePath(gitRoot, branch.name);
+  const result = await createWorktree(gitRoot, worktreePath, branch.name);
+  if (!result.success) {
+    return { path: gitRoot, created: false, isMain: true };
+  }
+  return { path: worktreePath, created: true, isMain: false };
+}
+async function cleanupMergedWorktrees(repoRoot) {
+  const removed = [];
+  const errors = [];
+  const defaultBranch = await getDefaultBranch(repoRoot);
+  const { stdout } = await execa("git", ["branch", "--merged", defaultBranch], { cwd: repoRoot });
+  const mergedBranches = stdout.split("\n").map((b) => b.trim().replace(/^\*\s*/, "")).filter((b) => b && b !== defaultBranch);
+  const worktrees = await listWorktrees(repoRoot);
+  for (const wt of worktrees) {
+    if (wt.isMain || !wt.branch) continue;
+    if (mergedBranches.includes(wt.branch)) {
+      const result = await removeWorktree(repoRoot, wt.path, { force: true });
+      if (result.success) {
+        removed.push(wt.path);
+      } else if (result.error) {
+        errors.push(`${wt.path}: ${result.error}`);
+      }
+    }
+  }
+  return { removed, errors };
+}
+
+// src/isolation/lima.ts
+import { execa as execa2 } from "execa";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { homedir, platform } from "os";
+import { join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+function getErrorMessage2(err) {
+  if (typeof err.stderr === "string" && err.stderr) {
+    return err.stderr;
+  }
+  return err.message;
+}
+function getOutputString(output) {
+  if (typeof output === "string") {
+    return output;
+  }
+  return void 0;
+}
+var RAPID_LIMA_INSTANCE = "rapid";
+var RAPID_LIMA_DIR = join3(homedir(), ".rapid", "lima");
+async function hasLima() {
+  try {
+    await execa2("limactl", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isMacOS() {
+  return platform() === "darwin";
+}
+function getLimaTemplatePath() {
+  const __dirname3 = dirname2(fileURLToPath(import.meta.url));
+  const possiblePaths = [
+    join3(__dirname3, "../../../../templates/lima.yaml"),
+    // From dist/isolation/
+    join3(__dirname3, "../../../templates/lima.yaml"),
+    // From src/isolation/
+    join3(homedir(), ".rapid", "lima.yaml")
+    // User config
+  ];
+  return possiblePaths[0];
+}
+async function listInstances() {
+  try {
+    const { stdout } = await execa2("limactl", ["list", "--json"]);
+    const instances = JSON.parse(stdout);
+    return instances.map((inst) => {
+      const result = {
+        name: inst.name,
+        status: inst.status,
+        arch: inst.arch,
+        cpus: inst.cpus,
+        memory: `${Math.round(inst.memory / 1024 / 1024 / 1024)}GiB`,
+        disk: `${Math.round(inst.disk / 1024 / 1024 / 1024)}GiB`,
+        dir: inst.dir
+      };
+      if (inst.sshLocalPort !== void 0) {
+        result.sshLocalPort = inst.sshLocalPort;
+      }
+      return result;
+    });
+  } catch {
+    return [];
+  }
+}
+async function getInstance(name = RAPID_LIMA_INSTANCE) {
+  const instances = await listInstances();
+  return instances.find((i) => i.name === name) ?? null;
+}
+async function instanceExists(name = RAPID_LIMA_INSTANCE) {
+  const instance = await getInstance(name);
+  return instance !== null;
+}
+async function isRunning(name = RAPID_LIMA_INSTANCE) {
+  const instance = await getInstance(name);
+  return instance?.status === "Running";
+}
+async function createLimaConfig(projectDir, options = {}) {
+  const templatePath = getLimaTemplatePath();
+  const configDir = RAPID_LIMA_DIR;
+  const configPath = join3(configDir, "lima.yaml");
+  await mkdir2(configDir, { recursive: true });
+  let template;
+  try {
+    template = await readFile2(templatePath, "utf-8");
+  } catch {
+    template = getMinimalLimaConfig();
+  }
+  let config = template;
+  const projectMount = `
+  - location: "${projectDir}"
+    writable: true`;
+  config = config.replace(
+    /mounts:\s*\n\s*- location: "~"/,
+    `mounts:
+  - location: "~"${projectMount}`
+  );
+  if (options.cpus) {
+    config = config.replace(/cpus: \d+/, `cpus: ${options.cpus}`);
+  }
+  if (options.memory) {
+    config = config.replace(/memory: "[^"]*"/, `memory: "${options.memory}"`);
+  }
+  if (options.disk) {
+    config = config.replace(/disk: "[^"]*"/, `disk: "${options.disk}"`);
+  }
+  if (options.env) {
+    const envLines = Object.entries(options.env).map(([key, value]) => `  ${key}: "${value}"`).join("\n");
+    config = config.replace(/env:[\s\S]*?(?=\n\w|\n#|$)/, `env:
+${envLines}
+`);
+  }
+  await writeFile2(configPath, config);
+  return configPath;
+}
+function getMinimalLimaConfig() {
+  return `
+vmType: "vz"
+rosetta:
+  enabled: true
+  binfmt: true
+cpus: 4
+memory: "8GiB"
+disk: "50GiB"
+images:
+  - location: "https://cloud-images.ubuntu.com/releases/24.04/release/ubuntu-24.04-server-cloudimg-arm64.img"
+    arch: "aarch64"
+  - location: "https://cloud-images.ubuntu.com/releases/24.04/release/ubuntu-24.04-server-cloudimg-amd64.img"
+    arch: "x86_64"
+mountType: "virtiofs"
+mounts:
+  - location: "~"
+    writable: true
+mountInotify: true
+ssh:
+  forwardAgent: true
+  localPort: 0
+networks:
+  - vzNAT: true
+containerd:
+  system: true
+  user: false
+portForwards:
+  - guestPort: 3000
+    hostPort: 3000
+  - guestPort: 8080
+    hostPort: 8080
+provision:
+  - mode: system
+    script: |
+      #!/bin/bash
+      set -eux
+      apt-get update
+      apt-get install -y build-essential curl git jq
+      curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
+      apt-get install -y nodejs
+      npm install -g pnpm
+  - mode: user
+    script: |
+      #!/bin/bash
+      set -eux
+      npm install -g @anthropic-ai/claude-code || true
+      curl -fsSL https://opencode.ai/install | bash || true
+`;
+}
+async function startInstance(projectDir, options = {}) {
+  const name = RAPID_LIMA_INSTANCE;
+  if (!await hasLima()) {
+    return {
+      success: false,
+      error: "Lima is not installed. Install with: brew install lima"
+    };
+  }
+  if (!isMacOS()) {
+    return {
+      success: false,
+      error: "Lima is only available on macOS"
+    };
+  }
+  try {
+    const exists = await instanceExists(name);
+    if (exists) {
+      if (await isRunning(name)) {
+        return { success: true };
+      }
+      await execa2("limactl", ["start", name], {
+        timeout: (options.timeout ?? 300) * 1e3
+      });
+    } else {
+      const configPath = await createLimaConfig(projectDir, options);
+      await execa2("limactl", ["start", "--name", name, configPath], {
+        timeout: (options.timeout ?? 600) * 1e3,
+        stdio: "inherit"
+        // Show progress
+      });
+    }
+    return { success: true };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      error: getErrorMessage2(error)
+    };
+  }
+}
+async function stopInstance(name = RAPID_LIMA_INSTANCE, options = {}) {
+  try {
+    const args = ["stop"];
+    if (options.force) {
+      args.push("--force");
+    }
+    args.push(name);
+    await execa2("limactl", args);
+    return { success: true };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      error: getErrorMessage2(error)
+    };
+  }
+}
+async function deleteInstance(name = RAPID_LIMA_INSTANCE, options = {}) {
+  try {
+    const args = ["delete"];
+    if (options.force) {
+      args.push("--force");
+    }
+    args.push(name);
+    await execa2("limactl", args);
+    return { success: true };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      error: getErrorMessage2(error)
+    };
+  }
+}
+async function execInLima(command, options = {}) {
+  const name = options.name ?? RAPID_LIMA_INSTANCE;
+  try {
+    let fullCommand = command.join(" ");
+    if (options.cwd) {
+      fullCommand = `cd "${options.cwd}" && ${fullCommand}`;
+    }
+    if (options.env) {
+      const exports = Object.entries(options.env).map(([key, value]) => `export ${key}="${value}"`).join(" && ");
+      fullCommand = `${exports} && ${fullCommand}`;
+    }
+    const useInheritStdio = options.interactive || options.tty;
+    const result = await execa2(
+      "limactl",
+      ["shell", name, "--", "bash", "-c", fullCommand],
+      useInheritStdio ? { stdio: "inherit" } : {}
+    );
+    const successResult = {
+      success: true
+    };
+    const stdout = getOutputString(result.stdout);
+    const stderr = getOutputString(result.stderr);
+    if (stdout) successResult.stdout = stdout;
+    if (stderr) successResult.stderr = stderr;
+    return successResult;
+  } catch (err) {
+    const error = err;
+    const errorResult = {
+      success: false,
+      error: error.message
+    };
+    const stdout = getOutputString(error.stdout);
+    const stderr = getOutputString(error.stderr);
+    if (stdout) errorResult.stdout = stdout;
+    if (stderr) errorResult.stderr = stderr;
+    return errorResult;
+  }
+}
+async function shellInLima(options = {}) {
+  const name = options.name ?? RAPID_LIMA_INSTANCE;
+  const args = ["shell", name];
+  if (options.cwd) {
+    args.push("--workdir", options.cwd);
+  }
+  if (options.command) {
+    args.push("--", options.command);
+  }
+  await execa2("limactl", args, { stdio: "inherit" });
+}
+async function setupGitSsh(name = RAPID_LIMA_INSTANCE) {
+  try {
+    const result = await execInLima(["ssh-add", "-l"], { name });
+    if (!result.success) {
+      return {
+        success: false,
+        error: "SSH agent forwarding is not working. Make sure ssh-agent is running on the host."
+      };
+    }
+    return { success: true };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/commands/dev.ts
+var devCommand = new Command2("dev").description("Launch AI coding session in the dev container").option("-a, --agent <name>", "Agent to use").option(
+  "--multi [agents]",
+  "Launch multiple agents (comma-separated, or interactive if no value)"
+).option("--list", "List available agents without launching").option("--local", "Run locally instead of in container (not recommended)").option("--no-start", "Do not auto-start container if stopped").option("--no-worktree", "Skip automatic worktree creation for feature branches").action(async (options) => {
+  try {
+    const spinner = ora2("Loading configuration...").start();
+    const loaded = await loadConfig();
+    if (!loaded) {
+      spinner.fail("No rapid.json found. Run `rapid init` first.");
+      process.exit(1);
+    }
+    const { config } = loaded;
+    let { rootDir } = loaded;
+    spinner.succeed("Configuration loaded");
+    if (options.list) {
+      listAgents(config);
+      return;
+    }
+    if (options.worktree !== false && await isGitRepo(rootDir)) {
+      const branch = await getCurrentBranch(rootDir);
+      if (!branch.isDefault && !branch.detached && branch.name) {
+        spinner.start(`Checking worktree for branch: ${branch.name}...`);
+        try {
+          const worktree = await getOrCreateWorktreeForBranch(rootDir);
+          if (worktree.created) {
+            spinner.succeed(`Created worktree: ${worktree.path}`);
+            rootDir = worktree.path;
+          } else if (!worktree.isMain) {
+            spinner.succeed(`Using worktree: ${worktree.path}`);
+            rootDir = worktree.path;
+          } else {
+            spinner.info(`Using main directory (branch: ${branch.name})`);
+          }
+        } catch (err) {
+          spinner.warn("Could not create worktree, using main directory");
+          logger2.debug(err instanceof Error ? err.message : String(err));
+        }
+      }
+    }
+    if (options.multi !== void 0) {
+      await runMultiAgent(config, rootDir, options);
+      return;
+    }
+    const agentName = options.agent || config.agents.default;
+    const agent = getAgent(config, agentName);
+    if (!agent) {
+      logger2.error(`Agent "${agentName}" not found in configuration`);
+      logger2.info("Available agents:");
+      Object.keys(config.agents.available).forEach((name) => {
+        const isDefault = name === config.agents.default;
+        console.log(`  ${isDefault ? "* " : "  "}${name}${isDefault ? " (default)" : ""}`);
+      });
+      process.exit(1);
+    }
+    if (options.local) {
+      logger2.warn("Running locally instead of in container");
+      logger2.dim("This bypasses the isolated dev environment");
+      logger2.blank();
+      await runLocally(agent, agentName, rootDir, config);
+      return;
+    }
+    const hasDevCli = await hasDevcontainerCli();
+    if (!hasDevCli) {
+      logger2.error("devcontainer CLI not found");
+      logger2.info("Install with: npm install -g @devcontainers/cli");
+      logger2.blank();
+      logger2.info("Or use --local to run without container (not recommended)");
+      process.exit(1);
+    }
+    spinner.start("Checking container status...");
+    const status = await getContainerStatus(rootDir, config);
+    if (!status.running) {
+      if (options.start === false) {
+        spinner.fail("Container not running. Use `rapid start` first.");
+        process.exit(1);
+      }
+      spinner.text = "Starting container...";
+      spinner.stopAndPersist({ symbol: "\u{1F433}", text: "Starting container..." });
+      const result = await startContainer(rootDir, config, { quiet: false });
+      if (!result.success) {
+        logger2.blank();
+        logger2.error("Failed to start container");
+        logger2.error(result.error || "Unknown error");
+        process.exit(1);
+      }
+      logger2.blank();
+    } else {
+      spinner.succeed(`Container running (${status.containerName})`);
+    }
+    let secrets = {};
+    const secretsConfig = config.secrets;
+    if (secretsConfig?.items && Object.keys(secretsConfig.items).length > 0) {
+      const provider = secretsConfig.provider || "env";
+      if (provider === "1password") {
+        spinner.start("Loading secrets from 1Password...");
+        const hasOp = await hasOpCli();
+        if (!hasOp) {
+          spinner.warn("1Password CLI not found - secrets will not be loaded");
+          logger2.info("Install with: brew install 1password-cli");
+        } else {
+          const authenticated = await isOpAuthenticated();
+          if (!authenticated) {
+            spinner.warn("1Password not authenticated - secrets will not be loaded");
+            logger2.info("Run: eval $(op signin)");
+          } else {
+            try {
+              secrets = await loadSecrets(secretsConfig);
+              const count = Object.keys(secrets).length;
+              spinner.succeed(`Loaded ${count} secret${count !== 1 ? "s" : ""} from 1Password`);
+            } catch (err) {
+              spinner.warn("Failed to load secrets from 1Password");
+              logger2.debug(err instanceof Error ? err.message : String(err));
+            }
+          }
+        }
+      } else if (provider === "vault") {
+        spinner.start("Loading secrets from Vault...");
+        const hasVault = await hasVaultCli();
+        if (!hasVault) {
+          spinner.warn("Vault CLI not found - secrets will not be loaded");
+          logger2.info("Install from: https://developer.hashicorp.com/vault/docs/install");
+        } else {
+          const authenticated = await isVaultAuthenticated();
+          if (!authenticated) {
+            spinner.warn("Vault not authenticated - secrets will not be loaded");
+            logger2.info("Run: vault login");
+          } else {
+            try {
+              secrets = await loadSecrets(secretsConfig);
+              const count = Object.keys(secrets).length;
+              spinner.succeed(`Loaded ${count} secret${count !== 1 ? "s" : ""} from Vault`);
+            } catch (err) {
+              spinner.warn("Failed to load secrets from Vault");
+              logger2.debug(err instanceof Error ? err.message : String(err));
+            }
+          }
+        }
+      } else if (provider === "env") {
+        spinner.start("Loading secrets from environment...");
+        try {
+          secrets = await loadSecrets(secretsConfig);
+          const count = Object.keys(secrets).length;
+          if (count > 0) {
+            spinner.succeed(`Loaded ${count} secret${count !== 1 ? "s" : ""} from environment`);
+          } else {
+            spinner.warn("No secrets found in environment");
+          }
+        } catch (err) {
+          spinner.warn("Failed to load secrets from environment");
+          logger2.debug(err instanceof Error ? err.message : String(err));
+        }
+      }
+    }
+    logger2.blank();
+    logger2.info(`Launching ${logger2.brand(agentName)} in container...`);
+    const builtArgs = buildAgentArgs(agent, { injectSystemPrompt: true });
+    if (agentSupportsRuntimeInjection(agent)) {
+      logger2.dim("Injecting RAPID methodology via CLI args");
+    }
+    logger2.blank();
+    const agentArgs = [agent.cli, ...builtArgs];
+    const mcpEnv = await prepareMcpEnv(rootDir, config.mcp);
+    const mergedEnv = { ...secrets, ...mcpEnv ?? {} };
+    await execInContainer(rootDir, agentArgs, config, {
+      interactive: true,
+      tty: true,
+      env: mergedEnv
+    });
+  } catch (error) {
+    logger2.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+async function prepareMcpEnv(rootDir, mcp) {
+  if (!mcp?.servers || Object.keys(mcp.servers).length === 0) {
+    return void 0;
+  }
+  const configFile = mcp.configFile ?? ".mcp.json";
+  const configPath = isAbsolute(configFile) ? configFile : join4(rootDir, configFile);
+  const servers = {};
+  for (const [name, serverConfig] of Object.entries(mcp.servers)) {
+    if (!serverConfig || typeof serverConfig !== "object") {
+      continue;
+    }
+    const { enabled, ...rest } = serverConfig;
+    if (enabled === false) {
+      continue;
+    }
+    servers[name] = rest;
+  }
+  if (Object.keys(servers).length === 0) {
+    return void 0;
+  }
+  await writeFile3(configPath, `${JSON.stringify({ servers }, null, 2)}
+`, "utf-8");
+  return {
+    MCP_CONFIG_FILE: configFile
+  };
+}
+async function runLocally(agent, agentName, rootDir, config) {
+  const { execa: execa4 } = await import("execa");
+  const status = await checkAgentAvailable(agent);
+  if (!status.available) {
+    logger2.error(`${agentName} CLI not found locally`);
+    process.exit(1);
+  }
+  let secrets = {};
+  const secretsConfig = config.secrets;
+  if (secretsConfig?.items && Object.keys(secretsConfig.items).length > 0) {
+    const provider = secretsConfig.provider || "env";
+    const spinner = ora2();
+    if (provider === "1password") {
+      spinner.start("Loading secrets from 1Password...");
+      const hasOp = await hasOpCli();
+      if (!hasOp) {
+        spinner.warn("1Password CLI not found - secrets will not be loaded");
+        logger2.info("Install with: brew install 1password-cli");
+      } else {
+        const authenticated = await isOpAuthenticated();
+        if (!authenticated) {
+          spinner.warn("1Password not authenticated - secrets will not be loaded");
+          logger2.info("Run: eval $(op signin)");
+        } else {
+          try {
+            secrets = await loadSecrets(secretsConfig);
+            const count = Object.keys(secrets).length;
+            spinner.succeed(`Loaded ${count} secret${count !== 1 ? "s" : ""} from 1Password`);
+          } catch (err) {
+            spinner.warn("Failed to load secrets from 1Password");
+            logger2.debug(err instanceof Error ? err.message : String(err));
+          }
+        }
+      }
+    } else if (provider === "vault") {
+      spinner.start("Loading secrets from Vault...");
+      const hasVault = await hasVaultCli();
+      if (!hasVault) {
+        spinner.warn("Vault CLI not found - secrets will not be loaded");
+        logger2.info("Install from: https://developer.hashicorp.com/vault/docs/install");
+      } else {
+        const authenticated = await isVaultAuthenticated();
+        if (!authenticated) {
+          spinner.warn("Vault not authenticated - secrets will not be loaded");
+          logger2.info("Run: vault login");
+        } else {
+          try {
+            secrets = await loadSecrets(secretsConfig);
+            const count = Object.keys(secrets).length;
+            spinner.succeed(`Loaded ${count} secret${count !== 1 ? "s" : ""} from Vault`);
+          } catch (err) {
+            spinner.warn("Failed to load secrets from Vault");
+            logger2.debug(err instanceof Error ? err.message : String(err));
+          }
+        }
+      }
+    } else if (provider === "env") {
+      spinner.start("Loading secrets from environment...");
+      try {
+        secrets = await loadSecrets(secretsConfig);
+        const count = Object.keys(secrets).length;
+        if (count > 0) {
+          spinner.succeed(`Loaded ${count} secret${count !== 1 ? "s" : ""} from environment`);
+        } else {
+          spinner.warn("No secrets found in environment");
+        }
+      } catch (err) {
+        spinner.warn("Failed to load secrets from environment");
+        logger2.debug(err instanceof Error ? err.message : String(err));
+      }
+    }
+  }
+  const mcpEnv = await prepareMcpEnv(rootDir, config.mcp);
+  const mergedEnv = { ...secrets, ...mcpEnv ?? {} };
+  const builtArgs = buildAgentArgs(agent, { injectSystemPrompt: true });
+  if (isMacOS() && await hasLima()) {
+    await runInLimaVm(agent, agentName, rootDir, builtArgs, mergedEnv);
+    return;
+  }
+  logger2.info(`Launching ${logger2.brand(agentName)}...`);
+  logger2.dim(`Working directory: ${rootDir}`);
+  if (agentSupportsRuntimeInjection(agent)) {
+    logger2.dim("Injecting RAPID methodology via CLI args");
+  }
+  logger2.blank();
+  await execa4(agent.cli, builtArgs, {
+    cwd: rootDir,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ...mergedEnv
+    }
+  });
+}
+async function runInLimaVm(agent, agentName, rootDir, args, env) {
+  const spinner = ora2();
+  if (!await isRunning()) {
+    spinner.start(`Starting Lima VM (${RAPID_LIMA_INSTANCE})...`);
+    const result = await startInstance(rootDir, {
+      env,
+      timeout: 600
+      // 10 minutes for first-time setup
+    });
+    if (!result.success) {
+      spinner.fail("Failed to start Lima VM");
+      logger2.error(result.error ?? "Unknown error");
+      logger2.blank();
+      logger2.info("Falling back to running directly on host...");
+      logger2.blank();
+      const { execa: execa4 } = await import("execa");
+      await execa4(agent.cli, args, {
+        cwd: rootDir,
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          ...env
+        }
+      });
+      return;
+    }
+    spinner.succeed("Lima VM started");
+  } else {
+    logger2.info(`Lima VM (${RAPID_LIMA_INSTANCE}) is running`);
+  }
+  logger2.info(`Launching ${logger2.brand(agentName)} in Lima VM...`);
+  logger2.dim(`Working directory: ${rootDir}`);
+  logger2.dim("SSH agent forwarded for commit signing");
+  logger2.blank();
+  await execInLima([agent.cli, ...args], {
+    cwd: rootDir,
+    env,
+    interactive: true,
+    tty: true
+  });
+}
+function listAgents(config) {
+  logger2.header("Available Agents");
+  Object.keys(config.agents.available).forEach((name) => {
+    const isDefault = name === config.agents.default;
+    console.log(
+      `  ${isDefault ? logger2.brand("*") : " "} ${name}${isDefault ? logger2.dim(" (default)") : ""}`
+    );
+  });
+  logger2.blank();
+  logger2.dim("Use --agent <name> to select a specific agent");
+}
+async function runMultiAgent(config, rootDir, options) {
+  const availableAgents = Object.keys(config.agents.available);
+  if (availableAgents.length === 0) {
+    logger2.error("No agents configured");
+    process.exit(1);
+  }
+  let selectedAgents;
+  if (typeof options.multi === "string") {
+    selectedAgents = options.multi.split(",").map((a) => a.trim()).filter(Boolean);
+    for (const name of selectedAgents) {
+      if (!config.agents.available[name]) {
+        logger2.error(`Agent "${name}" not found in configuration`);
+        logger2.info("Available agents: " + availableAgents.join(", "));
+        process.exit(1);
+      }
+    }
+  } else {
+    logger2.header("Multi-Agent Mode");
+    console.log();
+    console.log("  Available agents:");
+    for (const name of availableAgents) {
+      const isDefault = name === config.agents.default;
+      console.log(`    ${logger2.brand("\u2022")} ${name}${isDefault ? logger2.dim(" (default)") : ""}`);
+    }
+    console.log();
+    logger2.info("To run multiple agents, specify them with:");
+    console.log(`  ${logger2.brand("rapid dev --multi claude,aider")}`);
+    console.log();
+    logger2.info("Or run agents in separate terminals:");
+    for (const name of availableAgents) {
+      console.log(`  ${logger2.dim("$")} rapid dev --agent ${name}`);
+    }
+    console.log();
+    logger2.warn("Note: Running multiple agents simultaneously requires separate terminal windows.");
+    logger2.info("Each agent maintains its own session and context.");
+    console.log();
+    return;
+  }
+  if (selectedAgents.length === 0) {
+    logger2.error("No agents specified");
+    process.exit(1);
+  }
+  if (selectedAgents.length === 1) {
+    logger2.info(
+      `Only one agent specified. Use ${logger2.brand("rapid dev --agent " + selectedAgents[0])} instead.`
+    );
+    process.exit(0);
+  }
+  logger2.header("Multi-Agent Session");
+  console.log();
+  console.log("  Selected agents:");
+  for (const name of selectedAgents) {
+    console.log(`    ${logger2.brand("\u2022")} ${name}`);
+  }
+  console.log();
+  const { execa: execa4 } = await import("execa");
+  let hasTmux = false;
+  try {
+    await execa4("tmux", ["-V"]);
+    hasTmux = true;
+  } catch {
+    hasTmux = false;
+  }
+  if (hasTmux) {
+    logger2.info("Launching agents in tmux panes...");
+    console.log();
+    const sessionName = `rapid-${Date.now()}`;
+    const firstAgent = selectedAgents[0];
+    const firstCmd = options.local ? `rapid dev --agent ${firstAgent} --local` : `rapid dev --agent ${firstAgent}`;
+    await execa4("tmux", ["new-session", "-d", "-s", sessionName, "-n", "rapid", firstCmd], {
+      cwd: rootDir
+    });
+    for (let i = 1; i < selectedAgents.length; i++) {
+      const agentName = selectedAgents[i];
+      const cmd = options.local ? `rapid dev --agent ${agentName} --local` : `rapid dev --agent ${agentName}`;
+      await execa4("tmux", ["split-window", "-t", sessionName, "-h", cmd], {
+        cwd: rootDir
+      });
+      await execa4("tmux", ["select-layout", "-t", sessionName, "tiled"]);
+    }
+    logger2.success(`Started ${selectedAgents.length} agents in tmux session: ${sessionName}`);
+    console.log();
+    logger2.info("Attaching to tmux session...");
+    logger2.dim("Press Ctrl+B then D to detach, or Ctrl+B then arrow keys to switch panes");
+    console.log();
+    await execa4("tmux", ["attach-session", "-t", sessionName], {
+      stdio: "inherit"
+    });
+  } else {
+    logger2.warn("tmux not found. Multi-agent mode works best with tmux installed.");
+    console.log();
+    logger2.info("To run multiple agents, open separate terminal windows and run:");
+    console.log();
+    for (const name of selectedAgents) {
+      const cmd = options.local ? `--local` : "";
+      console.log(
+        `  ${logger2.dim("Terminal " + (selectedAgents.indexOf(name) + 1) + ":")} rapid dev --agent ${name} ${cmd}`.trim()
+      );
+    }
+    console.log();
+    logger2.info("Install tmux for integrated multi-pane support:");
+    console.log(`  ${logger2.dim("macOS:")}  brew install tmux`);
+    console.log(`  ${logger2.dim("Ubuntu:")} sudo apt install tmux`);
+    console.log();
+  }
+}
+
+// src/commands/status.ts
+import { Command as Command3 } from "commander";
+import {
+  loadConfig as loadConfig2,
+  checkAllAgents,
+  logger as logger3,
+  getContainerStatus as getContainerStatus2,
+  hasDevcontainerCli as hasDevcontainerCli2,
+  hasDocker,
+  loadDevcontainerConfig,
+  verifySecrets,
+  hasOpCli as hasOpCli2,
+  hasVaultCli as hasVaultCli2,
+  isOpAuthenticated as isOpAuthenticated2,
+  isVaultAuthenticated as isVaultAuthenticated2,
+  hasEnvrc,
+  getProviderInfo,
+  getAuthStatus
+} from "@a3t/rapid-core";
+import ora3 from "ora";
+var statusCommand = new Command3("status").description("Show environment status").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const spinner = ora3("Checking status...").start();
+    const loaded = await loadConfig2();
+    if (!loaded) {
+      spinner.fail("No rapid.json found");
+      if (options.json) {
+        console.log(JSON.stringify({ configured: false }, null, 2));
+      }
+      process.exit(1);
+    }
+    const { config, filepath, rootDir } = loaded;
+    spinner.text = "Checking container...";
+    const containerStatus = await getContainerStatus2(rootDir, config);
+    const devcontainerConfig = await loadDevcontainerConfig(rootDir, config);
+    const hasDevCli = await hasDevcontainerCli2();
+    const dockerRunning = await hasDocker();
+    spinner.text = "Checking agents...";
+    const agentStatuses = await checkAllAgents(config);
+    spinner.text = "Checking secrets...";
+    const secretsConfig = config.secrets;
+    const provider = secretsConfig?.provider || "env";
+    let secretsStatus = null;
+    if (secretsConfig) {
+      let cliInstalled = true;
+      let authenticated = true;
+      if (provider === "1password") {
+        cliInstalled = await hasOpCli2();
+        authenticated = cliInstalled && await isOpAuthenticated2();
+      } else if (provider === "vault") {
+        cliInstalled = await hasVaultCli2();
+        authenticated = cliInstalled && await isVaultAuthenticated2();
+      }
+      const envrcExists = await hasEnvrc(rootDir, secretsConfig);
+      const verified = await verifySecrets(secretsConfig);
+      secretsStatus = {
+        provider,
+        cliInstalled,
+        authenticated,
+        envrcExists,
+        secretsCount: secretsConfig.items ? Object.keys(secretsConfig.items).length : 0,
+        allAvailable: verified.allAvailable
+      };
+    }
+    spinner.text = "Checking authentication...";
+    const authStatus = await getAuthStatus();
+    spinner.stop();
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            configured: true,
+            configPath: filepath,
+            rootDir,
+            defaultAgent: config.agents.default,
+            container: {
+              configured: !!devcontainerConfig,
+              running: containerStatus.running,
+              name: containerStatus.containerName,
+              devcontainerCli: hasDevCli,
+              docker: dockerRunning
+            },
+            agents: agentStatuses,
+            secrets: secretsStatus,
+            auth: {
+              authenticated: authStatus.authenticated,
+              sources: authStatus.sources.map((s) => ({
+                source: s.source,
+                provider: s.provider,
+                authType: s.authType,
+                hasValue: !!s.value
+              }))
+            }
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log();
+    console.log(`  ${logger3.brand("RAPID")} Status`);
+    console.log(`  ${logger3.dim("\u2500".repeat(24))}`);
+    console.log();
+    console.log(`  ${logger3.dim("Config:")}      ${filepath}`);
+    console.log(`  ${logger3.dim("Root:")}        ${rootDir}`);
+    console.log();
+    console.log(`  ${logger3.dim("Container:")}`);
+    if (!devcontainerConfig) {
+      console.log(`    ${logger3.dim("\u25CB")} ${logger3.dim("No devcontainer.json configured")}`);
+    } else if (!dockerRunning) {
+      console.log(`    ${logger3.dim("\u25CB")} ${logger3.dim("Docker not running")}`);
+    } else if (!hasDevCli) {
+      console.log(`    ${logger3.dim("\u25CB")} ${logger3.dim("devcontainer CLI not installed")}`);
+    } else if (containerStatus.running) {
+      console.log(
+        `    ${logger3.brand("\u25CF")} Running ${logger3.dim(`(${containerStatus.containerName})`)}`
+      );
+    } else if (containerStatus.exists) {
+      console.log(
+        `    ${logger3.dim("\u25CB")} Stopped ${logger3.dim(`(${containerStatus.containerName})`)}`
+      );
+    } else {
+      console.log(`    ${logger3.dim("\u25CB")} Not started`);
+    }
+    console.log();
+    console.log(
+      `  ${logger3.dim("Agents:")}      ${logger3.dim(`(default: ${config.agents.default})`)}`
+    );
+    agentStatuses.forEach((status) => {
+      const isDefault = status.name === config.agents.default;
+      const icon = status.available ? logger3.brand("\u2713") : logger3.dim("\u25CB");
+      const name = isDefault ? logger3.bold(status.name) : status.name;
+      const version = status.version ? logger3.dim(` (${status.version})`) : "";
+      console.log(`    ${icon} ${name}${version}`);
+    });
+    console.log();
+    if (secretsStatus) {
+      const providerInfo = getProviderInfo(
+        secretsStatus.provider
+      );
+      console.log(`  ${logger3.dim("Secrets:")}     ${logger3.dim(`(${providerInfo.name})`)}`);
+      if (providerInfo.cliRequired) {
+        const cliIcon = secretsStatus.cliInstalled ? logger3.brand("\u2713") : logger3.dim("\u25CB");
+        console.log(
+          `    ${cliIcon} CLI ${secretsStatus.cliInstalled ? "installed" : "not installed"}`
+        );
+        if (secretsStatus.cliInstalled) {
+          const authIcon = secretsStatus.authenticated ? logger3.brand("\u2713") : logger3.dim("\u25CB");
+          console.log(
+            `    ${authIcon} ${secretsStatus.authenticated ? "Authenticated" : "Not authenticated"}`
+          );
+        }
+      }
+      if (secretsStatus.secretsCount > 0) {
+        const allIcon = secretsStatus.allAvailable ? logger3.brand("\u2713") : logger3.dim("\u25CB");
+        console.log(
+          `    ${allIcon} ${secretsStatus.secretsCount} secret${secretsStatus.secretsCount !== 1 ? "s" : ""} ${secretsStatus.allAvailable ? "available" : "configured"}`
+        );
+      }
+      const envrcIcon = secretsStatus.envrcExists ? logger3.brand("\u2713") : logger3.dim("\u25CB");
+      console.log(
+        `    ${envrcIcon} .envrc ${secretsStatus.envrcExists ? "exists" : "not generated"}`
+      );
+      console.log();
+    }
+    console.log(`  ${logger3.dim("Auth:")}`);
+    if (!authStatus.authenticated) {
+      console.log(`    ${logger3.dim("\u25CB")} ${logger3.dim("No authentication detected")}`);
+      console.log(`    ${logger3.dim("  Run `rapid auth` for options")}`);
+    } else {
+      for (const cred of authStatus.sources) {
+        const icon = cred.authType === "oauth" ? logger3.brand("\u25CF") : logger3.dim("\u25CB");
+        const authType = cred.authType === "oauth" ? "OAuth" : "API Key";
+        let info = `${cred.source} (${cred.provider}, ${authType})`;
+        if (cred.accountInfo?.email) {
+          info += ` - ${cred.accountInfo.email}`;
+        }
+        console.log(`    ${icon} ${info}`);
+      }
+    }
+    console.log();
+    if (!containerStatus.running && devcontainerConfig && dockerRunning && hasDevCli) {
+      logger3.info("Run `rapid start` to start the container");
+    } else if (containerStatus.running) {
+      logger3.info("Run `rapid dev` to start coding");
+    }
+    console.log();
+  } catch (error) {
+    logger3.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/agent.ts
+import { Command as Command4 } from "commander";
+import { loadConfig as loadConfig3, checkAllAgents as checkAllAgents2, logger as logger4 } from "@a3t/rapid-core";
+var agentCommand = new Command4("agent").description("Manage AI agents");
+agentCommand.command("list").description("List available agents").action(async () => {
+  try {
+    const loaded = await loadConfig3();
+    if (!loaded) {
+      logger4.error("No rapid.json found. Run `rapid init` first.");
+      process.exit(1);
+    }
+    const { config } = loaded;
+    const statuses = await checkAllAgents2(config);
+    logger4.header("Available Agents");
+    statuses.forEach((status) => {
+      const isDefault = status.name === config.agents.default;
+      const icon = status.available ? "\u2713" : "\u25CB";
+      const defaultTag = isDefault ? " (default)" : "";
+      const versionTag = status.version ? ` - ${status.version}` : "";
+      if (status.available) {
+        console.log(
+          `  ${logger4.brand(icon)} ${status.name}${defaultTag}${logger4.dim(versionTag)}`
+        );
+      } else {
+        console.log(
+          `  ${logger4.dim(icon)} ${logger4.dim(status.name)}${defaultTag} ${logger4.dim("[not installed]")}`
+        );
+      }
+    });
+    logger4.blank();
+  } catch (error) {
+    logger4.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+agentCommand.command("default [name]").description("Get or set default agent").action(async (name) => {
+  try {
+    const loaded = await loadConfig3();
+    if (!loaded) {
+      logger4.error("No rapid.json found. Run `rapid init` first.");
+      process.exit(1);
+    }
+    const { config } = loaded;
+    if (!name) {
+      console.log(config.agents.default);
+      return;
+    }
+    if (!config.agents.available[name]) {
+      logger4.error(`Agent "${name}" not found in configuration`);
+      logger4.info("Available agents:");
+      Object.keys(config.agents.available).forEach((n) => {
+        console.log(`  - ${n}`);
+      });
+      process.exit(1);
+    }
+    logger4.warn("Setting default agent requires editing rapid.json");
+    logger4.info(`Set "agents.default" to "${name}" in your rapid.json`);
+  } catch (error) {
+    logger4.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/start.ts
+import { Command as Command5 } from "commander";
+import {
+  loadConfig as loadConfig4,
+  logger as logger5,
+  hasDevcontainerCli as hasDevcontainerCli3,
+  hasDocker as hasDocker2,
+  loadDevcontainerConfig as loadDevcontainerConfig2,
+  getContainerStatus as getContainerStatus3,
+  startContainer as startContainer2
+} from "@a3t/rapid-core";
+import ora4 from "ora";
+var startCommand = new Command5("start").description("Start the development container").option("--rebuild", "Force rebuild the container", false).option("--no-cache", "Build without Docker cache", false).action(async (options) => {
+  const spinner = ora4("Starting development environment...").start();
+  try {
+    spinner.text = "Loading configuration...";
+    const loaded = await loadConfig4();
+    if (!loaded) {
+      spinner.fail("No rapid.json found. Run `rapid init` first.");
+      process.exit(1);
+    }
+    const { config, rootDir } = loaded;
+    spinner.text = "Checking devcontainer CLI...";
+    const hasDevCli = await hasDevcontainerCli3();
+    if (!hasDevCli) {
+      spinner.fail("devcontainer CLI not found");
+      logger5.blank();
+      logger5.info("Install with:");
+      console.log("  npm install -g @devcontainers/cli");
+      logger5.blank();
+      process.exit(1);
+    }
+    spinner.text = "Checking Docker...";
+    const dockerAvailable = await hasDocker2();
+    if (!dockerAvailable) {
+      spinner.fail("Docker is not running");
+      logger5.info("Please start Docker Desktop and try again.");
+      process.exit(1);
+    }
+    spinner.text = "Checking devcontainer configuration...";
+    const devcontainerConfig = await loadDevcontainerConfig2(rootDir, config);
+    if (!devcontainerConfig) {
+      spinner.fail("No devcontainer.json found");
+      logger5.blank();
+      logger5.info("Create a .devcontainer/devcontainer.json or run:");
+      console.log("  rapid init --template <template>");
+      logger5.blank();
+      process.exit(1);
+    }
+    spinner.text = "Checking container status...";
+    const status = await getContainerStatus3(rootDir, config);
+    if (status.running && !options.rebuild) {
+      spinner.succeed("Container already running");
+      logger5.info(`Container: ${status.containerName}`);
+      logger5.blank();
+      logger5.info("Run `rapid dev` to start coding");
+      return;
+    }
+    spinner.text = options.rebuild ? "Rebuilding container..." : "Starting container...";
+    spinner.stopAndPersist({ symbol: "\u{1F433}", text: spinner.text });
+    const result = await startContainer2(rootDir, config, {
+      rebuild: options.rebuild,
+      quiet: false
+    });
+    if (!result.success) {
+      logger5.blank();
+      logger5.error("Failed to start container");
+      logger5.error(result.error || "Unknown error");
+      process.exit(1);
+    }
+    logger5.blank();
+    logger5.success("Development environment ready!");
+    logger5.blank();
+    logger5.info("Next steps:");
+    console.log(`  ${logger5.dim("\u2022")} Run ${logger5.brand("rapid dev")} to start coding`);
+    console.log(`  ${logger5.dim("\u2022")} Run ${logger5.brand("rapid stop")} when done`);
+    logger5.blank();
+  } catch (error) {
+    spinner.fail("Failed to start environment");
+    logger5.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/stop.ts
+import { Command as Command6 } from "commander";
+import { loadConfig as loadConfig5, logger as logger6, getContainerStatus as getContainerStatus4, stopContainer } from "@a3t/rapid-core";
+import ora5 from "ora";
+var stopCommand = new Command6("stop").description("Stop the development container").option("--remove", "Remove container after stopping", false).action(async (options) => {
+  const spinner = ora5("Stopping development environment...").start();
+  try {
+    const loaded = await loadConfig5();
+    if (!loaded) {
+      spinner.fail("No rapid.json found");
+      process.exit(1);
+    }
+    const { config, rootDir } = loaded;
+    spinner.text = "Checking container status...";
+    const status = await getContainerStatus4(rootDir, config);
+    if (!status.exists) {
+      spinner.succeed("No container to stop");
+      return;
+    }
+    if (!status.running) {
+      if (options.remove) {
+        spinner.text = "Removing container...";
+        await stopContainer(rootDir, config, { remove: true });
+        spinner.succeed("Container removed");
+      } else {
+        spinner.succeed("Container already stopped");
+      }
+      return;
+    }
+    spinner.text = "Stopping container...";
+    const result = await stopContainer(rootDir, config, { remove: options.remove });
+    if (!result.success) {
+      spinner.fail("Failed to stop container");
+      logger6.error(result.error || "Unknown error");
+      process.exit(1);
+    }
+    spinner.succeed(options.remove ? "Container stopped and removed" : "Container stopped");
+  } catch (error) {
+    spinner.fail("Failed to stop environment");
+    logger6.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/secrets.ts
+import { Command as Command7 } from "commander";
+import {
+  loadConfig as loadConfig6,
+  logger as logger7,
+  verifySecrets as verifySecrets2,
+  loadSecrets as loadSecrets2,
+  hasOpCli as hasOpCli3,
+  hasVaultCli as hasVaultCli3,
+  isOpAuthenticated as isOpAuthenticated3,
+  isVaultAuthenticated as isVaultAuthenticated3,
+  getOpAuthStatus,
+  hasOpServiceAccountToken,
+  generateEnvrc,
+  writeEnvrc,
+  hasEnvrc as hasEnvrc2,
+  getProviderInfo as getProviderInfo2
+} from "@a3t/rapid-core";
+import ora6 from "ora";
+var secretsCommand = new Command7("secrets").description("Manage project secrets");
+secretsCommand.command("verify").description("Verify all secrets are accessible").option("--json", "Output as JSON").action(async (options) => {
+  const spinner = ora6("Verifying secrets...").start();
+  try {
+    const loaded = await loadConfig6();
+    if (!loaded) {
+      spinner.fail("No rapid.json found");
+      process.exit(1);
+    }
+    const { config } = loaded;
+    const secretsConfig = config.secrets;
+    if (!secretsConfig) {
+      spinner.info("No secrets configured");
+      return;
+    }
+    const provider = secretsConfig.provider || "env";
+    spinner.text = `Checking ${provider} availability...`;
+    if (provider === "1password") {
+      const hasOp = await hasOpCli3();
+      if (!hasOp) {
+        spinner.fail("1Password CLI (op) not found");
+        console.log();
+        logger7.info("Install with: brew install 1password-cli");
+        logger7.info("More info: https://developer.1password.com/docs/cli/get-started/");
+        process.exit(1);
+      }
+      const authenticated = await isOpAuthenticated3();
+      if (!authenticated) {
+        spinner.fail("1Password CLI not authenticated");
+        console.log();
+        logger7.info("Run: eval $(op signin)");
+        process.exit(1);
+      }
+    } else if (provider === "vault") {
+      const hasVault = await hasVaultCli3();
+      if (!hasVault) {
+        spinner.fail("Vault CLI not found");
+        console.log();
+        logger7.info("Install from: https://developer.hashicorp.com/vault/docs/install");
+        process.exit(1);
+      }
+      const authenticated = await isVaultAuthenticated3();
+      if (!authenticated) {
+        spinner.fail("Vault CLI not authenticated");
+        console.log();
+        logger7.info("Run: vault login");
+        process.exit(1);
+      }
+    }
+    spinner.text = "Verifying secrets...";
+    const status = await verifySecrets2(secretsConfig);
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+    console.log();
+    console.log(`  ${logger7.brand("Secrets")} Verification`);
+    console.log(`  ${logger7.dim("\u2500".repeat(24))}`);
+    console.log();
+    console.log(`  ${logger7.dim("Provider:")}  ${getProviderInfo2(provider).name}`);
+    console.log(
+      `  ${logger7.dim("Auth:")}      ${status.authenticated ? logger7.brand("\u2713") : logger7.dim("\u25CB")} ${status.authenticated ? "Authenticated" : "Not authenticated"}`
+    );
+    console.log();
+    if (status.secrets.length === 0) {
+      console.log(`  ${logger7.dim("No secrets configured in rapid.json")}`);
+      console.log();
+      return;
+    }
+    console.log(`  ${logger7.dim("Secrets:")}`);
+    for (const secret of status.secrets) {
+      const icon = secret.available ? logger7.brand("\u2713") : "\u2717";
+      const ref = logger7.dim(`(${provider})`);
+      const error = secret.error ? logger7.dim(` - ${secret.error}`) : "";
+      console.log(`    ${icon} ${secret.name} ${ref}${error}`);
+    }
+    console.log();
+    if (status.allAvailable) {
+      logger7.info("All secrets verified successfully!");
+    } else {
+      logger7.error("Some secrets are not available");
+      process.exit(1);
+    }
+    console.log();
+  } catch (error) {
+    spinner.fail("Failed to verify secrets");
+    logger7.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+secretsCommand.command("list").description("List configured secrets (names only, not values)").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const loaded = await loadConfig6();
+    if (!loaded) {
+      logger7.error("No rapid.json found");
+      process.exit(1);
+    }
+    const { config } = loaded;
+    const secretsConfig = config.secrets;
+    if (!secretsConfig || !secretsConfig.items || Object.keys(secretsConfig.items).length === 0) {
+      if (options.json) {
+        console.log(JSON.stringify({ secrets: [] }, null, 2));
+      } else {
+        logger7.info("No secrets configured");
+      }
+      return;
+    }
+    const provider = secretsConfig.provider || "env";
+    if (options.json) {
+      const secrets = Object.entries(secretsConfig.items).map(([name, reference]) => ({
+        name,
+        reference,
+        provider
+      }));
+      console.log(JSON.stringify({ provider, secrets }, null, 2));
+      return;
+    }
+    console.log();
+    console.log(`  ${logger7.brand("Configured Secrets")}`);
+    console.log(`  ${logger7.dim("\u2500".repeat(24))}`);
+    console.log();
+    console.log(`  ${logger7.dim("Provider:")} ${getProviderInfo2(provider).name}`);
+    console.log();
+    const maxNameLen = Math.max(...Object.keys(secretsConfig.items).map((n) => n.length));
+    for (const [name, reference] of Object.entries(secretsConfig.items)) {
+      const paddedName = name.padEnd(maxNameLen);
+      console.log(`  ${logger7.brand("\u2022")} ${paddedName}  ${logger7.dim(reference)}`);
+    }
+    console.log();
+  } catch (error) {
+    logger7.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+secretsCommand.command("generate").description("Generate .envrc file from rapid.json configuration").option("--force", "Overwrite existing .envrc", false).option("--stdout", "Print to stdout instead of writing file", false).action(async (options) => {
+  try {
+    const loaded = await loadConfig6();
+    if (!loaded) {
+      logger7.error("No rapid.json found");
+      process.exit(1);
+    }
+    const { config, rootDir } = loaded;
+    const secretsConfig = config.secrets;
+    if (!secretsConfig) {
+      logger7.error("No secrets configuration in rapid.json");
+      process.exit(1);
+    }
+    const content = generateEnvrc(secretsConfig);
+    if (options.stdout) {
+      console.log(content);
+      return;
+    }
+    const envrcExists = await hasEnvrc2(rootDir, secretsConfig);
+    if (envrcExists && !options.force) {
+      logger7.error(".envrc already exists. Use --force to overwrite.");
+      process.exit(1);
+    }
+    const spinner = ora6("Generating .envrc...").start();
+    const filepath = await writeEnvrc(rootDir, secretsConfig);
+    spinner.succeed("Generated .envrc");
+    console.log();
+    console.log(`  ${logger7.dim("File:")} ${filepath}`);
+    console.log();
+    const itemCount = secretsConfig.items ? Object.keys(secretsConfig.items).length : 0;
+    logger7.info(`Generated .envrc with ${itemCount} secret${itemCount !== 1 ? "s" : ""}`);
+    logger7.info(`Run ${logger7.brand("direnv allow")} to activate`);
+    console.log();
+  } catch (error) {
+    logger7.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+secretsCommand.command("info").description("Show secrets provider information and authentication status").option("--json", "Output as JSON").action(async (options) => {
+  const spinner = ora6("Checking provider status...").start();
+  try {
+    const loaded = await loadConfig6();
+    if (!loaded) {
+      spinner.fail("No rapid.json found");
+      process.exit(1);
+    }
+    const { config, rootDir } = loaded;
+    const secretsConfig = config.secrets || { provider: "env" };
+    const provider = secretsConfig.provider || "env";
+    const info = getProviderInfo2(provider);
+    let cliInstalled = true;
+    let authenticated = true;
+    let opAuthStatus = null;
+    if (provider === "1password") {
+      cliInstalled = await hasOpCli3();
+      if (cliInstalled) {
+        opAuthStatus = await getOpAuthStatus();
+        authenticated = opAuthStatus.authenticated;
+      } else {
+        authenticated = false;
+      }
+    } else if (provider === "vault") {
+      cliInstalled = await hasVaultCli3();
+      authenticated = cliInstalled && await isVaultAuthenticated3();
+    }
+    const envrcExists = await hasEnvrc2(rootDir, secretsConfig);
+    const hasServiceToken = hasOpServiceAccountToken();
+    spinner.stop();
+    const status = {
+      provider,
+      providerName: info.name,
+      cliRequired: info.cliRequired,
+      cliInstalled,
+      authenticated,
+      authMethod: opAuthStatus?.method,
+      accountInfo: opAuthStatus?.accountInfo,
+      hasServiceToken,
+      envrcExists,
+      envrcPath: secretsConfig.envrc?.path || ".envrc",
+      secretsCount: secretsConfig.items ? Object.keys(secretsConfig.items).length : 0
+    };
+    if (options.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+    console.log();
+    console.log(`  ${logger7.brand("Secrets")} Provider Info`);
+    console.log(`  ${logger7.dim("\u2500".repeat(24))}`);
+    console.log();
+    console.log(`  ${logger7.dim("Provider:")}      ${info.name}`);
+    if (info.cliRequired) {
+      const cliIcon = cliInstalled ? logger7.brand("\u2713") : "\u2717";
+      console.log(
+        `  ${logger7.dim("CLI:")}          ${cliIcon} ${info.cliRequired} ${cliInstalled ? "" : logger7.dim("(not installed)")}`
+      );
+      if (cliInstalled && provider === "1password" && opAuthStatus) {
+        const authIcon = authenticated ? logger7.brand("\u2713") : "\u2717";
+        const methodLabel = opAuthStatus.method === "service-account" ? "Service Account" : opAuthStatus.method === "user" ? "User" : "Not authenticated";
+        const accountLabel = opAuthStatus.accountInfo ? ` (${opAuthStatus.accountInfo})` : "";
+        console.log(`  ${logger7.dim("Auth:")}         ${authIcon} ${methodLabel}${accountLabel}`);
+        if (hasServiceToken) {
+          console.log(
+            `  ${logger7.dim("Token:")}        ${logger7.brand("\u2713")} OP_SERVICE_ACCOUNT_TOKEN set`
+          );
+        }
+      } else if (cliInstalled) {
+        const authIcon = authenticated ? logger7.brand("\u2713") : "\u2717";
+        console.log(
+          `  ${logger7.dim("Auth:")}         ${authIcon} ${authenticated ? "Authenticated" : "Not authenticated"}`
+        );
+      }
+      if (info.installUrl && !cliInstalled) {
+        console.log();
+        console.log(`  ${logger7.dim("Install:")}      ${info.installUrl}`);
+      }
+      if (info.authCommand && cliInstalled && !authenticated) {
+        console.log();
+        console.log(`  ${logger7.dim("Authenticate:")} ${info.authCommand}`);
+        if (provider === "1password") {
+          console.log(
+            `  ${logger7.dim("Or set:")}       OP_SERVICE_ACCOUNT_TOKEN for non-interactive auth`
+          );
+        }
+      }
+    }
+    console.log();
+    const envrcIcon = envrcExists ? logger7.brand("\u2713") : logger7.dim("\u25CB");
+    console.log(
+      `  ${logger7.dim(".envrc:")}       ${envrcIcon} ${envrcExists ? "Exists" : "Not generated"}`
+    );
+    console.log(`  ${logger7.dim("Secrets:")}      ${status.secretsCount} configured`);
+    console.log();
+    if (!envrcExists && status.secretsCount > 0) {
+      logger7.info(`Run ${logger7.brand("rapid secrets generate")} to create .envrc`);
+      console.log();
+    }
+  } catch (error) {
+    spinner.fail("Failed to get provider info");
+    logger7.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+secretsCommand.command("run").description("Run a command with secrets loaded into environment").argument("<command...>", "Command to run with secrets").option("--show", "Show which secrets are being loaded (names only)", false).action(async (commandArgs, options) => {
+  try {
+    const loaded = await loadConfig6();
+    if (!loaded) {
+      logger7.error("No rapid.json found");
+      process.exit(1);
+    }
+    const { config } = loaded;
+    const secretsConfig = config.secrets;
+    if (!secretsConfig || !secretsConfig.items) {
+      logger7.error("No secrets configured in rapid.json");
+      process.exit(1);
+    }
+    const provider = secretsConfig.provider || "env";
+    if (provider === "1password") {
+      const hasOp = await hasOpCli3();
+      if (!hasOp) {
+        logger7.error("1Password CLI (op) not found");
+        logger7.info("Install with: brew install 1password-cli");
+        process.exit(1);
+      }
+      const authenticated = await isOpAuthenticated3();
+      if (!authenticated) {
+        logger7.error("1Password not authenticated");
+        logger7.info("Run: eval $(op signin)");
+        process.exit(1);
+      }
+    }
+    const secrets = await loadSecrets2(secretsConfig);
+    const secretCount = Object.keys(secrets).length;
+    if (secretCount === 0) {
+      logger7.warn("No secrets were loaded");
+    } else if (options.show) {
+      logger7.info(`Loaded ${secretCount} secret${secretCount !== 1 ? "s" : ""}:`);
+      for (const name of Object.keys(secrets)) {
+        console.log(`  ${logger7.brand("\u2022")} ${name}`);
+      }
+      console.log();
+    }
+    const { execa: execa4 } = await import("execa");
+    const [cmd, ...args] = commandArgs;
+    if (!cmd) {
+      logger7.error("No command specified");
+      process.exit(1);
+    }
+    await execa4(cmd, args, {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        ...secrets
+      }
+    });
+  } catch (error) {
+    if (error.exitCode !== void 0) {
+      process.exit(error.exitCode);
+    }
+    logger7.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/auth.ts
+import { Command as Command8 } from "commander";
+import {
+  logger as logger8,
+  getAuthStatus as getAuthStatus2,
+  detectAllCredentials
+} from "@a3t/rapid-core";
+import ora7 from "ora";
+var authCommand = new Command8("auth").description("Show authentication status from external tools").option("--json", "Output as JSON").option("--source <source>", "Filter by source (claude-code, codex, gemini-cli, aider, env)").option("--provider <provider>", "Filter by provider (anthropic, openai, google)").action(async (options) => {
+  try {
+    const spinner = ora7("Checking authentication...").start();
+    const status = await getAuthStatus2();
+    spinner.stop();
+    if (options.json) {
+      let credentials = status.sources;
+      if (options.source) {
+        credentials = credentials.filter((c) => c.source === options.source);
+      }
+      if (options.provider) {
+        credentials = credentials.filter(
+          (c) => c.provider === options.provider
+        );
+      }
+      const sanitized = credentials.map((c) => ({
+        source: c.source,
+        provider: c.provider,
+        authType: c.authType,
+        envVar: c.envVar,
+        expiresAt: c.expiresAt?.toISOString(),
+        accountInfo: c.accountInfo,
+        configPath: c.configPath,
+        hasValue: !!c.value
+      }));
+      console.log(
+        JSON.stringify(
+          {
+            authenticated: sanitized.length > 0,
+            sources: sanitized,
+            warnings: status.warnings
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log();
+    console.log(`  ${logger8.brand("RAPID")} Authentication`);
+    console.log(`  ${logger8.dim("\u2500".repeat(24))}`);
+    console.log();
+    if (!status.authenticated) {
+      console.log(`  ${logger8.dim("No authentication detected")}`);
+      console.log();
+      console.log("  To authenticate, use one of these methods:");
+      console.log();
+      console.log(`    ${logger8.brand("Claude Pro/Max:")}`);
+      console.log("      Run `claude` and sign in with your Anthropic account");
+      console.log();
+      console.log(`    ${logger8.brand("OpenAI (ChatGPT Plus/Pro):")}`);
+      console.log("      Run `codex` and sign in with ChatGPT");
+      console.log();
+      console.log(`    ${logger8.brand("Gemini:")}`);
+      console.log("      Run `gemini` and sign in with your Google account");
+      console.log();
+      console.log(`    ${logger8.brand("API Keys:")}`);
+      console.log("      Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY");
+      console.log();
+      return;
+    }
+    for (const cred of status.sources) {
+      if (options.source && cred.source !== options.source) continue;
+      if (options.provider && cred.provider !== options.provider) continue;
+      const isPrimary = cred === status.preferredSource;
+      const icon = isPrimary ? logger8.brand("\u25CF") : logger8.dim("\u25CB");
+      const authIcon = cred.authType === "oauth" ? logger8.brand("OAuth") : logger8.dim("API Key");
+      console.log(`  ${icon} ${logger8.bold(cred.source)}`);
+      console.log(`    Provider: ${cred.provider}`);
+      console.log(`    Auth: ${authIcon}`);
+      if (cred.accountInfo?.email) {
+        console.log(`    Account: ${cred.accountInfo.email}`);
+      }
+      if (cred.accountInfo?.organization) {
+        console.log(`    Org: ${cred.accountInfo.organization}`);
+      }
+      if (cred.accountInfo?.plan) {
+        console.log(`    Plan: ${logger8.brand(cred.accountInfo.plan)}`);
+      }
+      if (cred.expiresAt) {
+        const now = /* @__PURE__ */ new Date();
+        const expiresIn = Math.round((cred.expiresAt.getTime() - now.getTime()) / 1e3 / 60);
+        if (expiresIn > 0) {
+          console.log(`    Expires: in ${expiresIn} minutes`);
+        } else {
+          console.log(`    Expires: ${logger8.dim("EXPIRED")}`);
+        }
+      }
+      if (cred.configPath) {
+        console.log(`    Config: ${logger8.dim(cred.configPath)}`);
+      }
+      if (cred.envVar) {
+        console.log(`    Env: ${logger8.dim(cred.envVar)}`);
+      }
+      if (isPrimary) {
+        console.log(`    ${logger8.brand("\u2192 Primary source")}`);
+      }
+      console.log();
+    }
+    if (status.warnings && status.warnings.length > 0) {
+      console.log(`  ${logger8.dim("Warnings:")}`);
+      for (const warning of status.warnings) {
+        console.log(`    ! ${warning}`);
+      }
+      console.log();
+    }
+    console.log(`  ${logger8.dim("Tip:")} RAPID will automatically use detected`);
+    console.log(`  ${logger8.dim("     ")} credentials when launching AI agents.`);
+    console.log();
+  } catch (error) {
+    logger8.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+authCommand.command("env").description("Show environment variables for detected credentials").option("--export", "Output as export statements").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const credentials = await detectAllCredentials();
+    const byProvider = /* @__PURE__ */ new Map();
+    for (const cred of credentials) {
+      if (!cred.value) continue;
+      const existing = byProvider.get(cred.provider);
+      if (!existing || cred.authType === "oauth" && cred.envVar) {
+        let envVar;
+        switch (cred.provider) {
+          case "anthropic":
+            envVar = cred.authType === "oauth" ? "ANTHROPIC_AUTH_TOKEN" : "ANTHROPIC_API_KEY";
+            break;
+          case "openai":
+            envVar = cred.authType === "oauth" ? "OPENAI_AUTH_TOKEN" : "OPENAI_API_KEY";
+            break;
+          case "google":
+            envVar = cred.authType === "oauth" ? "GOOGLE_AUTH_TOKEN" : cred.envVar || "GEMINI_API_KEY";
+            break;
+          default:
+            continue;
+        }
+        const masked = cred.value.slice(0, 8) + "..." + cred.value.slice(-4);
+        byProvider.set(cred.provider, { envVar, masked });
+      }
+    }
+    if (options.json) {
+      const result = {};
+      for (const [, { envVar, masked }] of byProvider) {
+        result[envVar] = masked;
+      }
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (options.export) {
+      for (const [, { envVar }] of byProvider) {
+        console.log(`# ${envVar} detected from external auth`);
+        console.log(`# export ${envVar}="<your-token>"`);
+      }
+      return;
+    }
+    console.log();
+    console.log(`  ${logger8.brand("RAPID")} Auth Environment`);
+    console.log(`  ${logger8.dim("\u2500".repeat(24))}`);
+    console.log();
+    if (byProvider.size === 0) {
+      console.log(`  ${logger8.dim("No credentials detected")}`);
+      console.log();
+      return;
+    }
+    for (const [provider, { envVar, masked }] of byProvider) {
+      console.log(`  ${logger8.brand(provider)}`);
+      console.log(`    ${envVar}=${masked}`);
+      console.log();
+    }
+    console.log(`  ${logger8.dim("These will be automatically injected when running agents.")}`);
+    console.log();
+  } catch (error) {
+    logger8.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/mcp.ts
+import { Command as Command9 } from "commander";
+import { writeFile as writeFile4 } from "fs/promises";
+import { join as join5 } from "path";
+import {
+  loadConfig as loadConfig7,
+  logger as logger9,
+  getMcpServers,
+  getMcpServerStatus,
+  addMcpServerFromTemplate as addMcpServerFromTemplate2,
+  addMcpServer,
+  removeMcpServer,
+  enableMcpServer,
+  disableMcpServer,
+  writeMcpConfig as writeMcpConfig2,
+  writeOpenCodeConfig as writeOpenCodeConfig2,
+  MCP_SERVER_TEMPLATES as MCP_SERVER_TEMPLATES2,
+  getMcpTemplate
+} from "@a3t/rapid-core";
+import ora8 from "ora";
+var mcpCommand = new Command9("mcp").description(
+  "Manage MCP (Model Context Protocol) servers"
+);
+async function saveConfig(rootDir, config) {
+  const configPath = join5(rootDir, "rapid.json");
+  await writeFile4(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+mcpCommand.command("list").description("List configured MCP servers").option("--json", "Output as JSON").option("--templates", "Show available templates instead of configured servers").action(async (options) => {
+  try {
+    if (options.templates) {
+      if (options.json) {
+        console.log(JSON.stringify(MCP_SERVER_TEMPLATES2, null, 2));
+        return;
+      }
+      console.log();
+      console.log(`  ${logger9.brand("Available MCP Server Templates")}`);
+      console.log(`  ${logger9.dim("\u2500".repeat(40))}`);
+      console.log();
+      for (const [name, template] of Object.entries(MCP_SERVER_TEMPLATES2)) {
+        const typeLabel = template.type === "remote" ? logger9.dim("(remote)") : logger9.dim("(stdio)");
+        const secretsLabel = template.requiredSecrets.length > 0 ? logger9.dim(` - requires: ${template.requiredSecrets.join(", ")}`) : logger9.dim(" - no secrets required");
+        console.log(`  ${logger9.brand("\u2022")} ${name} ${typeLabel}`);
+        console.log(`    ${template.description}${secretsLabel}`);
+        console.log();
+      }
+      logger9.info(`Use ${logger9.brand("rapid mcp add <name>")} to add a server`);
+      console.log();
+      return;
+    }
+    const loaded = await loadConfig7();
+    if (!loaded) {
+      logger9.error("No rapid.json found. Run `rapid init` first.");
+      process.exit(1);
+    }
+    const { config } = loaded;
+    const servers = getMcpServers(config);
+    if (options.json) {
+      console.log(JSON.stringify({ servers }, null, 2));
+      return;
+    }
+    console.log();
+    console.log(`  ${logger9.brand("MCP Servers")}`);
+    console.log(`  ${logger9.dim("\u2500".repeat(40))}`);
+    console.log();
+    if (servers.length === 0) {
+      console.log(`  ${logger9.dim("No MCP servers configured")}`);
+      console.log();
+      logger9.info(`Use ${logger9.brand("rapid mcp add <name>")} to add a server`);
+      logger9.info(`Use ${logger9.brand("rapid mcp list --templates")} to see available templates`);
+      console.log();
+      return;
+    }
+    for (const server of servers) {
+      const icon = server.enabled ? logger9.brand("\u2713") : logger9.dim("\u25CB");
+      const typeLabel = server.type === "remote" ? logger9.dim("(remote)") : logger9.dim("(stdio)");
+      const statusLabel = server.enabled ? "" : logger9.dim(" [disabled]");
+      const location = server.type === "remote" ? logger9.dim(server.url || "") : logger9.dim(server.command || "");
+      console.log(`  ${icon} ${server.name} ${typeLabel}${statusLabel}`);
+      if (location) {
+        console.log(`    ${location}`);
+      }
+      console.log();
+    }
+  } catch (error) {
+    logger9.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+mcpCommand.command("add").description("Add an MCP server").argument("<name>", "Server name (or template name)").option("--type <type>", "Server type: remote or stdio").option("--url <url>", "URL for remote servers").option("--command <cmd>", "Command for stdio servers").option("--args <args>", "Arguments for stdio command (comma-separated)").option("--header <header>", "HTTP header for remote servers (name=value)", collectHeaders, {}).action(async (name, options) => {
+  const spinner = ora8(`Adding MCP server '${name}'...`).start();
+  try {
+    const loaded = await loadConfig7();
+    if (!loaded) {
+      spinner.fail("No rapid.json found. Run `rapid init` first.");
+      process.exit(1);
+    }
+    let { config } = loaded;
+    const { rootDir } = loaded;
+    const existingServers = getMcpServers(config);
+    if (existingServers.some((s) => s.name === name)) {
+      spinner.fail(`MCP server '${name}' already exists`);
+      logger9.info(`Use ${logger9.brand(`rapid mcp remove ${name}`)} to remove it first`);
+      process.exit(1);
+    }
+    const template = getMcpTemplate(name);
+    if (template && !options.type && !options.url && !options.command) {
+      config = addMcpServerFromTemplate2(config, name);
+      spinner.text = `Adding '${name}' from template...`;
+    } else if (options.type || options.url || options.command) {
+      const serverConfig = {
+        enabled: true
+      };
+      if (options.type) {
+        serverConfig.type = options.type;
+      }
+      if (options.url) {
+        serverConfig.type = "remote";
+        serverConfig.url = options.url;
+      }
+      if (options.header && Object.keys(options.header).length > 0) {
+        serverConfig.headers = options.header;
+      }
+      if (options.command) {
+        serverConfig.type = "stdio";
+        serverConfig.command = options.command;
+      }
+      if (options.args) {
+        serverConfig.args = options.args.split(",").map((a) => a.trim());
+      }
+      config = addMcpServer(config, name, serverConfig);
+    } else if (template) {
+      config = addMcpServerFromTemplate2(config, name);
+    } else {
+      spinner.fail(`Unknown MCP server template: ${name}`);
+      logger9.info(`Use ${logger9.brand("rapid mcp list --templates")} to see available templates`);
+      logger9.info("Or specify --type, --url, or --command for a custom server");
+      process.exit(1);
+    }
+    await saveConfig(rootDir, config);
+    await writeMcpConfig2(rootDir, config);
+    await writeOpenCodeConfig2(rootDir, config);
+    spinner.succeed(`Added MCP server '${name}'`);
+    console.log();
+    if (template?.requiredSecrets.length) {
+      logger9.info("Required secrets:");
+      for (const secret of template.requiredSecrets) {
+        const ref = template.secretReferences?.[secret];
+        console.log(`  ${logger9.brand("\u2022")} ${secret}${ref ? logger9.dim(` (${ref})`) : ""}`);
+      }
+      console.log();
+      logger9.info(`Add these to ${logger9.brand("rapid.json")} secrets.items section`);
+      console.log();
+    }
+  } catch (error) {
+    spinner.fail("Failed to add MCP server");
+    logger9.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+mcpCommand.command("remove").description("Remove an MCP server").argument("<name>", "Server name to remove").action(async (name) => {
+  const spinner = ora8(`Removing MCP server '${name}'...`).start();
+  try {
+    const loaded = await loadConfig7();
+    if (!loaded) {
+      spinner.fail("No rapid.json found");
+      process.exit(1);
+    }
+    let { config } = loaded;
+    const { rootDir } = loaded;
+    config = removeMcpServer(config, name);
+    await saveConfig(rootDir, config);
+    await writeMcpConfig2(rootDir, config);
+    await writeOpenCodeConfig2(rootDir, config);
+    spinner.succeed(`Removed MCP server '${name}'`);
+    console.log();
+  } catch (error) {
+    spinner.fail("Failed to remove MCP server");
+    logger9.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+mcpCommand.command("enable").description("Enable a disabled MCP server").argument("<name>", "Server name to enable").action(async (name) => {
+  const spinner = ora8(`Enabling MCP server '${name}'...`).start();
+  try {
+    const loaded = await loadConfig7();
+    if (!loaded) {
+      spinner.fail("No rapid.json found");
+      process.exit(1);
+    }
+    let { config } = loaded;
+    const { rootDir } = loaded;
+    config = enableMcpServer(config, name);
+    await saveConfig(rootDir, config);
+    await writeMcpConfig2(rootDir, config);
+    await writeOpenCodeConfig2(rootDir, config);
+    spinner.succeed(`Enabled MCP server '${name}'`);
+    console.log();
+  } catch (error) {
+    spinner.fail("Failed to enable MCP server");
+    logger9.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+mcpCommand.command("disable").description("Disable an MCP server (without removing)").argument("<name>", "Server name to disable").action(async (name) => {
+  const spinner = ora8(`Disabling MCP server '${name}'...`).start();
+  try {
+    const loaded = await loadConfig7();
+    if (!loaded) {
+      spinner.fail("No rapid.json found");
+      process.exit(1);
+    }
+    let { config } = loaded;
+    const { rootDir } = loaded;
+    config = disableMcpServer(config, name);
+    await saveConfig(rootDir, config);
+    await writeMcpConfig2(rootDir, config);
+    await writeOpenCodeConfig2(rootDir, config);
+    spinner.succeed(`Disabled MCP server '${name}'`);
+    console.log();
+  } catch (error) {
+    spinner.fail("Failed to disable MCP server");
+    logger9.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+mcpCommand.command("status").description("Show MCP server status").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const loaded = await loadConfig7();
+    if (!loaded) {
+      logger9.error("No rapid.json found. Run `rapid init` first.");
+      process.exit(1);
+    }
+    const { config } = loaded;
+    const servers = getMcpServerStatus(config);
+    if (options.json) {
+      console.log(JSON.stringify({ servers }, null, 2));
+      return;
+    }
+    console.log();
+    console.log(`  ${logger9.brand("MCP Server Status")}`);
+    console.log(`  ${logger9.dim("\u2500".repeat(40))}`);
+    console.log();
+    if (servers.length === 0) {
+      console.log(`  ${logger9.dim("No MCP servers configured")}`);
+      console.log();
+      return;
+    }
+    let enabledCount = 0;
+    let disabledCount = 0;
+    for (const server of servers) {
+      if (server.enabled) {
+        enabledCount++;
+      } else {
+        disabledCount++;
+      }
+      const icon = server.status === "enabled" ? logger9.brand("\u2713") : server.status === "disabled" ? logger9.dim("\u25CB") : "\u2717";
+      const statusLabel = server.status === "enabled" ? "enabled" : server.status === "disabled" ? logger9.dim("disabled") : logger9.dim(`error: ${server.error}`);
+      const typeLabel = server.type === "remote" ? "remote" : "stdio";
+      console.log(`  ${icon} ${server.name}`);
+      console.log(`    ${logger9.dim("Type:")}   ${typeLabel}`);
+      console.log(`    ${logger9.dim("Status:")} ${statusLabel}`);
+      if (server.url) {
+        console.log(`    ${logger9.dim("URL:")}    ${server.url}`);
+      }
+      if (server.command) {
+        console.log(`    ${logger9.dim("Cmd:")}    ${server.command}`);
+      }
+      console.log();
+    }
+    console.log(`  ${logger9.dim("Summary:")} ${enabledCount} enabled, ${disabledCount} disabled`);
+    console.log();
+  } catch (error) {
+    logger9.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+mcpCommand.command("sync").description("Regenerate .mcp.json and opencode.json from rapid.json").action(async () => {
+  const spinner = ora8("Syncing MCP configuration files...").start();
+  try {
+    const loaded = await loadConfig7();
+    if (!loaded) {
+      spinner.fail("No rapid.json found");
+      process.exit(1);
+    }
+    const { config, rootDir } = loaded;
+    await writeMcpConfig2(rootDir, config);
+    await writeOpenCodeConfig2(rootDir, config);
+    const servers = getMcpServers(config);
+    const enabledCount = servers.filter((s) => s.enabled).length;
+    spinner.succeed("MCP configuration synced");
+    console.log();
+    console.log(`  ${logger9.dim("Files updated:")}`);
+    console.log(`    ${logger9.brand("\u2022")} .mcp.json`);
+    console.log(`    ${logger9.brand("\u2022")} opencode.json`);
+    console.log();
+    console.log(`  ${logger9.dim("Servers:")} ${enabledCount} enabled`);
+    console.log();
+  } catch (error) {
+    spinner.fail("Failed to sync MCP configuration");
+    logger9.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+function collectHeaders(value, previous) {
+  const [name, ...rest] = value.split("=");
+  if (name && rest.length > 0) {
+    previous[name] = rest.join("=");
+  }
+  return previous;
+}
+
+// src/commands/update.ts
+import { Command as Command10 } from "commander";
+
+// src/utils/update-checker.ts
+import updateNotifier from "update-notifier";
+import semver from "semver";
+import { execa as execa3 } from "execa";
+import { logger as logger10 } from "@a3t/rapid-core";
+import chalk from "chalk";
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname3, join as join6 } from "path";
+import prompts from "prompts";
+var __dirname = dirname3(fileURLToPath2(import.meta.url));
+function loadPackageJson() {
+  const paths = [
+    join6(__dirname, "../package.json"),
+    // bundled: dist/ -> package root
+    join6(__dirname, "../../package.json")
+    // source: src/utils/ -> package root
+  ];
+  for (const p of paths) {
+    if (existsSync2(p)) {
+      return JSON.parse(readFileSync(p, "utf-8"));
+    }
+  }
+  return { name: "@a3t/rapid", version: "0.0.0" };
+}
+var packageJson = loadPackageJson();
+var UpdateChecker = class {
+  notifier;
+  packageName = packageJson.name;
+  constructor() {
+    this.notifier = updateNotifier({
+      pkg: packageJson,
+      updateCheckInterval: 1e3 * 60 * 60 * 24,
+      // Check daily
+      shouldNotifyInNpmScript: true
+    });
+  }
+  /**
+   * Check if an update is available
+   */
+  hasUpdate() {
+    return !!this.notifier.update;
+  }
+  /**
+   * Get update information
+   */
+  getUpdateInfo() {
+    if (!this.notifier.update) return null;
+    return {
+      current: this.notifier.update.current,
+      latest: this.notifier.update.latest,
+      type: this.getUpdateType(this.notifier.update.current, this.notifier.update.latest)
+    };
+  }
+  /**
+   * Determine the type of update (major, minor, patch)
+   */
+  getUpdateType(current, latest) {
+    const diff = semver.diff(current, latest);
+    if (diff === "premajor" || diff === "preminor" || diff === "prepatch") {
+      return "prerelease";
+    }
+    return diff || "patch";
+  }
+  /**
+   * Show update notification
+   */
+  showNotification() {
+    if (!this.notifier.update) return;
+    const { current, latest } = this.notifier.update;
+    const updateType = this.getUpdateType(current, latest);
+    logger10.info(`Update available: ${logger10.dim(current)} \u2192 ${chalk.green(latest)}`);
+    if (updateType === "major") {
+      logger10.warn("This is a major version update with breaking changes.");
+    }
+  }
+  /**
+   * Verify package signatures using npm audit signatures
+   */
+  async verifySignatures() {
+    try {
+      logger10.info("Verifying package signatures...");
+      const result = await execa3("npm", ["audit", "signatures"], {
+        reject: false
+      });
+      if (result.exitCode === 0) {
+        logger10.success("Package signatures verified successfully");
+        return true;
+      } else {
+        logger10.warn("Package signature verification returned warnings");
+        logger10.debug(result.stdout || result.stderr);
+        return true;
+      }
+    } catch {
+      logger10.debug("Signature verification not available (requires npm >= 9)");
+      return true;
+    }
+  }
+  /**
+   * Perform the update with signature verification
+   */
+  async performUpdate() {
+    try {
+      logger10.info("Updating RAPID CLI...");
+      await execa3("npm", ["install", "-g", `${this.packageName}@latest`], {
+        stdio: "inherit"
+      });
+      await this.verifySignatures();
+      logger10.success("RAPID CLI updated successfully!");
+      logger10.info("Package published with npm provenance - cryptographically verified");
+      return true;
+    } catch (error) {
+      logger10.error("Failed to update RAPID CLI:", error);
+      return false;
+    }
+  }
+  /**
+   * Check for updates and handle them according to version type
+   */
+  async checkAndUpdate() {
+    if (!this.hasUpdate()) return;
+    const updateInfo = this.getUpdateInfo();
+    if (!updateInfo) return;
+    this.showNotification();
+    if (updateInfo.type === "major") {
+      logger10.warn(
+        `This is a major version update (${updateInfo.current} \u2192 ${updateInfo.latest}) that may contain breaking changes.`
+      );
+      try {
+        const response = await prompts({
+          type: "confirm",
+          name: "shouldUpdate",
+          message: "Would you like to update to this major version?",
+          initial: false
+        });
+        if (response.shouldUpdate) {
+          logger10.info(`Updating to ${updateInfo.latest} (major version)...`);
+          await this.performUpdate();
+        } else {
+          logger10.info("Skipping major version update.");
+          logger10.info('You can update later with "rapid update --force"');
+        }
+      } catch {
+        logger10.info(
+          'Run "rapid update" to update manually, or use "rapid update --force" to update automatically.'
+        );
+      }
+      return;
+    }
+    logger10.info(`Auto-updating to ${updateInfo.latest} (${updateInfo.type} version)...`);
+    await this.performUpdate();
+  }
+  /**
+   * Force update regardless of version type
+   */
+  async forceUpdate() {
+    if (!this.hasUpdate()) {
+      logger10.info("No updates available.");
+      return;
+    }
+    const updateInfo = this.getUpdateInfo();
+    if (updateInfo) {
+      this.showNotification();
+    }
+    await this.performUpdate();
+  }
+};
+var updateChecker = new UpdateChecker();
+
+// src/commands/update.ts
+import { logger as logger11 } from "@a3t/rapid-core";
+var updateCommand = new Command10("update").description("Check for and apply updates").option("--check", "Check for updates only").option("--force", "Force update even for major versions").action(async (options) => {
+  try {
+    if (options.check) {
+      logger11.header("Checking for updates...");
+      if (!updateChecker.hasUpdate()) {
+        logger11.success("You are using the latest version!");
+        return;
+      }
+      const updateInfo2 = updateChecker.getUpdateInfo();
+      if (updateInfo2) {
+        updateChecker.showNotification();
+        if (updateInfo2.type === "major") {
+          logger11.warn("This is a major version update with breaking changes.");
+          logger11.info('Use "rapid update --force" to update.');
+        } else {
+          logger11.info('Use "rapid update" to apply the update.');
+        }
+      }
+      return;
+    }
+    if (!updateChecker.hasUpdate()) {
+      logger11.success("You are already using the latest version!");
+      return;
+    }
+    const updateInfo = updateChecker.getUpdateInfo();
+    if (updateInfo && updateInfo.type === "major" && !options.force) {
+      logger11.warn("This is a major version update with breaking changes.");
+      logger11.info("Use --force to update anyway.");
+      return;
+    }
+    await updateChecker.forceUpdate();
+  } catch (error) {
+    logger11.error("Update failed:", error);
+    process.exit(1);
+  }
+});
+
+// src/commands/worktree.ts
+import { Command as Command11 } from "commander";
+import { logger as logger12 } from "@a3t/rapid-core";
+import ora9 from "ora";
+function formatWorktree(wt, currentPath) {
+  const isCurrent = wt.path === currentPath;
+  const marker = isCurrent ? logger12.brand("*") : " ";
+  const status = [];
+  if (wt.isMain) status.push("main");
+  if (wt.locked) status.push("locked");
+  if (wt.prunable) status.push("prunable");
+  if (!wt.exists) status.push("missing");
+  const statusStr = status.length > 0 ? logger12.dim(` (${status.join(", ")})`) : "";
+  const branchStr = wt.branch ? logger12.brand(wt.branch) : logger12.dim("detached");
+  const headShort = wt.head?.substring(0, 7) ?? "";
+  return `${marker} ${branchStr}${statusStr}
+    ${logger12.dim(wt.path)}
+    ${logger12.dim(`HEAD: ${headShort}`)}`;
+}
+var listCommand = new Command11("list").alias("ls").description("List all git worktrees").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const cwd = process.cwd();
+    if (!await isGitRepo(cwd)) {
+      logger12.error("Not a git repository");
+      process.exit(1);
+    }
+    const gitRoot = await getGitRoot(cwd);
+    const worktrees = await listWorktrees(gitRoot);
+    if (options.json) {
+      console.log(JSON.stringify(worktrees, null, 2));
+      return;
+    }
+    if (worktrees.length === 0) {
+      logger12.info("No worktrees found");
+      return;
+    }
+    logger12.header("Git Worktrees");
+    console.log();
+    for (const wt of worktrees) {
+      console.log(formatWorktree(wt, gitRoot));
+      console.log();
+    }
+    const prunable = worktrees.filter((wt) => wt.prunable);
+    if (prunable.length > 0) {
+      logger12.warn(`${prunable.length} worktree(s) can be pruned. Run: rapid worktree prune`);
+    }
+  } catch (error) {
+    logger12.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+var pruneCommand = new Command11("prune").description("Remove stale worktree references").option("--dry-run", "Show what would be pruned without removing").action(async (options) => {
+  const spinner = ora9("Checking worktrees...").start();
+  try {
+    const cwd = process.cwd();
+    if (!await isGitRepo(cwd)) {
+      spinner.fail("Not a git repository");
+      process.exit(1);
+    }
+    const gitRoot = await getGitRoot(cwd);
+    const worktrees = await listWorktrees(gitRoot);
+    const prunable = worktrees.filter((wt) => wt.prunable);
+    if (prunable.length === 0) {
+      spinner.succeed("No stale worktrees to prune");
+      return;
+    }
+    if (options.dryRun) {
+      spinner.info(`Would prune ${prunable.length} worktree(s):`);
+      for (const wt of prunable) {
+        console.log(`  ${logger12.dim("\u2022")} ${wt.path}`);
+      }
+      return;
+    }
+    spinner.text = `Pruning ${prunable.length} worktree(s)...`;
+    const result = await pruneWorktrees(gitRoot);
+    if (result.success) {
+      spinner.succeed(`Pruned ${result.pruned.length} worktree(s)`);
+      for (const path of result.pruned) {
+        console.log(`  ${logger12.dim("\u2022")} ${path}`);
+      }
+    } else {
+      spinner.fail(`Failed to prune: ${result.error}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+var removeCommand = new Command11("remove").alias("rm").description("Remove a worktree").argument("<path-or-branch>", "Worktree path or branch name").option("-f, --force", "Force removal even if worktree is dirty").action(async (pathOrBranch, options) => {
+  const spinner = ora9("Finding worktree...").start();
+  try {
+    const cwd = process.cwd();
+    if (!await isGitRepo(cwd)) {
+      spinner.fail("Not a git repository");
+      process.exit(1);
+    }
+    const gitRoot = await getGitRoot(cwd);
+    const worktrees = await listWorktrees(gitRoot);
+    const worktree = worktrees.find(
+      (wt) => wt.path === pathOrBranch || wt.path.endsWith(pathOrBranch) || wt.branch === pathOrBranch
+    );
+    if (!worktree) {
+      spinner.fail(`Worktree not found: ${pathOrBranch}`);
+      logger12.info("Available worktrees:");
+      for (const wt of worktrees) {
+        console.log(`  ${wt.branch || wt.path}`);
+      }
+      process.exit(1);
+    }
+    if (worktree.isMain) {
+      spinner.fail("Cannot remove the main worktree");
+      process.exit(1);
+    }
+    if (worktree.locked && !options.force) {
+      spinner.fail("Worktree is locked. Use --force to remove anyway.");
+      process.exit(1);
+    }
+    spinner.text = `Removing worktree: ${worktree.path}...`;
+    const result = await removeWorktree(gitRoot, worktree.path, { force: options.force });
+    if (result.success) {
+      spinner.succeed(`Removed worktree: ${worktree.path}`);
+    } else {
+      spinner.fail(`Failed to remove: ${result.error}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+var cleanupCommand = new Command11("cleanup").description("Remove worktrees for branches that have been merged").option("--dry-run", "Show what would be removed without removing").action(async (options) => {
+  const spinner = ora9("Analyzing worktrees...").start();
+  try {
+    const cwd = process.cwd();
+    if (!await isGitRepo(cwd)) {
+      spinner.fail("Not a git repository");
+      process.exit(1);
+    }
+    const gitRoot = await getGitRoot(cwd);
+    if (options.dryRun) {
+      const worktrees = await listWorktrees(gitRoot);
+      spinner.info("Dry run - would remove worktrees for merged branches");
+      const nonMain = worktrees.filter((wt) => !wt.isMain && wt.branch);
+      if (nonMain.length === 0) {
+        console.log("  No feature branch worktrees found");
+      } else {
+        console.log("  Feature branch worktrees:");
+        for (const wt of nonMain) {
+          console.log(`    ${logger12.dim("\u2022")} ${wt.branch} - ${wt.path}`);
+        }
+        console.log();
+        logger12.info("Run without --dry-run to remove worktrees for merged branches");
+      }
+      return;
+    }
+    spinner.text = "Removing worktrees for merged branches...";
+    const result = await cleanupMergedWorktrees(gitRoot);
+    if (result.removed.length === 0) {
+      spinner.succeed("No worktrees to clean up");
+      return;
+    }
+    spinner.succeed(`Cleaned up ${result.removed.length} worktree(s)`);
+    for (const path of result.removed) {
+      console.log(`  ${logger12.dim("\u2022")} ${path}`);
+    }
+    if (result.errors.length > 0) {
+      console.log();
+      logger12.warn("Some worktrees could not be removed:");
+      for (const err of result.errors) {
+        console.log(`  ${logger12.dim("\u2022")} ${err}`);
+      }
+    }
+  } catch (error) {
+    spinner.fail(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+var worktreeCommand = new Command11("worktree").alias("wt").description("Manage git worktrees for isolated development").addCommand(listCommand).addCommand(pruneCommand).addCommand(removeCommand).addCommand(cleanupCommand);
+worktreeCommand.action(async () => {
+  await listCommand.parseAsync([], { from: "user" });
+});
+
+// src/commands/lima.ts
+import { Command as Command12 } from "commander";
+import { logger as logger13 } from "@a3t/rapid-core";
+import ora10 from "ora";
+async function checkLimaAvailable() {
+  if (!isMacOS()) {
+    logger13.error("Lima is only available on macOS");
+    return false;
+  }
+  if (!await hasLima()) {
+    logger13.error("Lima is not installed");
+    logger13.blank();
+    logger13.info("Install Lima with:");
+    console.log(`  ${logger13.dim("$")} brew install lima`);
+    logger13.blank();
+    logger13.info("For more information: https://lima-vm.io");
+    return false;
+  }
+  return true;
+}
+var statusCommand2 = new Command12("status").description("Show Lima VM status").option("--json", "Output as JSON").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const instance = await getInstance();
+  if (options.json) {
+    console.log(JSON.stringify(instance, null, 2));
+    return;
+  }
+  if (!instance) {
+    logger13.info(`Lima VM (${RAPID_LIMA_INSTANCE}) is not created`);
+    logger13.blank();
+    logger13.info("Start the VM with:");
+    console.log(`  ${logger13.dim("$")} rapid lima start`);
+    logger13.blank();
+    logger13.info("Or use:");
+    console.log(`  ${logger13.dim("$")} rapid dev --local`);
+    return;
+  }
+  logger13.header("Lima VM Status");
+  console.log();
+  console.log(`  ${logger13.dim("Name:")}     ${instance.name}`);
+  console.log(
+    `  ${logger13.dim("Status:")}   ${instance.status === "Running" ? logger13.brand(instance.status) : instance.status}`
+  );
+  console.log(`  ${logger13.dim("Arch:")}     ${instance.arch}`);
+  console.log(`  ${logger13.dim("CPUs:")}     ${instance.cpus}`);
+  console.log(`  ${logger13.dim("Memory:")}   ${instance.memory}`);
+  console.log(`  ${logger13.dim("Disk:")}     ${instance.disk}`);
+  if (instance.sshLocalPort) {
+    console.log(`  ${logger13.dim("SSH Port:")} ${instance.sshLocalPort}`);
+  }
+  console.log();
+  if (instance.status === "Running") {
+    logger13.info("To open a shell:");
+    console.log(`  ${logger13.dim("$")} rapid lima shell`);
+  } else {
+    logger13.info("To start the VM:");
+    console.log(`  ${logger13.dim("$")} rapid lima start`);
+  }
+  console.log();
+});
+var startCommand2 = new Command12("start").description("Start the Lima VM").option("--cpus <n>", "Number of CPUs", "4").option("--memory <size>", "Memory size", "8GiB").option("--disk <size>", "Disk size", "50GiB").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const spinner = ora10("Starting Lima VM...").start();
+  const projectDir = process.cwd();
+  const result = await startInstance(projectDir, {
+    cpus: parseInt(options.cpus, 10),
+    memory: options.memory,
+    disk: options.disk,
+    timeout: 600
+  });
+  if (!result.success) {
+    spinner.fail("Failed to start Lima VM");
+    logger13.error(result.error ?? "Unknown error");
+    process.exit(1);
+  }
+  spinner.succeed("Lima VM started");
+  logger13.blank();
+  const sshSpinner = ora10("Checking SSH agent forwarding...").start();
+  const sshResult = await setupGitSsh();
+  if (sshResult.success) {
+    sshSpinner.succeed("SSH agent forwarding is working");
+  } else {
+    sshSpinner.warn("SSH agent forwarding may not be working");
+    logger13.dim(sshResult.error ?? "Make sure ssh-agent is running on the host");
+  }
+  logger13.blank();
+  logger13.info("To open a shell:");
+  console.log(`  ${logger13.dim("$")} rapid lima shell`);
+  console.log();
+});
+var stopCommand2 = new Command12("stop").description("Stop the Lima VM").option("-f, --force", "Force stop").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const instance = await getInstance();
+  if (!instance) {
+    logger13.info("Lima VM is not created");
+    return;
+  }
+  if (instance.status !== "Running") {
+    logger13.info("Lima VM is already stopped");
+    return;
+  }
+  const spinner = ora10("Stopping Lima VM...").start();
+  const result = await stopInstance(RAPID_LIMA_INSTANCE, {
+    force: options.force
+  });
+  if (!result.success) {
+    spinner.fail("Failed to stop Lima VM");
+    logger13.error(result.error ?? "Unknown error");
+    process.exit(1);
+  }
+  spinner.succeed("Lima VM stopped");
+});
+var shellCommand = new Command12("shell").description("Open a shell in the Lima VM").option("-c, --command <cmd>", "Command to run instead of interactive shell").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const instance = await getInstance();
+  if (!instance || instance.status !== "Running") {
+    logger13.error("Lima VM is not running");
+    logger13.info("Start with: rapid lima start");
+    process.exit(1);
+  }
+  await shellInLima({
+    cwd: process.cwd(),
+    command: options.command
+  });
+});
+var deleteCommand = new Command12("delete").description("Delete the Lima VM").option("-f, --force", "Force delete without confirmation").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const instance = await getInstance();
+  if (!instance) {
+    logger13.info("Lima VM does not exist");
+    return;
+  }
+  if (!options.force) {
+    logger13.warn("This will permanently delete the Lima VM and all its data.");
+    logger13.info(`Use ${logger13.brand("--force")} to confirm deletion.`);
+    return;
+  }
+  const spinner = ora10("Deleting Lima VM...").start();
+  const result = await deleteInstance(RAPID_LIMA_INSTANCE, { force: true });
+  if (!result.success) {
+    spinner.fail("Failed to delete Lima VM");
+    logger13.error(result.error ?? "Unknown error");
+    process.exit(1);
+  }
+  spinner.succeed("Lima VM deleted");
+});
+var listCommand2 = new Command12("list").alias("ls").description("List all Lima instances").option("--json", "Output as JSON").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const instances = await listInstances();
+  if (options.json) {
+    console.log(JSON.stringify(instances, null, 2));
+    return;
+  }
+  if (instances.length === 0) {
+    logger13.info("No Lima instances found");
+    return;
+  }
+  logger13.header("Lima Instances");
+  console.log();
+  for (const inst of instances) {
+    const isRapid = inst.name === RAPID_LIMA_INSTANCE;
+    const statusColor = inst.status === "Running" ? logger13.brand : logger13.dim;
+    console.log(
+      `  ${isRapid ? logger13.brand("*") : " "} ${inst.name} ${statusColor(`(${inst.status})`)}`
+    );
+    console.log(`    ${logger13.dim(`${inst.cpus} CPUs, ${inst.memory}, ${inst.disk}`)}`);
+  }
+  console.log();
+});
+var limaCommand = new Command12("lima").description("Manage Lima VM for local development (macOS)").addCommand(statusCommand2).addCommand(startCommand2).addCommand(stopCommand2).addCommand(shellCommand).addCommand(deleteCommand).addCommand(listCommand2);
+limaCommand.action(async () => {
+  await statusCommand2.parseAsync([], { from: "user" });
+});
+
+// src/index.ts
+var __dirname2 = dirname4(fileURLToPath3(import.meta.url));
+var packageJson2 = JSON.parse(readFileSync2(join7(__dirname2, "../package.json"), "utf-8"));
+var VERSION = packageJson2.version;
+var program = new Command13();
+program.name("rapid").description("AI-assisted development with dev containers").version(VERSION, "-v, --version", "Show version").option("--verbose", "Verbose output").option("-q, --quiet", "Minimal output").option("--config <path>", "Path to rapid.json").hook("preAction", async (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.verbose) {
+    setLogLevel("debug");
+  } else if (opts.quiet) {
+    setLogLevel("error");
+  }
+  if (thisCommand.name() === "update" || thisCommand.name() === "version") {
+    return;
+  }
+  try {
+    await updateChecker.checkAndUpdate();
+  } catch (error) {
+    logger14.debug("Update check failed:", error);
+  }
+});
+program.addCommand(initCommand);
+program.addCommand(startCommand);
+program.addCommand(devCommand);
+program.addCommand(stopCommand);
+program.addCommand(statusCommand);
+program.addCommand(agentCommand);
+program.addCommand(secretsCommand);
+program.addCommand(authCommand);
+program.addCommand(mcpCommand);
+program.addCommand(updateCommand);
+program.addCommand(worktreeCommand);
+program.addCommand(limaCommand);
+program.action(() => {
+  console.log();
+  console.log(`  ${logger14.brand("RAPID")} ${logger14.dim(`v${VERSION}`)}`);
+  console.log(`  ${logger14.dim("AI-assisted development with dev containers")}`);
+  console.log();
+  program.help();
+});
+
+export {
+  program
+};
+//# sourceMappingURL=chunk-VWXN2TG5.js.map