@supercheck/cli 0.1.0-beta.9 → 0.1.1-beta.1

package/dist/bin/supercheck.js

@@ -4,8 +4,8 @@ import {
 } from "../chunk-W54DX2I7.js";
 
 // src/bin/supercheck.ts
-import { Command as Command18 } from "commander";
-import pc7 from "picocolors";
+import { Command as Command21 } from "commander";
+import pc10 from "picocolors";
 
 // src/commands/login.ts
 import { Command } from "commander";
@@ -193,6 +193,9 @@ function getStoredOrganization() {
 function getStoredProject() {
   return process.env.SUPERCHECK_PROJECT ?? store.get("project") ?? null;
 }
+function isAuthenticated() {
+  return getToken() !== null;
+}
 function requireAuth() {
   const token = getToken();
   if (!token) {
@@ -213,14 +216,10 @@ function requireTriggerKey() {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "0.1.0-beta.9" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.1.1-beta.1" : "0.0.0-dev";
 
-// src/api/client.ts
+// src/utils/proxy.ts
 import { ProxyAgent } from "undici";
-var DEFAULT_BASE_URL = "https://app.supercheck.io";
-var DEFAULT_TIMEOUT_MS = 3e4;
-var MAX_RETRIES = 3;
-var RETRY_BACKOFF_MS = 1e3;
 var proxyAgents = /* @__PURE__ */ new Map();
 function getProxyAgent(proxyUrl) {
   const existing = proxyAgents.get(proxyUrl);
@@ -229,6 +228,45 @@ function getProxyAgent(proxyUrl) {
   proxyAgents.set(proxyUrl, created);
   return created;
 }
+function isNoProxyMatch(url, noProxyRaw) {
+  const hostname = url.hostname;
+  const port = url.port || (url.protocol === "https:" ? "443" : "80");
+  const entries = noProxyRaw.split(",").map((entry) => entry.trim()).filter(Boolean);
+  if (entries.includes("*")) return true;
+  for (const entry of entries) {
+    const [hostPart, portPart] = entry.split(":");
+    const host = hostPart.trim();
+    const entryPort = portPart?.trim();
+    if (!host) continue;
+    if (entryPort && entryPort !== port) continue;
+    if (host.startsWith(".")) {
+      if (hostname.endsWith(host)) return true;
+      continue;
+    }
+    if (hostname === host) return true;
+    if (hostname.endsWith(`.${host}`)) return true;
+  }
+  return false;
+}
+function getProxyEnv(url) {
+  const noProxyRaw = process.env.NO_PROXY ?? process.env.no_proxy;
+  if (noProxyRaw && isNoProxyMatch(url, noProxyRaw)) {
+    return null;
+  }
+  if (url.protocol === "https:") {
+    return process.env.HTTPS_PROXY ?? process.env.https_proxy ?? process.env.HTTP_PROXY ?? process.env.http_proxy ?? null;
+  }
+  if (url.protocol === "http:") {
+    return process.env.HTTP_PROXY ?? process.env.http_proxy ?? null;
+  }
+  return null;
+}
+
+// src/api/client.ts
+var DEFAULT_BASE_URL = "https://app.supercheck.io";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_RETRIES = 3;
+var RETRY_BACKOFF_MS = 1e3;
 var ApiClient = class {
   baseUrl;
   token;
@@ -410,7 +448,7 @@ var ApiClient = class {
     return this.request("DELETE", path);
   }
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve10) => setTimeout(resolve10, ms));
   }
 };
 var defaultClient = null;
@@ -430,9 +468,9 @@ function getApiClient(options) {
 import { readdirSync, statSync, readFileSync } from "fs";
 import { resolve, relative, basename } from "path";
 function matchGlob(filePath, pattern) {
-  const withPlaceholders = pattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "{{STAR}}");
+  const withPlaceholders = pattern.replace(/\/\*\*\//g, "__GLOBSTAR_SLASH__").replace(/\*\*/g, "__GLOBSTAR__").replace(/\*/g, "__STAR__").replace(/\?/g, "__QMARK__");
   const escaped = withPlaceholders.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-  const regexStr = escaped.replace(/\{\{GLOBSTAR\}\}/g, ".*").replace(/\{\{STAR\}\}/g, "[^/]*");
+  const regexStr = escaped.replace(/__GLOBSTAR_SLASH__/g, "(?:/|/.+/)").replace(/__GLOBSTAR__/g, ".*").replace(/__STAR__/g, "[^/]*").replace(/__QMARK__/g, ".");
   return new RegExp(`^${regexStr}$`).test(filePath);
 }
 var SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -526,8 +564,29 @@ function readFileContent(filePath) {
   }
 }
 
+// src/utils/slug.ts
+function slugify(text) {
+  return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50) || "test";
+}
+function testFilename(testId, title, testType) {
+  const ext = testType === "k6" ? ".k6.ts" : ".pw.ts";
+  const slug = slugify(title);
+  return `${slug}.${testId}${ext}`;
+}
+var UUID_EXTRACT_REGEX = /(?:^|\.)([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
+function extractUuidFromFilename(filename) {
+  const base = filename.split(/[/\\]/).pop() ?? filename;
+  const stem = base.replace(/\.(pw|k6)\.ts$/, "");
+  const match = UUID_EXTRACT_REGEX.exec(stem);
+  return match ? match[1] : void 0;
+}
+function stripTitleMetadata(script) {
+  let result = script.replace(/^\/\/\s*@title\s+[^\n]+\n\n?/, "");
+  result = result.replace(/\n\s*\*\s*@title\s+[^\n]+/, "");
+  return result;
+}
+
 // src/utils/resources.ts
-var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function buildLocalResources(config, cwd) {
   const resources = [];
   if (config.jobs) {
@@ -536,7 +595,10 @@ function buildLocalResources(config, cwd) {
         id: job.id,
         type: "job",
         name: job.name,
-        definition: { ...job }
+        definition: {
+          ...job,
+          tests: normalizeJobTestsToIds(job.tests)
+        }
       });
     }
   }
@@ -596,20 +658,24 @@ function buildLocalResources(config, cwd) {
   for (const file of files) {
     const script = readFileContent(file.absolutePath);
     if (script) {
-      const stem = file.filename.replace(/\.(pw|k6)\.ts$/, "");
-      const testId = UUID_REGEX.test(stem) ? stem : void 0;
+      const testId = extractUuidFromFilename(file.filename);
       if (!testId) {
         logger.debug(`Test file "${file.filename}" does not have a UUID-based filename \u2014 will be treated as a new resource`);
       }
+      const titleMatch = script.match(/@title\s+(.+)$/m);
+      const stem = file.filename.replace(/\.(pw|k6)\.ts$/, "");
+      const title = titleMatch ? titleMatch[1].trim() : stem;
+      const cleanScript = stripTitleMetadata(script);
+      const displayName = file.relativePath.replace(/^_supercheck_\//, "");
       resources.push({
         id: testId,
         type: "test",
-        name: file.filename,
+        name: displayName,
         definition: {
           id: testId,
-          title: stem,
+          title,
           testType: file.type === "playwright" ? "playwright" : "k6",
-          script
+          script: cleanScript
         }
       });
     }
@@ -699,13 +765,20 @@ function normalizeRemoteRaw(type, raw) {
       if (!normalized.alertConfig) delete normalized.alertConfig;
     }
   }
+  if (type === "test") {
+    if (normalized.type === "browser") normalized.testType = "playwright";
+    else if (normalized.type === "performance") normalized.testType = "k6";
+    delete normalized.type;
+    if (typeof normalized.script === "string") {
+      normalized.script = stripTitleMetadata(normalized.script);
+    }
+  }
   if (type === "job") {
     if (Array.isArray(normalized.tests)) {
       normalized.tests = normalized.tests.map((t) => {
-        if (typeof t === "string") return t;
+        if (typeof t === "string") return extractUuidFromFilename(t) ?? t;
         if (t && typeof t === "object" && t.id) {
-          const testType = t.type === "performance" || t.type === "k6" ? "k6" : "pw";
-          return `_supercheck_/tests/${t.id}.${testType}.ts`;
+          return String(t.id);
         }
         return t;
       });
@@ -730,6 +803,13 @@ function normalizeRemoteRaw(type, raw) {
   }
   return normalized;
 }
+function normalizeJobTestsToIds(tests) {
+  if (!tests) return tests;
+  return tests.map((t) => {
+    const id = extractUuidFromFilename(t);
+    return id ?? t;
+  });
+}
 async function fetchRemoteResources(client) {
   const resources = [];
   try {
@@ -746,7 +826,7 @@ async function fetchRemoteResources(client) {
     logFetchError("jobs", err);
   }
   try {
-    const tests = await fetchAllPages(client, "/api/tests", "tests");
+    const tests = await fetchAllPages(client, "/api/tests?includeScript=true", "tests");
     for (const test of tests) {
       const id = safeId(test.id);
       if (!id) {
@@ -1194,11 +1274,11 @@ var alertConfigSchema = z.object({
   customMessage: z.string().optional()
 }).passthrough();
 var playwrightTestConfigSchema = z.object({
-  testMatch: z.string().default("_supercheck_/tests/**/*.pw.ts"),
+  testMatch: z.string().default("_supercheck_/playwright/**/*.pw.ts"),
   browser: z.enum(["chromium", "firefox", "webkit"]).default("chromium")
 });
 var k6TestConfigSchema = z.object({
-  testMatch: z.string().default("_supercheck_/tests/**/*.k6.ts")
+  testMatch: z.string().default("_supercheck_/k6/**/*.k6.ts")
 });
 var testsConfigSchema = z.object({
   playwright: playwrightTestConfigSchema.optional(),
@@ -1372,6 +1452,8 @@ function validateNoSecrets(config) {
 }
 async function loadConfig(options = {}) {
   const cwd = options.cwd ?? process.cwd();
+  const { config: loadEnv } = await import("dotenv");
+  loadEnv({ path: resolve2(cwd, ".env") });
   const configPath = resolveConfigPath(cwd, options.configPath);
   if (!configPath) {
     throw new CLIError(
@@ -1481,21 +1563,21 @@ var locationsCommand = new Command2("locations").description("List available exe
 // src/commands/config.ts
 import { Command as Command3 } from "commander";
 var configCommand = new Command3("config").description("Configuration management");
-configCommand.command("validate").description("Validate supercheck.config.ts").action(async () => {
-  const { config, configPath } = await loadConfig();
+configCommand.command("validate").description("Validate supercheck.config.ts").option("--config <path>", "Path to config file").action(async (options) => {
+  const { config, configPath } = await loadConfig({ configPath: options.config });
   logger.success(`Valid configuration loaded from ${configPath}`);
   logger.info(`  Organization: ${config.project.organization}`);
   logger.info(`  Project:      ${config.project.project}`);
 });
-configCommand.command("print").description("Print the resolved configuration").action(async () => {
-  const { config } = await loadConfig();
+configCommand.command("print").description("Print the resolved configuration").option("--config <path>", "Path to config file").action(async (options) => {
+  const { config } = await loadConfig({ configPath: options.config });
   output(config);
 });
 
 // src/commands/init.ts
 import { Command as Command4 } from "commander";
-import { existsSync as existsSync3, mkdirSync, writeFileSync as writeFileSync2, readFileSync as readFileSync2, appendFileSync } from "fs";
-import { resolve as resolve4 } from "path";
+import { existsSync as existsSync4, mkdirSync, writeFileSync as writeFileSync2, readFileSync as readFileSync2, appendFileSync } from "fs";
+import { resolve as resolve5 } from "path";
 
 // src/utils/package-manager.ts
 import { existsSync as existsSync2, writeFileSync } from "fs";
@@ -1549,9 +1631,9 @@ async function installDependencies(cwd, pm, opts = {}) {
   await withSpinner(
     `Installing ${devDeps.length} packages...`,
     async () => {
-      const { execSync } = await import("child_process");
+      const { execSync: execSync2 } = await import("child_process");
       try {
-        execSync(cmd, {
+        execSync2(cmd, {
           cwd,
           stdio: "pipe",
           timeout: 12e4,
@@ -1573,6 +1655,200 @@ Error: ${message}`,
   );
 }
 
+// src/utils/deps.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve4 } from "path";
+import pc3 from "picocolors";
+function isCommandAvailable(command) {
+  try {
+    const output2 = execSync(`${command} --version`, {
+      stdio: "pipe",
+      timeout: 1e4,
+      env: { ...process.env }
+    }).toString().trim();
+    const version = output2.split("\n")[0].trim();
+    return { available: true, version };
+  } catch {
+    return { available: false };
+  }
+}
+function isPlaywrightPackageInstalled(cwd) {
+  try {
+    const pkgPath = resolve4(cwd, "node_modules", "@playwright", "test", "package.json");
+    return existsSync3(pkgPath);
+  } catch {
+    return false;
+  }
+}
+function isK6Installed() {
+  const result = isCommandAvailable("k6");
+  return { installed: result.available, version: result.version };
+}
+function isNodeInstalled() {
+  return { installed: true, version: process.version };
+}
+async function installPlaywrightBrowsers(cwd, browser = "chromium") {
+  try {
+    logger.info(`Installing Playwright ${browser} browser...`);
+    execSync(`npx playwright install ${browser}`, {
+      cwd,
+      stdio: "inherit",
+      timeout: 3e5,
+      // 5 min timeout for browser download
+      env: { ...process.env }
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkAllDependencies(cwd) {
+  const deps = [];
+  const node = isNodeInstalled();
+  deps.push({
+    name: "Node.js",
+    installed: node.installed,
+    version: node.version,
+    required: true,
+    installHint: "https://nodejs.org/"
+  });
+  const pwPkg = isPlaywrightPackageInstalled(cwd);
+  deps.push({
+    name: "@playwright/test",
+    installed: pwPkg,
+    detail: pwPkg ? "npm package found" : "npm package not found",
+    required: true,
+    installHint: "npm install --save-dev @playwright/test"
+  });
+  if (pwPkg) {
+    const pwCheck = isCommandAvailable("npx playwright --version");
+    deps.push({
+      name: "Playwright browsers",
+      installed: pwCheck.available,
+      version: pwCheck.version,
+      detail: pwCheck.available ? "browsers available" : "run: npx playwright install chromium",
+      required: true,
+      installHint: "npx playwright install chromium"
+    });
+  } else {
+    deps.push({
+      name: "Playwright browsers",
+      installed: false,
+      detail: "install @playwright/test first",
+      required: true,
+      installHint: "npm install --save-dev @playwright/test && npx playwright install chromium"
+    });
+  }
+  const k6 = isK6Installed();
+  deps.push({
+    name: "k6",
+    installed: k6.installed,
+    version: k6.version,
+    detail: k6.installed ? void 0 : "needed for performance tests",
+    required: false,
+    installHint: getK6InstallHint()
+  });
+  return deps;
+}
+function getK6InstallHint() {
+  const platform = process.platform;
+  switch (platform) {
+    case "darwin":
+      return "brew install k6";
+    case "linux":
+      return "sudo snap install k6 or see https://grafana.com/docs/k6/latest/set-up/install-k6/";
+    case "win32":
+      return "choco install k6 or winget install k6";
+    default:
+      return "https://grafana.com/docs/k6/latest/set-up/install-k6/";
+  }
+}
+function formatDependencyReport(deps) {
+  const lines = [];
+  let allGood = true;
+  for (const dep of deps) {
+    const icon = dep.installed ? pc3.green("\u2713") : dep.required ? pc3.red("\u2717") : pc3.yellow("\u25CB");
+    const name = dep.installed ? dep.name : pc3.dim(dep.name);
+    const version = dep.version ? pc3.dim(` (${dep.version})`) : "";
+    const detail = dep.detail && !dep.installed ? pc3.dim(` \u2014 ${dep.detail}`) : "";
+    lines.push(`  ${icon} ${name}${version}${detail}`);
+    if (!dep.installed && dep.required) {
+      allGood = false;
+      lines.push(`    ${pc3.dim("Install:")} ${dep.installHint}`);
+    } else if (!dep.installed && !dep.required) {
+      lines.push(`    ${pc3.dim("Install (optional):")} ${dep.installHint}`);
+    }
+  }
+  if (allGood) {
+    lines.push("");
+    lines.push(pc3.green("  All required dependencies are installed!"));
+  }
+  return lines.join("\n");
+}
+function ensureDependenciesForTestType(cwd, testType) {
+  if (testType === "playwright") {
+    if (!isPlaywrightPackageInstalled(cwd)) {
+      throw new DependencyError(
+        "playwright",
+        "@playwright/test is not installed.\n  Install it with: npm install --save-dev @playwright/test\n  Then install browsers: npx playwright install chromium"
+      );
+    }
+  }
+  if (testType === "k6") {
+    const k6 = isK6Installed();
+    if (!k6.installed) {
+      throw new DependencyError(
+        "k6",
+        `k6 is not installed.
+  Install it with: ${getK6InstallHint()}
+  Documentation: https://grafana.com/docs/k6/latest/set-up/install-k6/`
+      );
+    }
+  }
+}
+var DependencyError = class extends Error {
+  dependency;
+  constructor(dependency, message) {
+    super(message);
+    this.name = "DependencyError";
+    this.dependency = dependency;
+  }
+};
+
+// src/utils/uuid.ts
+import { randomBytes } from "crypto";
+function uuidv7() {
+  const now = Date.now();
+  const timestampBytes = new Uint8Array(6);
+  let ts = now;
+  for (let i = 5; i >= 0; i--) {
+    timestampBytes[i] = ts & 255;
+    ts = Math.floor(ts / 256);
+  }
+  const randBytes = randomBytes(10);
+  const bytes = new Uint8Array(16);
+  bytes.set(timestampBytes, 0);
+  bytes[6] = 112 | randBytes[0] & 15;
+  bytes[7] = randBytes[1];
+  bytes[8] = 128 | randBytes[2] & 63;
+  bytes[9] = randBytes[3];
+  bytes[10] = randBytes[4];
+  bytes[11] = randBytes[5];
+  bytes[12] = randBytes[6];
+  bytes[13] = randBytes[7];
+  bytes[14] = randBytes[8];
+  bytes[15] = randBytes[9];
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32)
+  ].join("-");
+}
+
 // src/commands/init.ts
 var CONFIG_TEMPLATE = `import { defineConfig } from '@supercheck/cli'
 
@@ -1587,23 +1863,27 @@ export default defineConfig({
   },
   tests: {
     playwright: {
-      testMatch: '_supercheck_/tests/**/*.pw.ts',
+      testMatch: '_supercheck_/playwright/**/*.pw.ts',
       browser: 'chromium',
     },
     k6: {
-      testMatch: '_supercheck_/tests/**/*.k6.ts',
+      testMatch: '_supercheck_/k6/**/*.k6.ts',
     },
   },
 })
 `;
-var EXAMPLE_PW_TEST = `import { test, expect } from '@playwright/test'
+var EXAMPLE_PW_TEST = `// @title Homepage Check
+
+import { test, expect } from '@playwright/test'
 
 test('homepage loads successfully', async ({ page }) => {
   await page.goto('https://example.com')
   await expect(page).toHaveTitle(/Example/)
 })
 `;
-var EXAMPLE_K6_TEST = `import http from 'k6/http'
+var EXAMPLE_K6_TEST = `// @title Load Test
+
+import http from 'k6/http'
 import { check, sleep } from 'k6'
 
 export const options = {
@@ -1631,7 +1911,7 @@ var SUPERCHECK_TSCONFIG = `{
     "resolveJsonModule": true,
     "isolatedModules": true,
     "noEmit": true,
-    "types": ["node"]
+    "types": ["node", "k6"]
   },
   "include": [
     "supercheck.config.ts",
@@ -1648,8 +1928,8 @@ supercheck.config.local.mjs
 `;
 var initCommand = new Command4("init").description("Initialize a new Supercheck project with config and example tests").option("--force", "Overwrite existing config file").option("--skip-install", "Skip automatic dependency installation").option("--skip-examples", "Skip creating example test files").option("--pm <manager>", "Package manager to use (npm, yarn, pnpm, bun)").action(async (options) => {
   const cwd = process.cwd();
-  const configPath = resolve4(cwd, "supercheck.config.ts");
-  if (existsSync3(configPath) && !options.force) {
+  const configPath = resolve5(cwd, "supercheck.config.ts");
+  if (existsSync4(configPath) && !options.force) {
     throw new CLIError(
       "supercheck.config.ts already exists. Use --force to overwrite.",
       3 /* ConfigError */
@@ -1660,43 +1940,42 @@ var initCommand = new Command4("init").description("Initialize a new Supercheck
   logger.newline();
   writeFileSync2(configPath, CONFIG_TEMPLATE, "utf-8");
   logger.success("Created supercheck.config.ts");
-  const tsconfigPath = resolve4(cwd, "tsconfig.supercheck.json");
-  if (!existsSync3(tsconfigPath) || options.force) {
+  const tsconfigPath = resolve5(cwd, "tsconfig.supercheck.json");
+  if (!existsSync4(tsconfigPath) || options.force) {
     writeFileSync2(tsconfigPath, SUPERCHECK_TSCONFIG, "utf-8");
     logger.success("Created tsconfig.supercheck.json (IDE IntelliSense)");
   }
-  const dirs = [
-    "_supercheck_/tests",
-    "_supercheck_/monitors",
-    "_supercheck_/status-pages"
-  ];
-  for (const dir of dirs) {
-    const dirPath = resolve4(cwd, dir);
-    if (!existsSync3(dirPath)) {
-      mkdirSync(dirPath, { recursive: true });
-    }
-    if (dir !== "_supercheck_/tests") {
-      const gitkeepPath = resolve4(dirPath, ".gitkeep");
-      if (!existsSync3(gitkeepPath)) {
-        writeFileSync2(gitkeepPath, "", "utf-8");
-      }
+  const supercheckDir = resolve5(cwd, "_supercheck_");
+  const playwrightDir = resolve5(supercheckDir, "playwright");
+  const k6Dir = resolve5(supercheckDir, "k6");
+  for (const dir of [supercheckDir, playwrightDir, k6Dir]) {
+    if (!existsSync4(dir)) {
+      mkdirSync(dir, { recursive: true });
     }
   }
   logger.success("Created _supercheck_/ directory structure");
   if (!options.skipExamples) {
-    const pwTestPath = resolve4(cwd, "_supercheck_/tests/homepage.pw.ts");
-    if (!existsSync3(pwTestPath)) {
+    const pwTitle = "Homepage Check";
+    const pwId = uuidv7();
+    const pwSlug = slugify(pwTitle);
+    const pwFilename = `${pwSlug}.${pwId}.pw.ts`;
+    const pwTestPath = resolve5(cwd, `_supercheck_/playwright/${pwFilename}`);
+    if (!existsSync4(pwTestPath)) {
       writeFileSync2(pwTestPath, EXAMPLE_PW_TEST, "utf-8");
-      logger.success("Created _supercheck_/tests/homepage.pw.ts (Playwright example)");
-    }
-    const k6TestPath = resolve4(cwd, "_supercheck_/tests/load-test.k6.ts");
-    if (!existsSync3(k6TestPath)) {
+      logger.success(`Created _supercheck_/playwright/${pwFilename} (Playwright example)`);
+    }
+    const k6Title = "Load Test";
+    const k6Id = uuidv7();
+    const k6Slug = slugify(k6Title);
+    const k6Filename = `${k6Slug}.${k6Id}.k6.ts`;
+    const k6TestPath = resolve5(cwd, `_supercheck_/k6/${k6Filename}`);
+    if (!existsSync4(k6TestPath)) {
       writeFileSync2(k6TestPath, EXAMPLE_K6_TEST, "utf-8");
-      logger.success("Created _supercheck_/tests/load-test.k6.ts (k6 example)");
+      logger.success(`Created _supercheck_/k6/${k6Filename} (k6 example)`);
     }
   }
-  const gitignorePath = resolve4(cwd, ".gitignore");
-  if (existsSync3(gitignorePath)) {
+  const gitignorePath = resolve5(cwd, ".gitignore");
+  if (existsSync4(gitignorePath)) {
     const content = readFileSync2(gitignorePath, "utf-8");
     if (!content.includes("supercheck.config.local")) {
       appendFileSync(gitignorePath, GITIGNORE_ADDITIONS, "utf-8");
@@ -1710,16 +1989,33 @@ var initCommand = new Command4("init").description("Initialize a new Supercheck
     logger.success("Created package.json");
   }
   await installDependencies(cwd, pm, {
-    packages: options.skipExamples ? ["@supercheck/cli", "typescript", "@types/node"] : ["@supercheck/cli", "typescript", "@types/node", "@playwright/test"],
+    packages: options.skipExamples ? ["@supercheck/cli", "typescript", "@types/node", "@types/k6"] : ["@supercheck/cli", "typescript", "@types/node", "@playwright/test", "@types/k6"],
     skipInstall: options.skipInstall ?? false
   });
+  if (!options.skipInstall && !options.skipExamples) {
+    logger.newline();
+    const browserInstalled = await installPlaywrightBrowsers(cwd, "chromium");
+    if (browserInstalled) {
+      logger.success("Playwright chromium browser installed");
+    } else {
+      logger.warn("Could not install Playwright browsers automatically.");
+      logger.info("  Run manually: npx playwright install chromium");
+    }
+  }
+  const k6Status = isK6Installed();
   logger.newline();
   logger.header("Supercheck project initialized!");
   logger.newline();
+  if (!k6Status.installed) {
+    logger.warn("k6 is not installed (needed for performance/load tests)");
+    logger.info(`  Install: ${getK6InstallHint()}`);
+    logger.info("  Docs: https://grafana.com/docs/k6/latest/set-up/install-k6/");
+    logger.newline();
+  }
   logger.info("Next steps:");
   logger.info("  1. Edit supercheck.config.ts with your org/project details");
   logger.info("  2. Run `supercheck login --token <your-token>` to authenticate");
-  logger.info("  3. Write tests in _supercheck_/tests/ (*.pw.ts for Playwright, *.k6.ts for k6)");
+  logger.info("  3. Write tests in _supercheck_/playwright and _supercheck_/k6");
   logger.info("  4. Run `supercheck diff` to preview changes against the cloud");
   logger.info("  5. Run `supercheck deploy` to push to Supercheck");
   logger.info("  6. Run `supercheck pull` to sync cloud resources locally");
@@ -1734,6 +2030,8 @@ var initCommand = new Command4("init").description("Initialize a new Supercheck
 
 // src/commands/jobs.ts
 import { Command as Command5 } from "commander";
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve6 } from "path";
 
 // src/api/authenticated-client.ts
 function createAuthenticatedClient() {
@@ -1742,7 +2040,7 @@ function createAuthenticatedClient() {
   return getApiClient({ token, baseUrl: baseUrl ?? void 0 });
 }
 
-// src/utils/validation.ts
+// src/utils/number.ts
 function parseIntStrict(value, name, opts) {
   const parsed = parseInt(value, 10);
   if (!Number.isFinite(parsed)) {
@@ -1766,8 +2064,188 @@ function parseIntStrict(value, name, opts) {
   return parsed;
 }
 
+// src/utils/validation.ts
+function normalizeTestTypeForApi(localType) {
+  if (typeof localType !== "string") return void 0;
+  const normalized = localType.trim().toLowerCase();
+  if (normalized === "playwright") return "browser";
+  if (normalized === "k6") return "performance";
+  if (normalized === "load") return "performance";
+  if (normalized === "browser" || normalized === "performance" || normalized === "api" || normalized === "database" || normalized === "custom") {
+    return normalized;
+  }
+  return void 0;
+}
+function formatValidationError(responseBody) {
+  if (responseBody && typeof responseBody === "object") {
+    const body = responseBody;
+    if (typeof body.error === "string") {
+      const line = typeof body.line === "number" ? body.line : void 0;
+      const column = typeof body.column === "number" ? body.column : void 0;
+      if (line !== void 0 && column !== void 0) {
+        return `${body.error} (line ${line}, column ${column})`;
+      }
+      return body.error;
+    }
+  }
+  return "Validation failed";
+}
+async function validateScripts(client, inputs) {
+  const results = [];
+  for (const input of inputs) {
+    if (!input.script || input.script.trim().length === 0) {
+      throw new CLIError(`Test "${input.name}" has no script content`, 3 /* ConfigError */);
+    }
+    try {
+      const { data } = await client.post(
+        "/api/validate-script",
+        {
+          script: input.script,
+          testType: input.testType
+        }
+      );
+      results.push({
+        name: input.name,
+        valid: data?.valid ?? true,
+        warnings: data?.warnings
+      });
+    } catch (err) {
+      if (err instanceof ApiRequestError) {
+        results.push({
+          name: input.name,
+          valid: false,
+          error: formatValidationError(err.responseBody)
+        });
+        continue;
+      }
+      throw err;
+    }
+  }
+  return results;
+}
+
+// src/utils/exec.ts
+import { spawn } from "child_process";
+function runCommand(command, args, cwd) {
+  return new Promise((resolve10, reject) => {
+    const child = spawn(command, args, {
+      stdio: "inherit",
+      shell: true,
+      cwd
+    });
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => resolve10(code ?? 0));
+  });
+}
+
+// src/utils/playwright.ts
+import { mkdtempSync, writeFileSync as writeFileSync3, rmSync } from "fs";
+import { join } from "path";
+function createTempPlaywrightConfig(cwd, testMatch) {
+  const dir = mkdtempSync(join(cwd, ".supercheck-playwright-"));
+  const filePath = join(dir, "playwright.supercheck.config.mjs");
+  const match = testMatch ?? "_supercheck_/playwright/**/*.pw.ts";
+  const contents = [
+    "import { defineConfig } from '@playwright/test'",
+    "",
+    "export default defineConfig({",
+    `  testDir: ${JSON.stringify(cwd)},`,
+    `  testMatch: ${JSON.stringify([match])},`,
+    "})",
+    ""
+  ].join("\n");
+  writeFileSync3(filePath, contents, "utf-8");
+  return {
+    path: filePath,
+    cleanup: () => {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  };
+}
+
 // src/commands/jobs.ts
 var jobCommand = new Command5("job").description("Manage jobs");
+function inferLocalTestType(filePath) {
+  return filePath.endsWith(".k6.ts") || filePath.endsWith(".k6.js") ? "k6" : "playwright";
+}
+function toDisplayName(cwd, filePath) {
+  const normalized = filePath.replace(cwd, "").replace(/^\//, "");
+  return normalized.startsWith("_supercheck_/") ? normalized.replace(/^_supercheck_\//, "") : normalized;
+}
+function resolveJobLocalTests(cwd, tests, patterns) {
+  const files = discoverFiles(cwd, patterns);
+  const uuidMap = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const uuid = extractUuidFromFilename(file.absolutePath);
+    if (uuid) uuidMap.set(uuid, file.absolutePath);
+  }
+  return tests.map((ref) => {
+    let resolved;
+    if (ref.endsWith(".pw.ts") || ref.endsWith(".k6.ts") || ref.endsWith(".pw.js") || ref.endsWith(".k6.js")) {
+      resolved = resolve6(cwd, ref);
+    } else if (ref.startsWith("_supercheck_/")) {
+      resolved = resolve6(cwd, ref);
+    } else if (uuidMap.has(ref)) {
+      resolved = uuidMap.get(ref);
+    }
+    if (!resolved) {
+      throw new CLIError(`Cannot resolve local test for job entry: ${ref}`, 3 /* ConfigError */);
+    }
+    const script = readFileSync3(resolved, "utf-8");
+    const type = inferLocalTestType(resolved);
+    return { path: resolved, type, name: toDisplayName(cwd, resolved), script };
+  });
+}
+async function validateJobTests(client, tests) {
+  const inputs = tests.map((test) => ({
+    name: test.name,
+    script: test.script,
+    testType: normalizeTestTypeForApi(test.type)
+  }));
+  const results = await validateScripts(client, inputs);
+  const failures = results.filter((r) => !r.valid);
+  if (failures.length > 0) {
+    const details = failures.map((f) => `  - ${f.name}: ${f.error ?? "Validation failed"}`).join("\n");
+    throw new CLIError(`Validation failed:
+${details}`, 3 /* ConfigError */);
+  }
+}
+async function runLocalJobTests(tests, cwd, testMatch) {
+  const playwrightTests = tests.filter((t) => t.type === "playwright").map((t) => t.path);
+  const k6Tests = tests.filter((t) => t.type === "k6").map((t) => t.path);
+  try {
+    if (playwrightTests.length > 0) {
+      ensureDependenciesForTestType(cwd, "playwright");
+    }
+    if (k6Tests.length > 0) {
+      ensureDependenciesForTestType(cwd, "k6");
+    }
+  } catch (err) {
+    if (err instanceof DependencyError) {
+      throw new CLIError(err.message, 1 /* GeneralError */);
+    }
+    throw err;
+  }
+  if (playwrightTests.length > 0) {
+    logger.header("Running Playwright tests");
+    const tempConfig = createTempPlaywrightConfig(cwd, testMatch);
+    try {
+      const code = await runCommand("npx", ["playwright", "test", "--config", tempConfig.path, ...playwrightTests], cwd);
+      if (code !== 0) {
+        throw new CLIError(`Playwright tests failed with exit code ${code}`, 1 /* GeneralError */);
+      }
+    } finally {
+      tempConfig.cleanup();
+    }
+  }
+  for (const path of k6Tests) {
+    logger.header(`Running k6 test: ${toDisplayName(cwd, path)}`);
+    const code = await runCommand("k6", ["run", path], cwd);
+    if (code !== 0) {
+      throw new CLIError(`k6 test failed with exit code ${code}`, 1 /* GeneralError */);
+    }
+  }
+}
 jobCommand.command("list").description("List all jobs").option("--page <page>", "Page number", "1").option("--limit <limit>", "Items per page", "50").action(async (options) => {
   const client = createAuthenticatedClient();
   const { data } = await withSpinner(
@@ -1846,15 +2324,19 @@ jobCommand.command("get <id>").description("Get job details").action(async (id)
   );
   outputDetail(data);
 });
-jobCommand.command("create").description("Create a new job").requiredOption("--name <name>", "Job name").option("--description <description>", "Job description", "").option("--type <type>", "Job type (playwright, k6)").option("--schedule <cron>", "Cron schedule expression").option("--timeout <seconds>", "Timeout in seconds", "300").option("--retries <count>", "Retry count on failure", "0").action(async (options) => {
+jobCommand.command("create").description("Create a new job").requiredOption("--name <name>", "Job name").requiredOption("--tests <tests...>", "Test IDs (space or comma separated)").option("--description <description>", "Job description", "").option("--type <type>", "Job runner type (playwright, k6)").option("--schedule <cron>", "Cron schedule expression").option("--timeout <seconds>", "Timeout in seconds", "300").option("--retries <count>", "Retry count on failure", "0").action(async (options) => {
   const client = createAuthenticatedClient();
+  const tests = (options.tests ?? []).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+  if (tests.length === 0) {
+    throw new CLIError("At least one test ID is required to create a job.", 3 /* ConfigError */);
+  }
   const body = {
     name: options.name,
     description: options.description,
     timeoutSeconds: parseIntStrict(options.timeout, "--timeout", { min: 1 }),
     retryCount: parseIntStrict(options.retries, "--retries", { min: 0 }),
     config: {},
-    tests: []
+    tests: tests.map((id) => ({ id }))
   };
   if (options.type) body.jobType = options.type;
   if (options.schedule) body.cronSchedule = options.schedule;
@@ -1862,8 +2344,10 @@ jobCommand.command("create").description("Create a new job").requiredOption("--n
     "Creating job",
     () => client.post("/api/jobs", body)
   );
-  logger.success(`Job "${options.name}" created (${data.id})`);
-  outputDetail(data);
+  const job = data.job ?? data;
+  const jobId = job?.id;
+  logger.success(`Job "${options.name}" created (${jobId ?? "unknown"})`);
+  outputDetail(job);
 });
 jobCommand.command("update <id>").description("Update job configuration").option("--name <name>", "Job name").option("--description <description>", "Job description").option("--schedule <cron>", "Cron schedule expression").option("--timeout <seconds>", "Timeout in seconds").option("--retries <count>", "Retry count on failure").option("--status <status>", "Job status (active, paused)").action(async (id, options) => {
   const client = createAuthenticatedClient();
@@ -1901,7 +2385,34 @@ jobCommand.command("delete <id>").description("Delete a job").option("--force",
   );
   logger.success(`Job ${id} deleted`);
 });
-jobCommand.command("run").description("Run a job immediately").requiredOption("--id <id>", "Job ID to run").action(async (options) => {
+jobCommand.command("run").description("Run a job immediately").requiredOption("--id <id>", "Job ID to run").option("--local", "Run locally").option("--cloud", "Run on cloud").action(async (options) => {
+  if (options.local && options.cloud) {
+    throw new CLIError("--local and --cloud are mutually exclusive.", 3 /* ConfigError */);
+  }
+  const useLocal = options.local === true;
+  if (useLocal) {
+    const cwd = process.cwd();
+    const { config } = await loadConfig({ cwd });
+    const job = config.jobs?.find((j) => j.id === options.id || j.name === options.id);
+    if (!job) {
+      throw new CLIError(`Job ${options.id} not found in local config.`, 3 /* ConfigError */);
+    }
+    const tests2 = Array.isArray(job.tests) ? job.tests : [];
+    if (tests2.length === 0) {
+      throw new CLIError(`Job ${options.id} has no tests.`, 1 /* GeneralError */);
+    }
+    const patterns = {
+      playwright: config.tests?.playwright?.testMatch,
+      k6: config.tests?.k6?.testMatch
+    };
+    const localTests = resolveJobLocalTests(cwd, tests2, patterns);
+    const client2 = createAuthenticatedClient();
+    await withSpinner("Validating test scripts...", async () => {
+      await validateJobTests(client2, localTests);
+    }, { successText: "Test scripts validated" });
+    await runLocalJobTests(localTests, cwd, config.tests?.playwright?.testMatch);
+    return;
+  }
   const client = createAuthenticatedClient();
   const { data: jobData } = await withSpinner(
     "Fetching job details",
@@ -1941,7 +2452,11 @@ jobCommand.command("trigger <id>").description("Trigger a job run").option("--wa
       `/api/jobs/${id}/trigger`
     )
   );
-  logger.success(`Job triggered. Run ID: ${data.runId}`);
+  const runId = data.runId ?? data.data?.runId;
+  if (!runId) {
+    throw new CLIError("Job trigger response did not include a run ID.", 4 /* ApiError */);
+  }
+  logger.success(`Job triggered. Run ID: ${runId}`);
   if (options.wait) {
     let statusClient;
     try {
@@ -1956,20 +2471,20 @@ jobCommand.command("trigger <id>").description("Trigger a job run").option("--wa
     const timeoutMs = parseIntStrict(options.timeout, "--timeout", { min: 1 }) * 1e3;
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
-      await new Promise((resolve6) => setTimeout(resolve6, 3e3));
+      await new Promise((resolve10) => setTimeout(resolve10, 3e3));
       const { data: runData } = await statusClient.get(
-        `/api/runs/${data.runId}`
+        `/api/runs/${runId}`
       );
       const status = typeof runData.status === "string" ? runData.status.toLowerCase() : "";
       if (["passed", "failed", "error", "blocked"].includes(status)) {
         if (status === "passed") {
-          logger.success(`Run ${data.runId} passed`);
+          logger.success(`Run ${runId} passed`);
         } else if (status === "blocked") {
-          logger.error(`Run ${data.runId} blocked`);
-          throw new CLIError(`Run ${data.runId} blocked`, 1 /* GeneralError */);
+          logger.error(`Run ${runId} blocked`);
+          throw new CLIError(`Run ${runId} blocked`, 1 /* GeneralError */);
         } else {
-          logger.error(`Run ${data.runId} ${status}`);
-          throw new CLIError(`Run ${data.runId} ${status}`, 1 /* GeneralError */);
+          logger.error(`Run ${runId} ${status}`);
+          throw new CLIError(`Run ${runId} ${status}`, 1 /* GeneralError */);
         }
         outputDetail(runData);
         return;
@@ -1985,55 +2500,14 @@ jobCommand.command("trigger <id>").description("Trigger a job run").option("--wa
 
 // src/commands/runs.ts
 import { Command as Command6 } from "commander";
-import { ProxyAgent as ProxyAgent2 } from "undici";
-var proxyAgents2 = /* @__PURE__ */ new Map();
-function getProxyAgent2(proxyUrl) {
-  const existing = proxyAgents2.get(proxyUrl);
-  if (existing) return existing;
-  const created = new ProxyAgent2(proxyUrl);
-  proxyAgents2.set(proxyUrl, created);
-  return created;
-}
-function isNoProxyMatch(url, noProxyRaw) {
-  const hostname = url.hostname;
-  const port = url.port || (url.protocol === "https:" ? "443" : "80");
-  const entries = noProxyRaw.split(",").map((entry) => entry.trim()).filter(Boolean);
-  if (entries.includes("*")) return true;
-  for (const entry of entries) {
-    const [hostPart, portPart] = entry.split(":");
-    const host = hostPart.trim();
-    const entryPort = portPart?.trim();
-    if (!host) continue;
-    if (entryPort && entryPort !== port) continue;
-    if (host.startsWith(".")) {
-      if (hostname.endsWith(host)) return true;
-      continue;
-    }
-    if (hostname === host) return true;
-    if (hostname.endsWith(`.${host}`)) return true;
-  }
-  return false;
-}
-function getProxyEnv(url) {
-  const noProxyRaw = process.env.NO_PROXY ?? process.env.no_proxy;
-  if (noProxyRaw && isNoProxyMatch(url, noProxyRaw)) {
-    return null;
-  }
-  if (url.protocol === "https:") {
-    return process.env.HTTPS_PROXY ?? process.env.https_proxy ?? process.env.HTTP_PROXY ?? process.env.http_proxy ?? null;
-  }
-  if (url.protocol === "http:") {
-    return process.env.HTTP_PROXY ?? process.env.http_proxy ?? null;
-  }
-  return null;
-}
-var runCommand = new Command6("run").description("Manage runs");
-runCommand.command("list").description("List runs").option("--page <page>", "Page number", "1").option("--limit <limit>", "Items per page", "50").option("--status <status>", "Filter by status").action(async (options) => {
+var runCommand2 = new Command6("run").description("Manage runs");
+runCommand2.command("list").description("List runs").option("--page <page>", "Page number", "1").option("--limit <limit>", "Items per page", "50").option("--job <jobId>", "Filter by job ID").option("--status <status>", "Filter by status").action(async (options) => {
   const client = createAuthenticatedClient();
   const params = {
     page: options.page,
     limit: options.limit
   };
+  if (options.job) params.jobId = options.job;
   if (options.status) params.status = options.status;
   const { data } = await withSpinner(
     "Fetching runs",
@@ -2058,7 +2532,7 @@ Page ${data.pagination.page}/${data.pagination.totalPages} (${data.pagination.to
     );
   }
 });
-runCommand.command("get <id>").description("Get run details").action(async (id) => {
+runCommand2.command("get <id>").description("Get run details").action(async (id) => {
   const client = createAuthenticatedClient();
   const { data } = await withSpinner(
     "Fetching run details",
@@ -2066,7 +2540,7 @@ runCommand.command("get <id>").description("Get run details").action(async (id)
   );
   outputDetail(data);
 });
-runCommand.command("status <id>").description("Get run status").action(async (id) => {
+runCommand2.command("status <id>").description("Get run status").action(async (id) => {
   const client = createAuthenticatedClient();
   const { data } = await withSpinner(
     "Fetching run status",
@@ -2074,7 +2548,16 @@ runCommand.command("status <id>").description("Get run status").action(async (id
   );
   outputDetail(data);
 });
-runCommand.command("stream <id>").description("Stream live console output from a run").option("--idle-timeout <seconds>", "Abort if no data received within this period", "60").action(async (id, options) => {
+runCommand2.command("permissions <id>").description("Get run access permissions").action(async (id) => {
+  const client = createAuthenticatedClient();
+  const { data } = await withSpinner(
+    "Fetching run permissions",
+    () => client.get(`/api/runs/${id}/permissions`)
+  );
+  const payload = data.data ?? data;
+  outputDetail(payload);
+});
+runCommand2.command("stream <id>").description("Stream live console output from a run").option("--idle-timeout <seconds>", "Abort if no data received within this period", "60").action(async (id, options) => {
   const token = requireAuth();
   const baseUrl = getStoredBaseUrl() ?? "https://app.supercheck.io";
   const idleTimeoutMs = Math.max(Number(options.idleTimeout) || 60, 10) * 1e3;
@@ -2092,7 +2575,7 @@ runCommand.command("stream <id>").description("Stream live console output from a
         "Accept": "text/event-stream",
         "User-Agent": `supercheck-cli/${CLI_VERSION}`
       },
-      ...proxy ? { dispatcher: getProxyAgent2(proxy) } : {},
+      ...proxy ? { dispatcher: getProxyAgent(proxy) } : {},
       signal: controller.signal
     });
     clearTimeout(connectTimeout);
@@ -2182,62 +2665,101 @@ runCommand.command("stream <id>").description("Stream live console output from a
     );
   }
 });
+runCommand2.command("cancel <id>").description("Cancel a running execution").action(async (id) => {
+  const client = createAuthenticatedClient();
+  const { data } = await withSpinner(
+    "Cancelling run",
+    () => client.post(`/api/runs/${id}/cancel`)
+  );
+  outputDetail(data);
+});
 
 // src/commands/tests.ts
 import { Command as Command7 } from "commander";
-import { ProxyAgent as ProxyAgent3 } from "undici";
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve7 } from "path";
 import { Buffer as Buffer2 } from "buffer";
-var proxyAgents3 = /* @__PURE__ */ new Map();
-function getProxyAgent3(proxyUrl) {
-  const existing = proxyAgents3.get(proxyUrl);
-  if (existing) return existing;
-  const created = new ProxyAgent3(proxyUrl);
-  proxyAgents3.set(proxyUrl, created);
-  return created;
+function normalizeTestType(input) {
+  return normalizeTestTypeForApi(input) ?? input.trim().toLowerCase();
 }
-function isNoProxyMatch2(url, noProxyRaw) {
-  const hostname = url.hostname;
-  const port = url.port || (url.protocol === "https:" ? "443" : "80");
-  const entries = noProxyRaw.split(",").map((entry) => entry.trim()).filter(Boolean);
-  if (entries.includes("*")) return true;
-  for (const entry of entries) {
-    const [hostPart, portPart] = entry.split(":");
-    const host = hostPart.trim();
-    const entryPort = portPart?.trim();
-    if (!host) continue;
-    if (entryPort && entryPort !== port) continue;
-    if (host.startsWith(".")) {
-      if (hostname.endsWith(host)) return true;
-      continue;
-    }
-    if (hostname === host) return true;
-    if (hostname.endsWith(`.${host}`)) return true;
-  }
-  return false;
+function inferTestType(filename) {
+  if (filename.endsWith(".k6.ts") || filename.endsWith(".k6.js")) return "k6";
+  if (filename.endsWith(".pw.ts") || filename.endsWith(".pw.js") || filename.endsWith(".spec.ts")) return "playwright";
+  return void 0;
 }
-function getProxyEnv2(url) {
-  const noProxyRaw = process.env.NO_PROXY ?? process.env.no_proxy;
-  if (noProxyRaw && isNoProxyMatch2(url, noProxyRaw)) {
-    return null;
+function toDisplayName2(cwd, filePath) {
+  const normalized = filePath.replace(cwd, "").replace(/^\//, "");
+  return normalized.startsWith("_supercheck_/") ? normalized.replace(/^_supercheck_\//, "") : normalized;
+}
+function collectLocalTests(cwd, patterns, options) {
+  if (options.file) {
+    const filePath = resolve7(cwd, options.file);
+    const type = inferTestType(filePath) ?? (options.type === "k6" ? "k6" : "playwright");
+    const validationType = options.type ? normalizeTestTypeForApi(options.type) : normalizeTestTypeForApi(type);
+    const script = readFileSync4(filePath, "utf-8");
+    return [{
+      path: filePath,
+      type,
+      name: toDisplayName2(cwd, filePath),
+      script,
+      validationType
+    }];
+  }
+  const typeFilter = options.type?.toLowerCase();
+  const filterType = typeFilter && ["api", "database", "custom", "browser", "playwright"].includes(typeFilter) ? "playwright" : typeFilter === "performance" || typeFilter === "load" ? "k6" : typeFilter;
+  const files = discoverFiles(cwd, patterns).filter((file) => !filterType || file.type === filterType);
+  return files.map((file) => {
+    const script = readFileSync4(file.absolutePath, "utf-8");
+    const validationType = options.type ? normalizeTestTypeForApi(options.type) : normalizeTestTypeForApi(file.type);
+    return {
+      path: file.absolutePath,
+      type: file.type,
+      name: toDisplayName2(cwd, file.absolutePath),
+      script,
+      validationType
+    };
+  });
+}
+async function validateLocalTests(client, tests) {
+  const inputs = tests.map((test) => ({
+    name: test.name,
+    script: test.script,
+    testType: test.validationType ?? normalizeTestTypeForApi(test.type)
+  }));
+  const results = await validateScripts(client, inputs);
+  const failures = results.filter((r) => !r.valid);
+  if (failures.length > 0) {
+    const details = failures.map((f) => `  - ${f.name}: ${f.error ?? "Validation failed"}`).join("\n");
+    throw new CLIError(`Validation failed:
+${details}`, 3 /* ConfigError */);
   }
-  if (url.protocol === "https:") {
-    return process.env.HTTPS_PROXY ?? process.env.https_proxy ?? process.env.HTTP_PROXY ?? process.env.http_proxy ?? null;
+  const warnings = results.filter((r) => r.warnings && r.warnings.length > 0);
+  for (const warn of warnings) {
+    logger.warn(`Validation warnings for ${warn.name}: ${(warn.warnings ?? []).join(", ")}`);
   }
-  if (url.protocol === "http:") {
-    return process.env.HTTP_PROXY ?? process.env.http_proxy ?? null;
+}
+async function runPlaywrightTests(paths, cwd, testMatch) {
+  if (paths.length === 0) return;
+  const tempConfig = createTempPlaywrightConfig(cwd, testMatch);
+  try {
+    const code = await runCommand("npx", ["playwright", "test", "--config", tempConfig.path, ...paths], cwd);
+    if (code !== 0) {
+      throw new CLIError(`Playwright tests failed with exit code ${code}`, 1 /* GeneralError */);
+    }
+  } finally {
+    tempConfig.cleanup();
   }
-  return null;
 }
-function normalizeTestType(input) {
-  const normalized = input.trim().toLowerCase();
-  if (normalized === "k6") return "performance";
-  if (normalized === "performance") return "performance";
-  if (normalized === "playwright") return "browser";
-  if (normalized === "browser") return "browser";
-  return normalized;
+async function runK6Tests(paths, cwd) {
+  for (const path of paths) {
+    const code = await runCommand("k6", ["run", path], cwd);
+    if (code !== 0) {
+      throw new CLIError(`k6 test failed with exit code ${code}`, 1 /* GeneralError */);
+    }
+  }
 }
 var testCommand = new Command7("test").description("Manage tests");
-testCommand.command("list").description("List all tests").option("--page <page>", "Page number", "1").option("--limit <limit>", "Items per page", "50").option("--search <query>", "Search by title").option("--type <type>", "Filter by type (playwright, k6)").action(async (options) => {
+testCommand.command("list").description("List all tests").option("--page <page>", "Page number", "1").option("--limit <limit>", "Items per page", "50").option("--search <query>", "Search by title").option("--type <type>", "Filter by type (browser, performance, api, database, custom)").action(async (options) => {
   const client = createAuthenticatedClient();
   const params = {
     page: options.page,
@@ -2269,30 +2791,32 @@ Page ${data.pagination.page}/${data.pagination.totalPages} (${data.pagination.to
 });
 testCommand.command("get <id>").description("Get test details").option("--include-script", "Include the test script content").action(async (id, options) => {
   const client = createAuthenticatedClient();
-  const params = {};
-  if (options.includeScript) params.includeScript = "true";
+  const params = {
+    includeScript: options.includeScript ? "true" : "false"
+  };
   const { data } = await withSpinner(
     "Fetching test details",
     () => client.get(`/api/tests/${id}`, params)
   );
   outputDetail(data);
 });
-testCommand.command("create").description("Create a new test").requiredOption("--title <title>", "Test title").requiredOption("--file <path>", "Path to the test script file").option("--type <type>", "Test type (playwright, k6)", "playwright").option("--description <description>", "Test description").action(async (options) => {
-  const { readFileSync: readFileSync4 } = await import("fs");
-  const { resolve: resolve6 } = await import("path");
-  const filePath = resolve6(process.cwd(), options.file);
+testCommand.command("create").description("Create a new test").requiredOption("--title <title>", "Test title").requiredOption("--file <path>", "Path to the test script file").option("--type <type>", "Test type (browser, performance, api, database, custom)").option("--description <description>", "Test description").action(async (options) => {
+  const { readFileSync: readFileSync6 } = await import("fs");
+  const { resolve: resolve10 } = await import("path");
+  const filePath = resolve10(process.cwd(), options.file);
   let script;
   try {
-    script = readFileSync4(filePath, "utf-8");
+    script = readFileSync6(filePath, "utf-8");
   } catch {
     throw new CLIError(`Cannot read file: ${filePath}`, 1 /* GeneralError */);
   }
+  const typeArg = options.type || inferTestType(options.file) || "playwright";
   const client = createAuthenticatedClient();
   const encodedScript = Buffer2.from(script, "utf-8").toString("base64");
   const body = {
     title: options.title,
     script: encodedScript,
-    type: normalizeTestType(options.type)
+    type: normalizeTestType(typeArg)
   };
   if (options.description) body.description = options.description;
   const { data } = await withSpinner(
@@ -2309,11 +2833,11 @@ testCommand.command("update <id>").description("Update a test").option("--title
   if (options.title !== void 0) body.title = options.title;
   if (options.description !== void 0) body.description = options.description;
   if (options.file) {
-    const { readFileSync: readFileSync4 } = await import("fs");
-    const { resolve: resolve6 } = await import("path");
-    const filePath = resolve6(process.cwd(), options.file);
+    const { readFileSync: readFileSync6 } = await import("fs");
+    const { resolve: resolve10 } = await import("path");
+    const filePath = resolve10(process.cwd(), options.file);
     try {
-      const raw = readFileSync4(filePath, "utf-8");
+      const raw = readFileSync6(filePath, "utf-8");
       body.script = Buffer2.from(raw, "utf-8").toString("base64");
     } catch {
       throw new CLIError(`Cannot read file: ${filePath}`, 1 /* GeneralError */);
@@ -2346,6 +2870,71 @@ testCommand.command("delete <id>").description("Delete a test").option("--force"
   );
   logger.success(`Test ${id} deleted`);
 });
+testCommand.command("run").description("Run tests locally or in the cloud").option("--local", "Run locally").option("--cloud", "Run on cloud").option("--file <path>", "Local test file path").option("--all", "Run all local tests").option("--type <type>", "Local test type filter (browser, performance, api, database, custom)").option("--id <id>", "Cloud test ID").option("--location <location>", "Execution location (k6 cloud only)").action(async (options) => {
+  if (options.local && options.cloud) {
+    throw new CLIError("--local and --cloud are mutually exclusive.", 3 /* ConfigError */);
+  }
+  const useCloud = options.cloud || !options.local && !!options.id;
+  if (useCloud) {
+    if (!options.id) {
+      throw new CLIError("Cloud runs require --id <testId>.", 3 /* ConfigError */);
+    }
+    const client2 = createAuthenticatedClient();
+    const body = {};
+    if (options.location) body.location = options.location;
+    const { data } = await withSpinner(
+      "Executing test",
+      () => client2.post(`/api/tests/${options.id}/execute`, body)
+    );
+    outputDetail(data);
+    return;
+  }
+  if (!options.file && !options.all) {
+    throw new CLIError("Local runs require --file <path> or --all.", 3 /* ConfigError */);
+  }
+  const cwd = process.cwd();
+  const { config } = await loadConfig({ cwd });
+  const client = createAuthenticatedClient();
+  const patterns = {
+    playwright: config.tests?.playwright?.testMatch,
+    k6: config.tests?.k6?.testMatch
+  };
+  const localTests = collectLocalTests(cwd, patterns, {
+    file: options.file,
+    all: options.all,
+    type: options.type
+  });
+  if (localTests.length === 0) {
+    logger.warn("No local tests found to run.");
+    return;
+  }
+  await withSpinner("Validating test scripts...", async () => {
+    await validateLocalTests(client, localTests);
+  }, { successText: "Test scripts validated" });
+  const playwrightTests = localTests.filter((t) => t.type === "playwright").map((t) => t.path);
+  const k6Tests = localTests.filter((t) => t.type === "k6").map((t) => t.path);
+  try {
+    if (playwrightTests.length > 0) {
+      ensureDependenciesForTestType(cwd, "playwright");
+    }
+    if (k6Tests.length > 0) {
+      ensureDependenciesForTestType(cwd, "k6");
+    }
+  } catch (err) {
+    if (err instanceof DependencyError) {
+      throw new CLIError(err.message, 3 /* ConfigError */);
+    }
+    throw err;
+  }
+  if (playwrightTests.length > 0) {
+    logger.header("Running Playwright tests");
+    await runPlaywrightTests(playwrightTests, cwd, config.tests?.playwright?.testMatch);
+  }
+  if (k6Tests.length > 0) {
+    logger.header("Running k6 tests");
+    await runK6Tests(k6Tests, cwd);
+  }
+});
 testCommand.command("execute <id>").description("Execute a test immediately").option("--location <location>", "Execution location (k6 only)").action(async (id, options) => {
   const client = createAuthenticatedClient();
   const body = {};
@@ -2370,35 +2959,34 @@ testCommand.command("tags <id>").description("Get test tags").action(async (id)
     ]
   });
 });
-testCommand.command("validate").description("Validate a test script").requiredOption("--file <path>", "Path to the test script file").option("--type <type>", "Test type (playwright, k6)", "playwright").action(async (options) => {
-  const { readFileSync: readFileSync4 } = await import("fs");
-  const { resolve: resolve6 } = await import("path");
-  const filePath = resolve6(process.cwd(), options.file);
+testCommand.command("validate").description("Validate a test script").requiredOption("--file <path>", "Path to the test script file").option("--type <type>", "Test type (browser, performance, api, database, custom)").action(async (options) => {
+  const cwd = process.cwd();
+  const filePath = resolve7(cwd, options.file);
   let script;
   try {
     script = readFileSync4(filePath, "utf-8");
   } catch {
     throw new CLIError(`Cannot read file: ${filePath}`, 1 /* GeneralError */);
   }
+  const typeArg = options.type || inferTestType(options.file) || "playwright";
   const client = createAuthenticatedClient();
-  const { data } = await withSpinner(
+  const results = await withSpinner(
     "Validating script",
-    () => client.post(
-      "/api/validate-script",
-      { script, testType: normalizeTestType(options.type) }
-    )
+    () => validateScripts(client, [{
+      name: toDisplayName2(cwd, filePath),
+      script,
+      testType: normalizeTestTypeForApi(typeArg)
+    }])
   );
-  if (data.valid) {
-    logger.success(`Script is valid (${options.type})`);
-  } else {
-    logger.error("Script validation failed:");
-    if (data.errors) {
-      for (const err of data.errors) {
-        logger.error(`  - ${err}`);
-      }
+  const result = results[0];
+  if (result?.valid) {
+    logger.success(`Script is valid (${typeArg})`);
+    if (result.warnings && result.warnings.length > 0) {
+      logger.warn(`Warnings: ${result.warnings.join(", ")}`);
     }
-    throw new CLIError("Script validation failed", 1 /* GeneralError */);
+    return;
   }
+  throw new CLIError(`Script validation failed: ${result?.error ?? "Unknown error"}`, 1 /* GeneralError */);
 });
 testCommand.command("status <id>").description("Stream live status events for a test").option("--idle-timeout <seconds>", "Abort if no data received within this period", "60").action(async (id, options) => {
   const token = requireAuth();
@@ -2411,14 +2999,14 @@ testCommand.command("status <id>").description("Stream live status events for a
   const controller = new AbortController();
   const connectTimeout = setTimeout(() => controller.abort(), 3e4);
   try {
-    const proxy = getProxyEnv2(parsedUrl);
+    const proxy = getProxyEnv(parsedUrl);
     const response = await fetch(url, {
       headers: {
         "Authorization": `Bearer ${token}`,
         "Accept": "text/event-stream",
         "User-Agent": `supercheck-cli/${CLI_VERSION}`
       },
-      ...proxy ? { dispatcher: getProxyAgent3(proxy) } : {},
+      ...proxy ? { dispatcher: getProxyAgent(proxy) } : {},
       signal: controller.signal
     });
     clearTimeout(connectTimeout);
@@ -2749,7 +3337,7 @@ tagCommand.command("delete <id>").description("Delete a tag").option("--force",
 import { Command as Command11 } from "commander";
 
 // src/utils/reconcile.ts
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 function reconcile(local, remote) {
   const changes = [];
   const remoteByKey = /* @__PURE__ */ new Map();
@@ -2851,37 +3439,37 @@ function formatChangePlan(changes) {
   logger.header("Change Plan");
   logger.newline();
   if (creates.length > 0) {
-    logger.info(pc3.green(`  + ${creates.length} to create`));
+    logger.info(pc4.green(`  + ${creates.length} to create`));
     for (const c of creates) {
-      logger.info(pc3.green(`    + ${c.type}/${c.name}`));
+      logger.info(pc4.green(`    + ${c.type}/${c.name}`));
     }
   }
   if (updates.length > 0) {
-    logger.info(pc3.yellow(`  ~ ${updates.length} to update`));
+    logger.info(pc4.yellow(`  ~ ${updates.length} to update`));
     for (const c of updates) {
-      logger.info(pc3.yellow(`    ~ ${c.type}/${c.name} (${c.id})`));
+      logger.info(pc4.yellow(`    ~ ${c.type}/${c.name} (${c.id})`));
       if (c.details) {
         for (const d of c.details) {
-          logger.info(pc3.gray(`        ${d}`));
+          logger.info(pc4.gray(`        ${d}`));
         }
       }
     }
   }
   if (deletes.length > 0) {
-    logger.info(pc3.red(`  - ${deletes.length} to delete`));
+    logger.info(pc4.red(`  - ${deletes.length} to delete`));
     for (const c of deletes) {
-      logger.info(pc3.red(`    - ${c.type}/${c.name} (${c.id})`));
+      logger.info(pc4.red(`    - ${c.type}/${c.name} (${c.id})`));
     }
   }
   if (unchanged.length > 0) {
-    logger.info(pc3.gray(`  = ${unchanged.length} unchanged`));
+    logger.info(pc4.gray(`  = ${unchanged.length} unchanged`));
   }
   logger.newline();
   const totalChanges = creates.length + updates.length + deletes.length;
   if (totalChanges === 0) {
     logger.success("No changes detected. Everything is in sync.");
   } else {
-    logger.info(`${pc3.bold(String(totalChanges))} change(s) detected.`);
+    logger.info(`${pc4.bold(String(totalChanges))} change(s) detected.`);
   }
   logger.newline();
 }
@@ -2908,9 +3496,28 @@ var diffCommand = new Command11("diff").description("Preview changes between loc
 
 // src/commands/deploy.ts
 import { Command as Command12 } from "commander";
-import pc4 from "picocolors";
+import { renameSync } from "fs";
+import { resolve as resolve8 } from "path";
+
+// src/utils/paths.ts
+function testTypeToFolder(testType) {
+  return testType === "k6" ? "k6" : "playwright";
+}
+function testRelativePath(testId, title, testType) {
+  const folder = testTypeToFolder(testType);
+  const filename = testFilename(testId, title, testType);
+  return `_supercheck_/${folder}/${filename}`;
+}
+
+// src/commands/deploy.ts
+import pc5 from "picocolors";
 function prepareBodyForApi(type, body) {
   const payload = { ...body };
+  if (type === "test") {
+    const normalizedType = normalizeTestTypeForApi(payload.testType);
+    if (normalizedType) payload.type = normalizedType;
+    delete payload.testType;
+  }
   if (type === "job") {
     if (Array.isArray(payload.tests)) {
       payload.tests = payload.tests.map((t) => {
@@ -2927,13 +3534,30 @@ function prepareBodyForApi(type, body) {
   }
   return payload;
 }
-async function applyChange(client, change) {
+async function applyChange(client, change, opts) {
   try {
     const endpoint = getApiEndpoint(change.type);
     switch (change.action) {
       case "create": {
-        const body = prepareBodyForApi(change.type, change.local.definition);
-        await client.post(endpoint, body);
+        const { id: _id, ...rawBody } = change.local.definition;
+        const body = prepareBodyForApi(change.type, rawBody);
+        const response = await client.post(endpoint, body);
+        if (change.type === "test") {
+          const responseBody = response.data;
+          const createdId = responseBody?.test?.id;
+          const createdTitle = responseBody?.test?.title ?? change.local?.definition?.title;
+          const testType = change.local?.definition?.testType === "k6" ? "k6" : "playwright";
+          if (createdId && typeof createdTitle === "string") {
+            const existingPath = opts.testFilesByName.get(change.name);
+            if (existingPath) {
+              const newRelPath = testRelativePath(createdId, createdTitle, testType);
+              const newPath = resolve8(process.cwd(), newRelPath);
+              if (newPath !== existingPath) {
+                renameSync(existingPath, newPath);
+              }
+            }
+          }
+        }
         return { success: true };
       }
       case "update": {
@@ -2983,9 +3607,30 @@ var deployCommand = new Command12("deploy").description("Push local config resou
   }
   formatChangePlan(changes);
   if (options.dryRun) {
-    logger.info(pc4.yellow("Dry run \u2014 no changes applied."));
+    logger.info(pc5.yellow("Dry run \u2014 no changes applied."));
     return;
   }
+  const testsToValidate = actionable.filter((c) => c.type === "test" && (c.action === "create" || c.action === "update"));
+  if (testsToValidate.length > 0) {
+    await withSpinner("Validating test scripts...", async () => {
+      const inputs = testsToValidate.map((change) => ({
+        name: change.name,
+        script: String(change.local?.definition?.script ?? ""),
+        testType: normalizeTestTypeForApi(change.local?.definition?.testType)
+      }));
+      const results = await validateScripts(client, inputs);
+      const failures = results.filter((r) => !r.valid);
+      if (failures.length > 0) {
+        const details = failures.map((f) => `  - ${f.name}: ${f.error ?? "Validation failed"}`).join("\n");
+        throw new CLIError(`Validation failed:
+${details}`, 3 /* ConfigError */);
+      }
+      const warnings = results.filter((r) => r.warnings && r.warnings.length > 0);
+      for (const warn of warnings) {
+        logger.warn(`Validation warnings for ${warn.name}: ${(warn.warnings ?? []).join(", ")}`);
+      }
+    }, { successText: "Test scripts validated" });
+  }
   if (!options.force) {
     const confirmed = await confirmPrompt("Apply these changes?", { default: false });
     if (!confirmed) {
@@ -3002,10 +3647,19 @@ var deployCommand = new Command12("deploy").description("Push local config resou
     ...actionable.filter((c) => c.action === "update"),
     ...actionable.filter((c) => c.action === "delete")
   ];
+  const testFilesByName = /* @__PURE__ */ new Map();
+  const patterns = {
+    playwright: config.tests?.playwright?.testMatch,
+    k6: config.tests?.k6?.testMatch
+  };
+  for (const file of discoverFiles(cwd, patterns)) {
+    const key = file.relativePath.replace(/^_supercheck_\//, "");
+    testFilesByName.set(key, file.absolutePath);
+  }
   for (const change of ordered) {
     const actionLabel = change.action === "create" ? "+" : change.action === "update" ? "~" : "-";
-    const color = change.action === "create" ? pc4.green : change.action === "update" ? pc4.yellow : pc4.red;
-    const result = await applyChange(client, change);
+    const color = change.action === "create" ? pc5.green : change.action === "update" ? pc5.yellow : pc5.red;
+    const result = await applyChange(client, change, { testFilesByName });
     if (result.success) {
       logger.info(color(`  ${actionLabel} ${change.type}/${change.name} \u2713`));
       succeeded++;
@@ -3027,7 +3681,7 @@ var deployCommand = new Command12("deploy").description("Push local config resou
 
 // src/commands/destroy.ts
 import { Command as Command13 } from "commander";
-import pc5 from "picocolors";
+import pc6 from "picocolors";
 async function fetchManagedResources(client, config) {
   const resources = [];
   const managedIds = /* @__PURE__ */ new Set();
@@ -3157,13 +3811,13 @@ var destroyCommand = new Command13("destroy").description("Tear down managed res
   logger.header("Resources to destroy:");
   logger.newline();
   for (const r of managed) {
-    logger.info(pc5.red(`  - ${r.type}/${r.name} [${r.id}]`));
+    logger.info(pc6.red(`  - ${r.type}/${r.name} [${r.id}]`));
   }
   logger.newline();
-  logger.warn(`This will permanently delete ${pc5.bold(String(managed.length))} resource(s).`);
+  logger.warn(`This will permanently delete ${pc6.bold(String(managed.length))} resource(s).`);
   logger.newline();
   if (options.dryRun) {
-    logger.info(pc5.yellow("Dry run \u2014 no resources destroyed."));
+    logger.info(pc6.yellow("Dry run \u2014 no resources destroyed."));
     return;
   }
   if (!options.force) {
@@ -3182,7 +3836,7 @@ var destroyCommand = new Command13("destroy").description("Tear down managed res
     try {
       const endpoint = getApiEndpoint(resource.type);
       await client.delete(`${endpoint}/${resource.id}`);
-      logger.info(pc5.red(`  - ${resource.type}/${resource.name} \u2713`));
+      logger.info(pc6.red(`  - ${resource.type}/${resource.name} \u2713`));
       succeeded++;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -3203,30 +3857,23 @@ var destroyCommand = new Command13("destroy").description("Tear down managed res
 
 // src/commands/pull.ts
 import { Command as Command14 } from "commander";
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve5, dirname as dirname2 } from "path";
-import pc6 from "picocolors";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync4, readFileSync as readFileSync5, readdirSync as readdirSync2, unlinkSync } from "fs";
+import { resolve as resolve9, dirname as dirname2 } from "path";
+import pc7 from "picocolors";
 function mapTestType(apiType) {
   if (apiType === "performance" || apiType === "k6") return "k6";
   return "playwright";
 }
-function testFileExtension(testType) {
-  return testType === "k6" ? ".k6.ts" : ".pw.ts";
-}
-function testFilename(testId, testType) {
-  const ext = testFileExtension(testType);
-  return `${testId}${ext}`;
-}
 function writeIfChanged(filePath, content) {
-  if (existsSync4(filePath)) {
-    const existing = readFileSync3(filePath, "utf-8");
+  if (existsSync5(filePath)) {
+    const existing = readFileSync5(filePath, "utf-8");
     if (existing === content) return false;
   }
   const dir = dirname2(filePath);
-  if (!existsSync4(dir)) {
+  if (!existsSync5(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
-  writeFileSync3(filePath, content, "utf-8");
+  writeFileSync4(filePath, content, "utf-8");
   return true;
 }
 function decodeScript(script) {
@@ -3310,25 +3957,60 @@ async function fetchStatusPages(client) {
   }
 }
 function pullTests(tests, cwd, summary) {
-  const testsDir = resolve5(cwd, "_supercheck_/tests");
-  if (!existsSync4(testsDir)) {
-    mkdirSync2(testsDir, { recursive: true });
+  const baseDir = resolve9(cwd, "_supercheck_");
+  if (!existsSync5(baseDir)) {
+    mkdirSync2(baseDir, { recursive: true });
+  }
+  const existingByUuid = /* @__PURE__ */ new Map();
+  try {
+    for (const folder of ["playwright", "k6"]) {
+      const folderPath = resolve9(baseDir, folder);
+      if (!existsSync5(folderPath)) continue;
+      for (const file of readdirSync2(folderPath)) {
+        const uuid = extractUuidFromFilename(file);
+        if (uuid) existingByUuid.set(uuid, `${folder}/${file}`);
+      }
+    }
+  } catch {
   }
   for (const test of tests) {
     try {
       const testType = mapTestType(test.type);
-      const filename = testFilename(test.id, testType);
-      const relPath = `_supercheck_/tests/${filename}`;
-      const script = decodeScript(test.script);
+      const relPath = testRelativePath(test.id, test.title, testType);
+      const folderPath = resolve9(baseDir, testTypeToFolder(testType));
+      if (!existsSync5(folderPath)) {
+        mkdirSync2(folderPath, { recursive: true });
+      }
+      let script = decodeScript(test.script);
       if (!script) {
         logger.debug(`Skipping test "${test.title}" \u2014 no script content`);
         summary.skipped++;
         continue;
       }
-      const filePath = resolve5(cwd, relPath);
+      if (/@title\s+/.test(script)) {
+        script = script.replace(/(@title\s+)(.+?)(\r?\n|\*\/|$)/, `$1${test.title}$3`);
+      } else if (/\/\*\*([\s\S]*?)\*\//.test(script)) {
+        script = script.replace(/(\/\*\*)/, `$1
+ * @title ${test.title}`);
+      } else {
+        script = `// @title ${test.title}
+
+${script}`;
+      }
+      const existingFilename = existingByUuid.get(test.id);
+      const currentFile = relPath.replace(/^_supercheck_\//, "");
+      if (existingFilename && existingFilename !== currentFile) {
+        const oldPath = resolve9(baseDir, existingFilename);
+        try {
+          unlinkSync(oldPath);
+          logger.debug(`  Renamed: ${existingFilename} \u2192 ${currentFile}`);
+        } catch {
+        }
+      }
+      const filePath = resolve9(cwd, relPath);
       const written = writeIfChanged(filePath, script);
       if (written) {
-        logger.info(pc6.green(`  + ${relPath}`));
+        logger.info(pc7.green(`  + ${relPath}`));
         summary.tests++;
       } else {
         logger.debug(`  = ${relPath} (unchanged)`);
@@ -3483,10 +4165,10 @@ function generateConfigContent(opts) {
   parts.push("  // Test file patterns \u2014 Playwright (.pw.ts) and k6 (.k6.ts) scripts");
   parts.push("  tests: {");
   parts.push("    playwright: {");
-  parts.push(`      testMatch: '_supercheck_/tests/**/*.pw.ts',`);
+  parts.push(`      testMatch: '_supercheck_/playwright/**/*.pw.ts',`);
   parts.push("    },");
   parts.push("    k6: {");
-  parts.push(`      testMatch: '_supercheck_/tests/**/*.k6.ts',`);
+  parts.push(`      testMatch: '_supercheck_/k6/**/*.k6.ts',`);
   parts.push("    },");
   parts.push("  },");
   if (opts.monitors.length > 0) {
@@ -3529,7 +4211,9 @@ function generateConfigContent(opts) {
   parts.push(" *        npm install -D @supercheck/cli typescript @types/node");
   parts.push(" *        # If using Playwright tests, also install:");
   parts.push(" *        npm install -D @playwright/test");
-  parts.push(" *        # If using k6 tests, install k6: https://grafana.com/docs/k6/latest/set-up/install-k6/");
+  parts.push(" *        # If using k6 tests, also install types and k6 runtime:");
+  parts.push(" *        npm install -D @types/k6");
+  parts.push(" *        # Install k6 runtime: https://grafana.com/docs/k6/latest/set-up/install-k6/");
   parts.push(" *");
   parts.push(" *   2. Review the configuration above and make any changes you need.");
   parts.push(" *   3. Preview what will change:  npx supercheck diff");
@@ -3654,39 +4338,39 @@ var pullCommand = new Command14("pull").description("Pull tests, monitors, jobs,
     logger.header("Resources that would be pulled:");
     logger.newline();
     if (tests.length > 0) {
-      logger.info(pc6.cyan(`  Tests (${tests.length}):`));
+      logger.info(pc7.cyan(`  Tests (${tests.length}):`));
       for (const t of tests) {
         const testType = mapTestType(t.type);
         logger.info(`    ${t.title} (${testType})`);
       }
     }
     if (monitors.length > 0) {
-      logger.info(pc6.cyan(`  Monitors (${monitors.length}):`));
+      logger.info(pc7.cyan(`  Monitors (${monitors.length}):`));
       for (const m of monitors) logger.info(`    ${m.name} (${m.type}, every ${m.frequencyMinutes ?? "?"}min)`);
     }
     if (jobs.length > 0) {
-      logger.info(pc6.cyan(`  Jobs (${jobs.length}):`));
+      logger.info(pc7.cyan(`  Jobs (${jobs.length}):`));
       for (const j of jobs) logger.info(`    ${j.name}${j.cronSchedule ? ` (${j.cronSchedule})` : ""}`);
     }
     if (variables.length > 0) {
-      logger.info(pc6.cyan(`  Variables (${variables.length}):`));
+      logger.info(pc7.cyan(`  Variables (${variables.length}):`));
       for (const v of variables) logger.info(`    ${v.key}${v.isSecret ? " (secret)" : ""}`);
     }
     if (tags.length > 0) {
-      logger.info(pc6.cyan(`  Tags (${tags.length}):`));
+      logger.info(pc7.cyan(`  Tags (${tags.length}):`));
       for (const t of tags) logger.info(`    ${t.name}`);
     }
     if (statusPages.length > 0) {
-      logger.info(pc6.cyan(`  Status Pages (${statusPages.length}):`));
+      logger.info(pc7.cyan(`  Status Pages (${statusPages.length}):`));
       for (const sp of statusPages) logger.info(`    ${sp.name} (${sp.status ?? "draft"})`);
     }
     logger.newline();
-    logger.info(pc6.yellow("Dry run \u2014 no files written."));
+    logger.info(pc7.yellow("Dry run \u2014 no files written."));
     logger.newline();
     return;
   }
   if (!options.force) {
-    logger.info(`Found ${pc6.bold(String(totalResources))} resources to pull.`);
+    logger.info(`Found ${pc7.bold(String(totalResources))} resources to pull.`);
     logger.info("This will write test scripts and update supercheck.config.ts.");
     logger.newline();
     const { confirmPrompt: confirmPrompt2 } = await import("../prompt-BPDPYRS7.js");
@@ -3733,11 +4417,52 @@ var pullCommand = new Command14("pull").description("Pull tests, monitors, jobs,
     pullTests(fullTests, cwd, summary);
     logger.newline();
   }
+  const pkgPath = resolve9(cwd, "package.json");
+  if (!options.dryRun && !existsSync5(pkgPath)) {
+    logger.newline();
+    logger.info("Initializing project dependencies...");
+    const pm = detectPackageManager(cwd);
+    ensurePackageJson(cwd);
+    const packages = ["@supercheck/cli", "typescript", "@types/node"];
+    const hasPlaywright = tests.some((t) => mapTestType(t.type) === "playwright");
+    const hasK6 = tests.some((t) => mapTestType(t.type) === "k6");
+    if (hasPlaywright) packages.push("@playwright/test");
+    if (hasK6) packages.push("@types/k6");
+    await installDependencies(cwd, pm, {
+      packages,
+      skipInstall: false
+    });
+    const tsconfigPath = resolve9(cwd, "tsconfig.supercheck.json");
+    if (!existsSync5(tsconfigPath)) {
+      const tsconfigContent = JSON.stringify({
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          esModuleInterop: true,
+          strict: true,
+          skipLibCheck: true,
+          resolveJsonModule: true,
+          isolatedModules: true,
+          noEmit: true,
+          types: ["node", ...hasK6 ? ["k6"] : []]
+        },
+        include: [
+          "supercheck.config.ts",
+          "supercheck.config.local.ts",
+          "_supercheck_/**/*.ts"
+        ]
+      }, null, 2) + "\n";
+      writeFileSync4(tsconfigPath, tsconfigContent, "utf-8");
+      logger.success("Created tsconfig.supercheck.json (IDE IntelliSense)");
+    }
+    logger.success("Project initialized with dependencies");
+  }
   if (!options.testsOnly) {
     const testMap = /* @__PURE__ */ new Map();
     for (const t of tests) {
       const testType = mapTestType(t.type);
-      const filePath = `_supercheck_/tests/${testFilename(t.id, testType)}`;
+      const filePath = testRelativePath(t.id, t.title, testType);
       testMap.set(t.id, filePath);
     }
     const monitorDefs = buildMonitorDefinitions(monitors);
@@ -3766,15 +4491,15 @@ var pullCommand = new Command14("pull").description("Pull tests, monitors, jobs,
       tags: tagDefs,
       statusPages: statusPageDefs
     });
-    const configPath = resolve5(cwd, "supercheck.config.ts");
+    const configPath = resolve9(cwd, "supercheck.config.ts");
     const configChanged = writeIfChanged(configPath, configContent);
     if (configChanged) {
       logger.header("Config:");
-      if (monitorDefs.length > 0) logger.info(pc6.green(`  + ${monitorDefs.length} monitor(s)`));
-      if (jobDefs.length > 0) logger.info(pc6.green(`  + ${jobDefs.length} job(s)`));
-      if (variableDefs.length > 0) logger.info(pc6.green(`  + ${variableDefs.length} variable(s)`));
-      if (tagDefs.length > 0) logger.info(pc6.green(`  + ${tagDefs.length} tag(s)`));
-      if (statusPageDefs.length > 0) logger.info(pc6.green(`  + ${statusPageDefs.length} status page(s)`));
+      if (monitorDefs.length > 0) logger.info(pc7.green(`  + ${monitorDefs.length} monitor(s)`));
+      if (jobDefs.length > 0) logger.info(pc7.green(`  + ${jobDefs.length} job(s)`));
+      if (variableDefs.length > 0) logger.info(pc7.green(`  + ${variableDefs.length} variable(s)`));
+      if (tagDefs.length > 0) logger.info(pc7.green(`  + ${tagDefs.length} tag(s)`));
+      if (statusPageDefs.length > 0) logger.info(pc7.green(`  + ${statusPageDefs.length} status page(s)`));
       logger.success("Updated supercheck.config.ts");
     } else {
       logger.info("supercheck.config.ts is already up to date");
@@ -3815,9 +4540,53 @@ var pullCommand = new Command14("pull").description("Pull tests, monitors, jobs,
   logger.newline();
 });
 
-// src/commands/notifications.ts
+// src/commands/validate.ts
 import { Command as Command15 } from "commander";
-var notificationCommand = new Command15("notification").alias("notifications").description("Manage notification providers");
+import pc8 from "picocolors";
+var validateCommand = new Command15("validate").description("Validate local test scripts against Supercheck rules").option("--config <path>", "Path to config file").action(async (options) => {
+  const cwd = process.cwd();
+  const { config } = await loadConfig({ cwd, configPath: options.config });
+  const client = createAuthenticatedClient();
+  const localResources = buildLocalResources(config, cwd);
+  const tests = localResources.filter((r) => r.type === "test");
+  if (tests.length === 0) {
+    logger.warn("No local tests found to validate.");
+    return;
+  }
+  const inputs = tests.map((test) => ({
+    name: test.name,
+    script: String(test.definition?.script ?? ""),
+    testType: normalizeTestTypeForApi(test.definition?.testType)
+  }));
+  const results = await withSpinner("Validating test scripts...", async () => {
+    return validateScripts(client, inputs);
+  }, { successText: "Validation complete" });
+  logger.newline();
+  logger.header("Validation Results");
+  logger.newline();
+  let failed = 0;
+  for (const result of results) {
+    if (result.valid) {
+      logger.info(pc8.green(`  \u2713 ${result.name}`));
+      if (result.warnings && result.warnings.length > 0) {
+        logger.info(pc8.yellow(`    Warnings: ${result.warnings.join(", ")}`));
+      }
+    } else {
+      failed++;
+      logger.info(pc8.red(`  \u2717 ${result.name}`));
+      logger.info(pc8.gray(`    ${result.error ?? "Validation failed"}`));
+    }
+  }
+  logger.newline();
+  if (failed > 0) {
+    throw new CLIError(`Validation failed for ${failed} test(s).`, 3 /* ConfigError */);
+  }
+  logger.success("All tests passed validation.");
+});
+
+// src/commands/notifications.ts
+import { Command as Command16 } from "commander";
+var notificationCommand = new Command16("notification").alias("notifications").description("Manage notification providers");
 notificationCommand.command("list").description("List notification providers").action(async () => {
   const client = createAuthenticatedClient();
   const { data } = await withSpinner(
@@ -3949,8 +4718,8 @@ notificationCommand.command("test").description("Send a test notification to ver
 });
 
 // src/commands/alerts.ts
-import { Command as Command16 } from "commander";
-var alertCommand = new Command16("alert").alias("alerts").description("View alert history");
+import { Command as Command17 } from "commander";
+var alertCommand = new Command17("alert").alias("alerts").description("View alert history");
 alertCommand.command("history").description("Get alert history").option("--page <page>", "Page number", "1").option("--limit <limit>", "Number of results per page", "50").action(async (options) => {
   const client = createAuthenticatedClient();
   const { data } = await withSpinner(
@@ -3978,8 +4747,8 @@ Page ${pagination.page}/${pagination.totalPages} (${pagination.total} total)`
 });
 
 // src/commands/audit.ts
-import { Command as Command17 } from "commander";
-var auditCommand = new Command17("audit").description("View audit logs (admin)").option("--page <page>", "Page number", "1").option("--limit <limit>", "Items per page", "20").option("--search <query>", "Search by action").option("--action <action>", "Filter by action type").action(async (options) => {
+import { Command as Command18 } from "commander";
+var auditCommand = new Command18("audit").description("View audit logs (admin)").option("--page <page>", "Page number", "1").option("--limit <limit>", "Items per page", "20").option("--search <query>", "Search by action").option("--action <action>", "Filter by action type").action(async (options) => {
   const client = createAuthenticatedClient();
   const params = {
     page: options.page,
@@ -4017,8 +4786,227 @@ Page ${pagination.currentPage}/${pagination.totalPages} (${pagination.totalCount
   }
 });
 
+// src/commands/doctor.ts
+import { Command as Command19 } from "commander";
+import pc9 from "picocolors";
+var doctorCommand = new Command19("doctor").description("Check that all dependencies and configuration are set up correctly").option("--fix", "Attempt to automatically fix missing dependencies").action(async (options) => {
+  const cwd = process.cwd();
+  const format = getOutputFormat();
+  logger.newline();
+  logger.header("Supercheck Doctor");
+  logger.newline();
+  logger.info(pc9.bold("Dependencies:"));
+  const deps = checkAllDependencies(cwd);
+  if (format === "json") {
+    output(deps, {
+      columns: [
+        { key: "name", header: "Dependency" },
+        { key: "installed", header: "Installed" },
+        { key: "version", header: "Version" },
+        { key: "required", header: "Required" },
+        { key: "installHint", header: "Install" }
+      ]
+    });
+  } else {
+    logger.output(formatDependencyReport(deps));
+  }
+  logger.newline();
+  logger.info(pc9.bold("Authentication:"));
+  const hasAuth = isAuthenticated();
+  if (hasAuth) {
+    const baseUrl = getStoredBaseUrl() ?? "https://app.supercheck.io";
+    logger.output(`  ${pc9.green("\u2713")} Authenticated (${pc9.dim(baseUrl)})`);
+  } else {
+    logger.output(`  ${pc9.yellow("\u25CB")} Not authenticated \u2014 run: supercheck login --token <token>`);
+  }
+  logger.newline();
+  logger.info(pc9.bold("Configuration:"));
+  const configResult = await tryLoadConfig();
+  if (configResult) {
+    logger.output(`  ${pc9.green("\u2713")} supercheck.config.ts found`);
+    const org = configResult.config.project?.organization;
+    const proj = configResult.config.project?.project;
+    if (org && proj) {
+      logger.output(`  ${pc9.green("\u2713")} Project: ${pc9.dim(`${org}/${proj}`)}`);
+    } else {
+      logger.output(`  ${pc9.yellow("\u25CB")} Project org/project not configured in supercheck.config.ts`);
+    }
+  } else {
+    logger.output(`  ${pc9.yellow("\u25CB")} No supercheck.config.ts \u2014 run: supercheck init`);
+  }
+  logger.newline();
+  const missingRequired = deps.filter((d) => !d.installed && d.required);
+  if (options.fix && missingRequired.length > 0) {
+    logger.header("Attempting to fix missing dependencies...");
+    logger.newline();
+    for (const dep of missingRequired) {
+      if (dep.name === "Playwright browsers") {
+        const ok = await installPlaywrightBrowsers(cwd);
+        if (ok) {
+          logger.success("Playwright browsers installed");
+        } else {
+          logger.error(`Failed to install Playwright browsers. Run manually: ${dep.installHint}`);
+        }
+      } else if (dep.name === "@playwright/test") {
+        logger.info(`Install @playwright/test:`);
+        logger.info(`  ${dep.installHint}`);
+      }
+    }
+    logger.newline();
+  }
+  if (missingRequired.length === 0 && hasAuth && configResult) {
+    logger.success("Everything looks good! You're ready to use Supercheck.");
+  } else {
+    const issues = [];
+    if (missingRequired.length > 0) {
+      issues.push(`${missingRequired.length} missing required dependency(s)`);
+    }
+    if (!hasAuth) {
+      issues.push("not authenticated");
+    }
+    if (!configResult) {
+      issues.push("no config file");
+    }
+    logger.warn(`Issues found: ${issues.join(", ")}`);
+    if (!options.fix && missingRequired.length > 0) {
+      logger.info(`Run ${pc9.bold("supercheck doctor --fix")} to attempt automatic fixes.`);
+    }
+  }
+  logger.newline();
+  if (missingRequired.length > 0) {
+    throw new CLIError(
+      `Missing ${missingRequired.length} required dependency(s). Run 'supercheck doctor --fix' or install manually.`,
+      3 /* ConfigError */
+    );
+  }
+});
+
+// src/commands/upgrade.ts
+import { Command as Command20 } from "commander";
+import { spawn as spawn2 } from "child_process";
+var PACKAGE_NAME = "@supercheck/cli";
+var TAG_PATTERN = /^[a-z0-9][a-z0-9._-]*$/i;
+function normalizeTag(tag) {
+  const trimmed = tag.trim();
+  if (trimmed.startsWith("v") && trimmed.length > 1 && /\d/.test(trimmed[1])) {
+    return trimmed.slice(1);
+  }
+  return trimmed;
+}
+function getDefaultTag() {
+  return "latest";
+}
+function detectPackageManager2() {
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.includes("pnpm")) return "pnpm";
+  if (userAgent.includes("yarn")) return "yarn";
+  if (userAgent.includes("bun")) return "bun";
+  return "npm";
+}
+function buildInstallCommand(pm, pkgSpec) {
+  switch (pm) {
+    case "yarn": {
+      const args = ["global", "add", pkgSpec];
+      return { command: "yarn", args, preview: `yarn ${args.join(" ")}` };
+    }
+    case "pnpm": {
+      const args = ["add", "-g", pkgSpec];
+      return { command: "pnpm", args, preview: `pnpm ${args.join(" ")}` };
+    }
+    case "bun": {
+      const args = ["add", "-g", pkgSpec];
+      return { command: "bun", args, preview: `bun ${args.join(" ")}` };
+    }
+    case "npm":
+    default: {
+      const args = ["install", "-g", pkgSpec];
+      return { command: "npm", args, preview: `npm ${args.join(" ")}` };
+    }
+  }
+}
+function runInstallCommand(command, args) {
+  return new Promise((resolve10, reject) => {
+    const child = spawn2(command, args, { stdio: "inherit" });
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => resolve10(code ?? 0));
+  });
+}
+var upgradeCommand = new Command20("upgrade").description("Upgrade the Supercheck CLI to the latest version").option("--tag <tag>", "NPM dist-tag or version (latest, next, canary, 0.1.1-beta.1)").option("--package-manager <pm>", "Package manager to use (npm, yarn, pnpm, bun)").option("-y, --yes", "Skip confirmation prompt").option("--dry-run", "Print the upgrade command without running it").action(async (options) => {
+  const format = getOutputFormat();
+  const tag = normalizeTag(options.tag ?? getDefaultTag());
+  if (!TAG_PATTERN.test(tag)) {
+    throw new CLIError(
+      `Invalid tag "${tag}". Use a valid dist-tag (latest, next, canary) or version (0.1.1-beta.1).`,
+      3 /* ConfigError */
+    );
+  }
+  const pm = options.packageManager ?? detectPackageManager2();
+  if (!["npm", "yarn", "pnpm", "bun"].includes(pm)) {
+    throw new CLIError(
+      `Unsupported package manager "${pm}". Use npm, yarn, pnpm, or bun.`,
+      3 /* ConfigError */
+    );
+  }
+  const pkgSpec = `${PACKAGE_NAME}@${tag}`;
+  const install = buildInstallCommand(pm, pkgSpec);
+  if (options.dryRun) {
+    const payload = {
+      action: "upgrade",
+      package: PACKAGE_NAME,
+      tag,
+      packageManager: pm,
+      command: install.preview,
+      dryRun: true
+    };
+    if (format === "json") {
+      output(payload);
+    } else {
+      logger.info(`Upgrade command: ${install.preview}`);
+    }
+    return;
+  }
+  if (!options.yes) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      throw new CLIError(
+        "Upgrade requires confirmation. Re-run with --yes to skip the prompt.",
+        3 /* ConfigError */
+      );
+    }
+    const confirmed = await confirmPrompt(`Upgrade Supercheck CLI using ${pm}?`, { default: false });
+    if (!confirmed) {
+      logger.info("Upgrade cancelled.");
+      return;
+    }
+  }
+  let code = 0;
+  try {
+    code = await withSpinner(
+      "Upgrading Supercheck CLI...",
+      () => runInstallCommand(install.command, install.args)
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new CLIError(`Failed to run upgrade command: ${message}`, 1 /* GeneralError */);
+  }
+  if (code !== 0) {
+    throw new CLIError(`Upgrade failed with exit code ${code}.`, 1 /* GeneralError */);
+  }
+  if (format === "json") {
+    output({
+      action: "upgrade",
+      package: PACKAGE_NAME,
+      tag,
+      packageManager: pm,
+      command: install.preview,
+      success: true
+    });
+    return;
+  }
+  logger.success(`Supercheck CLI upgraded (${pkgSpec}).`);
+});
+
 // src/bin/supercheck.ts
-var program = new Command18().name("supercheck").description("Open-source testing, monitoring, and reliability \u2014 as code").version(CLI_VERSION, "-v, --version").option("--json", "Output in JSON format").option("--quiet", "Suppress non-essential output").option("--debug", "Enable debug logging").hook("preAction", (_thisCommand, actionCommand) => {
+var program = new Command21().name("supercheck").description("Open-source testing, monitoring, and reliability \u2014 as code").version(CLI_VERSION, "-v, --version").option("--json", "Output in JSON format").option("--quiet", "Suppress non-essential output").option("--debug", "Enable debug logging").hook("preAction", (_thisCommand, actionCommand) => {
   const opts = program.opts();
   if (opts.json) {
     setOutputFormat("json");
@@ -4038,13 +5026,14 @@ program.addCommand(whoamiCommand);
 program.addCommand(initCommand);
 program.addCommand(configCommand);
 program.addCommand(jobCommand);
-program.addCommand(runCommand);
+program.addCommand(runCommand2);
 program.addCommand(testCommand);
 program.addCommand(monitorCommand);
 program.addCommand(varCommand);
 program.addCommand(tagCommand);
 program.addCommand(diffCommand);
 program.addCommand(deployCommand);
+program.addCommand(validateCommand);
 program.addCommand(destroyCommand);
 program.addCommand(pullCommand);
 program.addCommand(notificationCommand);
@@ -4052,14 +5041,42 @@ program.addCommand(alertCommand);
 program.addCommand(auditCommand);
 program.addCommand(healthCommand);
 program.addCommand(locationsCommand);
+program.addCommand(doctorCommand);
+program.addCommand(upgradeCommand);
 program.exitOverride();
 async function main() {
   try {
     await program.parseAsync(process.argv);
   } catch (err) {
+    if (err instanceof ApiRequestError && err.responseBody !== void 0) {
+      const details = (() => {
+        if (typeof err.responseBody === "string") {
+          return err.responseBody.trim() ? `Details: ${err.responseBody}` : "";
+        }
+        if (err.responseBody && typeof err.responseBody === "object") {
+          return `Details: ${JSON.stringify(err.responseBody, null, 2)}`;
+        }
+        return err.responseBody ? `Details: ${String(err.responseBody)}` : "";
+      })();
+      const suffix = details ? `
+${details}
+` : "\n";
+      console.error(pc10.red(`
+\u2717 ${err.message}${suffix}`));
+      process.exit(err.exitCode);
+    }
+    if (err instanceof DependencyError) {
+      console.error(pc10.red(`
+\u2717 Missing dependency: ${err.dependency}`));
+      console.error(pc10.yellow(`
+${err.message}
+`));
+      console.error(pc10.dim("Run `supercheck doctor` for a full dependency check.\n"));
+      process.exit(3 /* ConfigError */);
+    }
     if (err instanceof CLIError) {
       if (err.exitCode !== 0 /* Success */) {
-        console.error(pc7.red(`
+        console.error(pc10.red(`
 \u2717 ${err.message}
 `));
       }
@@ -4068,7 +5085,7 @@ async function main() {
     if (err && typeof err === "object" && "exitCode" in err && typeof err.exitCode === "number") {
       process.exit(err.exitCode);
     }
-    console.error(pc7.red(`
+    console.error(pc10.red(`
 \u2717 Unexpected error: ${err instanceof Error ? err.message : String(err)}
 `));
     process.exit(1 /* GeneralError */);