@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/build-V66FAQXB.js

@@ -0,0 +1,1719 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import './chunk-QDF7QXBL.js';
+import { getSnapshotStateName, isSnapshotComplete } from './chunk-IBVVGH6X.js';
+import { guards, manifestActor, supabaseStartActor, envCheckActor, depsInstallActor, detectTurbo, detectManifestTask, detectDatabase, checkSupabaseStatus } from './chunk-2APB25TT.js';
+import { findRepoRoot } from './chunk-3WDV32GA.js';
+import { runLogged } from './chunk-6FAU4IGR.js';
+import { createMachineStateChangeLogger } from './chunk-5FT3F36G.js';
+import './chunk-II7VYQEM.js';
+import './chunk-VM3IWOT5.js';
+import { securePnpm } from './chunk-RZLYEO4U.js';
+import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
+import './chunk-WJXC4MVY.js';
+import './chunk-HKUWEGUX.js';
+import { init_esm_shims, __require } from './chunk-VRXHCR5K.js';
+import { CLIError, createCLILogger } from '@runa-ai/runa';
+import { Command } from 'commander';
+import { fromPromise, setup, assign, createActor } from 'xstate';
+import { z } from 'zod';
+import { existsSync, rmSync } from 'fs';
+import { mkdir } from 'fs/promises';
+import path5 from 'path';
+import { loadManifestSafe, validateUnifiedManifest, validateTablesManifest } from '@runa-ai/runa/manifests';
+
+createRequire(import.meta.url);
+
+// src/commands/build/index.ts
+init_esm_shims();
+
+// src/commands/build/commands/build.ts
+init_esm_shims();
+
+// src/commands/build/contract.ts
+init_esm_shims();
+var BuildPhaseSchema = z.enum(["types", "lint", "build", "db", "manifest"]);
+var VALID_BUILD_PHASES = ["types", "lint", "build", "db", "manifest"];
+var BuildInputSchema = z.object({
+  /** Enable E2E mode (NEXT_PUBLIC_E2E_TEST=true) */
+  e2e: z.boolean().default(false),
+  /** Clear build caches (.next, .turbo, .runa/manifests) */
+  clean: z.boolean().default(false),
+  /** Full clean + reinstall node_modules */
+  fresh: z.boolean().default(false),
+  /** Skip database sync step */
+  skipDb: z.boolean().default(false),
+  /** Skip manifest generation step */
+  skipManifest: z.boolean().default(false),
+  /** Show detailed output */
+  verbose: z.boolean().default(false),
+  /** Dry-run mode (show what would be done) */
+  check: z.boolean().default(false),
+  /** Skip auto-setup phase (deps install, env check, supabase start) */
+  noSetup: z.boolean().default(false),
+  /** Target directory (defaults to cwd) */
+  targetDir: z.string().optional(),
+  /** Only run specific phases (partial build) */
+  only: z.array(BuildPhaseSchema).optional()
+}).strict();
+var BuildPhaseStatusSchema = z.enum(["pending", "running", "passed", "failed", "skipped"]);
+var BuildPhaseResultSchema = z.object({
+  status: BuildPhaseStatusSchema,
+  durationMs: z.number().int().nonnegative(),
+  error: z.string().optional()
+});
+var BuildOutputSchema = z.object({
+  /** Overall success status */
+  success: z.boolean(),
+  /** Exit code: 0 = success, 1 = failure */
+  exitCode: z.union([z.literal(0), z.literal(1)]),
+  /** Results for each phase */
+  phases: z.object({
+    // Setup phase (auto-detect and fix)
+    depsInstall: BuildPhaseResultSchema.optional(),
+    envCheck: BuildPhaseResultSchema.optional(),
+    supabaseStart: BuildPhaseResultSchema.optional(),
+    // Clean phase
+    clean: BuildPhaseResultSchema.optional(),
+    fresh: BuildPhaseResultSchema.optional(),
+    // Core phases
+    typeCheck: BuildPhaseResultSchema,
+    lint: BuildPhaseResultSchema,
+    build: BuildPhaseResultSchema,
+    dbSync: BuildPhaseResultSchema.optional(),
+    manifest: BuildPhaseResultSchema.optional(),
+    validate: BuildPhaseResultSchema
+  }),
+  /** Total duration in milliseconds */
+  durationMs: z.number().int().nonnegative(),
+  /** Error message if failed */
+  error: z.string().optional(),
+  /** Warning messages (non-blocking issues) */
+  warnings: z.array(z.string()).optional()
+}).strict();
+
+// src/commands/build/machine.ts
+init_esm_shims();
+
+// src/commands/build/actors/index.ts
+init_esm_shims();
+
+// src/commands/build/actors/build.ts
+init_esm_shims();
+var buildActor = fromPromise(
+  async ({ input }) => {
+    const { repoRoot, tmpDir, hasTurbo, e2e, env = process.env } = input;
+    const startTime = Date.now();
+    try {
+      const fullTmpDir = path5.join(repoRoot, tmpDir);
+      await mkdir(fullTmpDir, { recursive: true });
+      const buildEnv = { ...env };
+      if (e2e) {
+        buildEnv.NEXT_PUBLIC_E2E_TEST = "true";
+        buildEnv.E2E_TEST = "true";
+        console.log("  E2E mode enabled: NEXT_PUBLIC_E2E_TEST=true");
+      }
+      const hasApps = existsSync(path5.join(repoRoot, "apps"));
+      let args;
+      if (hasTurbo) {
+        args = hasApps ? ["turbo", "run", "build", "--filter=./apps/*", "--filter=./packages/*"] : ["turbo", "run", "build"];
+      } else {
+        args = ["build"];
+      }
+      await runLogged({
+        cwd: repoRoot,
+        env: buildEnv,
+        label: "build",
+        command: "pnpm",
+        args,
+        logFile: path5.join(fullTmpDir, "build.log")
+      });
+      return {
+        passed: true,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        durationMs: Date.now() - startTime,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+);
+
+// src/commands/build/actors/clean.ts
+init_esm_shims();
+var CLEAN_DIRS = [".next", ".turbo", ".runa/manifests", "dist"];
+var FRESH_DIRS = ["node_modules"];
+function deleteIfExists(fullPath, displayPath, verbose) {
+  if (existsSync(fullPath)) {
+    if (verbose) {
+      console.log(`  Deleting: ${displayPath}`);
+    }
+    rmSync(fullPath, { recursive: true, force: true });
+    return true;
+  }
+  return false;
+}
+function deleteRootDirectories(repoRoot, dirs, verbose) {
+  const deleted = [];
+  for (const dir of dirs) {
+    const fullPath = path5.join(repoRoot, dir);
+    if (deleteIfExists(fullPath, dir, verbose)) {
+      deleted.push(dir);
+    }
+  }
+  return deleted;
+}
+function cleanMonorepoPackages(repoRoot, dirs, verbose) {
+  const deleted = [];
+  const subdirs = ["apps", "packages"];
+  for (const subdir of subdirs) {
+    const subdirPath = path5.join(repoRoot, subdir);
+    if (!existsSync(subdirPath)) continue;
+    const entries = __require("fs").readdirSync(subdirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      for (const dir of dirs) {
+        const targetPath = path5.join(subdirPath, entry.name, dir);
+        const displayPath = `${subdir}/${entry.name}/${dir}`;
+        if (deleteIfExists(targetPath, displayPath, verbose)) {
+          deleted.push(displayPath);
+        }
+      }
+    }
+  }
+  return deleted;
+}
+function deleteDirectories(repoRoot, dirs, verbose) {
+  const rootDeleted = deleteRootDirectories(repoRoot, dirs, verbose);
+  const packageDeleted = cleanMonorepoPackages(repoRoot, dirs, verbose);
+  return [...rootDeleted, ...packageDeleted];
+}
+var cleanActor = fromPromise(
+  async ({ input }) => {
+    const { repoRoot, tmpDir, verbose = false } = input;
+    try {
+      await mkdir(path5.join(repoRoot, tmpDir), { recursive: true });
+      if (verbose) {
+        console.log("Cleaning build caches...");
+      }
+      const deletedPaths = deleteDirectories(repoRoot, CLEAN_DIRS, verbose);
+      return {
+        passed: true,
+        deletedPaths
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        deletedPaths: [],
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+);
+var freshActor = fromPromise(
+  async ({ input }) => {
+    const { repoRoot, tmpDir, verbose = false } = input;
+    try {
+      await mkdir(path5.join(repoRoot, tmpDir), { recursive: true });
+      if (verbose) {
+        console.log("Fresh install: cleaning all caches and node_modules...");
+      }
+      const deletedBuildPaths = deleteDirectories(repoRoot, CLEAN_DIRS, verbose);
+      const deletedNodeModules = deleteDirectories(repoRoot, FRESH_DIRS, verbose);
+      const deletedPaths = [...deletedBuildPaths, ...deletedNodeModules];
+      if (verbose) {
+        console.log("Pruning pnpm store...");
+      }
+      await securePnpm(["store", "prune"], {
+        cwd: repoRoot,
+        stdio: verbose ? "inherit" : "pipe",
+        reject: false
+        // Don't fail if store prune fails
+      });
+      if (verbose) {
+        console.log("Reinstalling dependencies...");
+      }
+      const installResult = await securePnpm(["install"], {
+        cwd: repoRoot,
+        stdio: verbose ? "inherit" : "pipe",
+        reject: false
+      });
+      if (installResult.exitCode !== 0) {
+        const errorMsg = installResult.stderr || installResult.stdout || "pnpm install failed";
+        return {
+          passed: false,
+          deletedPaths,
+          error: `pnpm install failed: ${errorMsg.slice(0, 500)}`
+        };
+      }
+      if (verbose) {
+        console.log("Verifying dependency resolution...");
+      }
+      const lsResult = await securePnpm(["ls", "--depth=0"], {
+        cwd: repoRoot,
+        stdio: "pipe",
+        reject: false
+      });
+      if (lsResult.exitCode !== 0) {
+        return {
+          passed: false,
+          deletedPaths,
+          error: `Dependency verification failed. Some packages may not be explicitly declared in package.json.
+
+Tip: If imports fail after --fresh, add missing dependencies to package.json explicitly.
+
+Common missing deps: @supabase/supabase-js, drizzle-orm, @hono/node-server`
+        };
+      }
+      return {
+        passed: true,
+        deletedPaths
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        deletedPaths: [],
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+);
+
+// src/commands/build/actors/db-sync.ts
+init_esm_shims();
+var DEFAULT_BUILD_DB_SYNC_TIMEOUT_MS = 18e4;
+function resolveBuildDbSyncTimeoutMs(env) {
+  const configured = env.RUNA_BUILD_DB_SYNC_TIMEOUT_MS;
+  if (!configured) return DEFAULT_BUILD_DB_SYNC_TIMEOUT_MS;
+  const parsed = Number.parseInt(configured, 10);
+  if (Number.isNaN(parsed) || parsed <= 0) {
+    return DEFAULT_BUILD_DB_SYNC_TIMEOUT_MS;
+  }
+  return parsed;
+}
+function isTimeoutError(error) {
+  if (error && typeof error === "object") {
+    const maybeTimedOut = error.timedOut;
+    if (maybeTimedOut === true) return true;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  const normalized = message.toLowerCase();
+  return normalized.includes("timed out") || normalized.includes("timeout");
+}
+function buildSupabaseSkipWarning(params) {
+  if (params.conflictingProject) {
+    const portInfo = params.actualPort != null ? ` (port ${params.actualPort})` : "";
+    return `Supabase is not running for this repo${portInfo}: port is used by project '${params.conflictingProject}'. Skipping db sync. Stop the conflicting project or run with '--skip-db'.`;
+  }
+  if (params.portInUse) {
+    const portInfo = params.actualPort != null ? ` (port ${params.actualPort})` : "";
+    return `Supabase is not running for this repo${portInfo}: port is already used by another process. Skipping db sync. Stop the conflicting process or run with '--skip-db'.`;
+  }
+  return "Supabase is not running for this repo. Skipping db sync. Start it with 'supabase start'.";
+}
+function resolveSupabaseSkipWarning(input, repoRoot) {
+  if (input.supabaseRunning === false) {
+    return "Supabase is not running for this repo. Skipping db sync. Start it with 'supabase start'.";
+  }
+  if (input.supabaseRunning === true) {
+    return null;
+  }
+  const supabaseStatus = checkSupabaseStatus(repoRoot);
+  if (supabaseStatus.running) {
+    return null;
+  }
+  return buildSupabaseSkipWarning({
+    portInUse: supabaseStatus.portInUse,
+    actualPort: supabaseStatus.actualPort,
+    conflictingProject: supabaseStatus.conflictingProject
+  });
+}
+function isDatabaseUnavailableError(errorLower) {
+  const isConnectionError = errorLower.includes("econnrefused") || errorLower.includes("connection refused") || errorLower.includes("database system is not accepting connections") || errorLower.includes("could not connect to server") || errorLower.includes("connection timed out") || errorLower.includes("no pg_hba.conf entry");
+  const isMissingEnvVar = errorLower.includes("database_url") && (errorLower.includes("not set") || errorLower.includes("undefined") || errorLower.includes("missing"));
+  const isSupabaseNotRunning = errorLower.includes("supabase is not running") || errorLower.includes("supabase start") || errorLower.includes("supabase db is not running");
+  return isConnectionError || isMissingEnvVar || isSupabaseNotRunning;
+}
+var dbSyncActor = fromPromise(
+  async ({ input }) => {
+    const { repoRoot, tmpDir, env = process.env } = input;
+    const startTime = Date.now();
+    const timeoutMs = resolveBuildDbSyncTimeoutMs(env);
+    try {
+      const supabaseSkipWarning = resolveSupabaseSkipWarning(input, repoRoot);
+      if (supabaseSkipWarning) {
+        return {
+          passed: true,
+          durationMs: Date.now() - startTime,
+          warning: supabaseSkipWarning
+        };
+      }
+      const fullTmpDir = path5.join(repoRoot, tmpDir);
+      await mkdir(fullTmpDir, { recursive: true });
+      await runLogged({
+        cwd: repoRoot,
+        env,
+        label: "db-sync",
+        command: "pnpm",
+        args: ["exec", "runa", "db", "sync", "--auto-approve"],
+        logFile: path5.join(fullTmpDir, "db-sync.log"),
+        timeoutMs
+      });
+      return {
+        passed: true,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorLower = errorMessage.toLowerCase();
+      if (isTimeoutError(error)) {
+        return {
+          passed: true,
+          // Non-blocking - timeout should not block build
+          durationMs: Date.now() - startTime,
+          warning: `Database sync timed out after ${timeoutMs}ms. Skipping db sync. Run 'runa db sync --auto-approve' manually when database is ready.`
+        };
+      }
+      if (isDatabaseUnavailableError(errorLower)) {
+        return {
+          passed: true,
+          // Non-blocking - treat as warning (DB not available is expected in some workflows)
+          durationMs: Date.now() - startTime,
+          warning: "Database not available. Skipping db sync. Run `runa db sync` manually when database is ready."
+        };
+      }
+      return {
+        passed: false,
+        durationMs: Date.now() - startTime,
+        error: errorMessage
+      };
+    }
+  }
+);
+
+// src/commands/build/actors/static-checks.ts
+init_esm_shims();
+function getCommand(hasTurbo, task) {
+  return hasTurbo ? { command: "pnpm", args: ["turbo", "run", task] } : { command: "pnpm", args: [task] };
+}
+function parseCombinedTurboFailure(errorMessage) {
+  const normalized = errorMessage.toLowerCase();
+  const typeCheckFailed = normalized.includes("#type-check") || normalized.includes(" type-check ") || normalized.includes("type-check exited");
+  const lintFailed = normalized.includes("#lint") || normalized.includes(" lint ") || normalized.includes("lint exited");
+  if (!typeCheckFailed && !lintFailed) {
+    return { typeCheckPassed: false, lintPassed: false };
+  }
+  return {
+    typeCheckPassed: !typeCheckFailed,
+    lintPassed: !lintFailed
+  };
+}
+function buildOutput(typeCheckPassed, lintPassed, typeCheckDurationMs, lintDurationMs, errors) {
+  const passed = errors.length === 0;
+  return {
+    passed,
+    typeCheckPassed,
+    lintPassed,
+    typeCheckDurationMs,
+    lintDurationMs,
+    ...passed ? {} : { error: errors.join("; ") }
+  };
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function runTurboStaticChecksIfApplicable(params) {
+  if (!params.hasTurbo || params.skipTypes || params.skipLint) {
+    return null;
+  }
+  try {
+    await runLogged({
+      cwd: params.repoRoot,
+      env: params.env,
+      label: "static-checks",
+      command: "pnpm",
+      args: ["turbo", "run", "type-check", "lint"],
+      logFile: path5.join(params.fullTmpDir, "static-checks.log")
+    });
+    const durationMs = Date.now() - params.startTime;
+    return buildOutput(true, true, durationMs, durationMs, []);
+  } catch (error) {
+    const durationMs = Date.now() - params.startTime;
+    const errorMessage = toErrorMessage(error);
+    const parsed = parseCombinedTurboFailure(errorMessage);
+    return buildOutput(parsed.typeCheckPassed, parsed.lintPassed, durationMs, durationMs, [
+      `Static checks failed: ${errorMessage}`
+    ]);
+  }
+}
+async function runSingleStaticCheck(params) {
+  const cmd = getCommand(params.hasTurbo, params.task);
+  try {
+    await runLogged({
+      cwd: params.repoRoot,
+      env: params.env,
+      label: params.label,
+      command: cmd.command,
+      args: cmd.args,
+      logFile: path5.join(params.fullTmpDir, `${params.label}.log`)
+    });
+    return { passed: true };
+  } catch (error) {
+    return { passed: false, error: toErrorMessage(error) };
+  }
+}
+var staticChecksActor = fromPromise(
+  async ({ input }) => {
+    const { repoRoot, tmpDir, hasTurbo, env = process.env, skipTypes, skipLint } = input;
+    const fullTmpDir = path5.join(repoRoot, tmpDir);
+    await mkdir(fullTmpDir, { recursive: true });
+    const startTime = Date.now();
+    const turboOutput = await runTurboStaticChecksIfApplicable({
+      repoRoot,
+      env,
+      fullTmpDir,
+      startTime,
+      hasTurbo,
+      skipTypes,
+      skipLint
+    });
+    if (turboOutput) {
+      return turboOutput;
+    }
+    let typeCheckPassed = true;
+    let lintPassed = true;
+    const errors = [];
+    if (!skipTypes) {
+      const result = await runSingleStaticCheck({
+        repoRoot,
+        env,
+        fullTmpDir,
+        hasTurbo,
+        task: "type-check",
+        label: "type-check"
+      });
+      if (!result.passed) {
+        typeCheckPassed = false;
+        errors.push(`Type check failed: ${result.error}`);
+      }
+    }
+    if (!skipLint) {
+      const result = await runSingleStaticCheck({
+        repoRoot,
+        env,
+        fullTmpDir,
+        hasTurbo,
+        task: "lint",
+        label: "lint"
+      });
+      if (!result.passed) {
+        lintPassed = false;
+        errors.push(`Lint failed: ${result.error}`);
+      }
+    }
+    const durationMs = Date.now() - startTime;
+    return buildOutput(
+      skipTypes ? true : typeCheckPassed,
+      skipLint ? true : lintPassed,
+      skipTypes ? 0 : durationMs,
+      skipLint ? 0 : durationMs,
+      errors
+    );
+  }
+);
+
+// src/commands/build/actors/validate.ts
+init_esm_shims();
+function appendValidationWarnings(warnings, prefix, validationWarnings) {
+  for (const warning of validationWarnings) {
+    warnings.push(`${prefix}: ${warning.message}`);
+  }
+}
+function hasAnyBuildOutput(repoRoot) {
+  const buildOutputPaths = [
+    path5.join(repoRoot, ".next"),
+    path5.join(repoRoot, "dist"),
+    path5.join(repoRoot, "apps", "web", ".next"),
+    path5.join(repoRoot, "apps", "dashboard", ".next"),
+    path5.join(repoRoot, "packages", "cli", "dist"),
+    path5.join(repoRoot, "packages", "sdk", "dist")
+  ];
+  return buildOutputPaths.some((outputPath) => existsSync(outputPath));
+}
+function applyManifestValidationResult(loadResult, warnings, errors) {
+  if (!loadResult.success) {
+    errors.push(loadResult.error.toUserMessage());
+    return false;
+  }
+  const validation = validateUnifiedManifest(loadResult.manifest);
+  return appendValidationOutcome("manifest.json", validation, warnings, errors);
+}
+function applyTablesValidationResult(loadResult, warnings, errors) {
+  if (!loadResult.success) {
+    errors.push(loadResult.error.toUserMessage());
+    return false;
+  }
+  const validation = validateTablesManifest(loadResult.manifest);
+  return appendValidationOutcome("tables.json", validation, warnings, errors);
+}
+function appendValidationOutcome(label, validation, warnings, errors) {
+  if (!validation.valid) {
+    errors.push(...validation.errors.map((error) => `${label}: ${error.code} - ${error.message}`));
+  }
+  appendValidationWarnings(warnings, label, validation.warnings);
+  return validation.valid;
+}
+var validateActor = fromPromise(
+  async ({ input }) => {
+    const { repoRoot, skipManifest, skipTables } = input;
+    const warnings = [];
+    const buildOutputsExist = hasAnyBuildOutput(repoRoot);
+    let manifestsExist = true;
+    let tablesExist = true;
+    const errors = [];
+    if (!buildOutputsExist) {
+      warnings.push(
+        "No build outputs found. Build may have failed or project structure is non-standard."
+      );
+    }
+    if (!skipManifest) {
+      manifestsExist = applyManifestValidationResult(
+        loadManifestSafe("unified", {
+          cwd: repoRoot,
+          useCache: false
+        }),
+        warnings,
+        errors
+      );
+    }
+    if (!skipTables) {
+      tablesExist = applyTablesValidationResult(
+        loadManifestSafe("tables", {
+          cwd: repoRoot,
+          useCache: false
+        }),
+        warnings,
+        errors
+      );
+    }
+    return {
+      passed: errors.length === 0,
+      checks: {
+        buildOutputs: buildOutputsExist,
+        manifests: manifestsExist,
+        tables: tablesExist
+      },
+      warnings,
+      error: errors.length > 0 ? errors.join("\n") : void 0
+    };
+  }
+);
+
+// src/commands/build/machine-dry-run.ts
+init_esm_shims();
+function getDryRunPhaseStatus(phaseNum, phaseName, config) {
+  if (config.shouldRun) {
+    return `  ${phaseNum}. ${phaseName}`;
+  }
+  return `  ${phaseNum}. ${phaseName}: SKIPPED${config.skipReason ? ` (${config.skipReason})` : ""}`;
+}
+function printStaticAnalysisPhase(shouldRunTypes, shouldRunLint) {
+  if (shouldRunTypes || shouldRunLint) {
+    const checks = [
+      ...shouldRunTypes ? ["type-check"] : [],
+      ...shouldRunLint ? ["lint"] : []
+    ].join(" + ");
+    const parallel = shouldRunTypes && shouldRunLint ? " (parallel)" : "";
+    console.log(`  3. Static Analysis: ${checks}${parallel}`);
+    return;
+  }
+  console.log("  3. Static Analysis: SKIPPED (--only)");
+}
+function printDbSyncPhase(context, shouldRunDb) {
+  if (context.hasDatabase && !context.input.skipDb && shouldRunDb) {
+    console.log("  5. DB Sync: runa db sync");
+    return;
+  }
+  if (shouldRunDb && !context.hasDatabase) {
+    console.log("  5. DB Sync: SKIPPED (no database configured)");
+    return;
+  }
+  console.log("  5. DB Sync: SKIPPED (--only)");
+}
+function printManifestPhase(context, shouldRunManifest) {
+  if (context.hasManifestTask && !context.input.skipManifest && shouldRunManifest) {
+    console.log("  6. Manifest: runa manifest (bundler-independent)");
+    return;
+  }
+  if (shouldRunManifest && !context.hasManifestTask) {
+    console.log("  6. Manifest: SKIPPED (no manifest task)");
+    return;
+  }
+  console.log("  6. Manifest: SKIPPED (--only)");
+}
+function printDryRunPhases(context) {
+  const only = context.input.only;
+  const hasOnly = only && only.length > 0;
+  const shouldRunTypes = !hasOnly || only.includes("types");
+  const shouldRunLint = !hasOnly || only.includes("lint");
+  const shouldRunBuild = !hasOnly || only.includes("build");
+  const shouldRunDb = !hasOnly || only.includes("db");
+  const shouldRunManifest = !hasOnly || only.includes("manifest");
+  if (!context.input.noSetup) {
+    console.log("  0. Auto-Setup: Check deps, env, Supabase");
+  }
+  if (context.input.clean || context.input.fresh) {
+    console.log("  1. Clean: Delete .next, .turbo, .runa/manifests");
+  }
+  if (context.input.fresh) {
+    console.log("  2. Fresh: Delete node_modules + pnpm install");
+  }
+  printStaticAnalysisPhase(shouldRunTypes, shouldRunLint);
+  console.log(
+    getDryRunPhaseStatus(4, "Build: turbo build", {
+      shouldRun: shouldRunBuild,
+      skipReason: "--only"
+    })
+  );
+  printDbSyncPhase(context, shouldRunDb);
+  printManifestPhase(context, shouldRunManifest);
+  console.log("  7. Validate: Check build outputs");
+}
+function printDryRunConfig(context) {
+  const only = context.input.only;
+  const hasOnly = only && only.length > 0;
+  console.log("\nConfiguration:");
+  console.log(`  E2E mode: ${context.input.e2e}`);
+  console.log(`  Auto-setup: ${!context.input.noSetup}`);
+  console.log(`  Has database: ${context.hasDatabase}`);
+  console.log(`  Has manifest task: ${context.hasManifestTask}`);
+  console.log(`  Has turbo: ${context.hasTurbo}`);
+  if (hasOnly) {
+    console.log(`  Only phases: ${only.join(", ")}`);
+  }
+}
+function printBuildDryRunPlan(context) {
+  const only = context.input.only;
+  const hasOnly = only && only.length > 0;
+  console.log("\n\u{1F4CB} Dry-run mode: showing what would be done\n");
+  if (hasOnly) {
+    console.log(`Partial build: only ${only.join(", ")}
+`);
+  }
+  console.log("Phases to execute:");
+  printDryRunPhases(context);
+  printDryRunConfig(context);
+}
+
+// src/commands/build/machine-e2e-meta.ts
+init_esm_shims();
+var buildMachineE2EMeta = {
+  idle: {
+    description: "Waiting for START event to begin build workflow",
+    severity: "non-critical",
+    observables: { log: "Starting build" },
+    assertions: ["expect(state).toBe('idle')"],
+    nextStates: ["setup", "preClean", "dryRun"]
+  },
+  dryRun: {
+    description: "Show what would be done without executing (--check)",
+    severity: "non-critical",
+    observables: { log: "Dry-run mode: showing what would be done" },
+    assertions: ["expect(log).toContain('Dry-run')"],
+    nextStates: ["done"]
+  },
+  setup: {
+    description: "Auto-detect and fix prerequisites (deps, env, Supabase)",
+    severity: "blocking",
+    observables: {
+      log: "Auto-Setup: Check deps, env, Supabase",
+      fs: "node_modules installed if needed"
+    },
+    assertions: ["expect(log).toContain('Auto-Setup')"],
+    nextStates: ["preClean", "failed"]
+  },
+  clean: {
+    description: "Delete build caches (.next, .turbo, .runa/manifests)",
+    severity: "non-critical",
+    observables: {
+      log: "Cleaning build caches",
+      fs: "Deleted .next, .turbo, .runa/manifests"
+    },
+    assertions: ["expect(log).toContain('Cleaning')"],
+    nextStates: ["staticAnalysis"]
+  },
+  fresh: {
+    description: "Full clean + reinstall node_modules (--fresh)",
+    severity: "blocking",
+    observables: {
+      log: "Fresh install: deleting node_modules",
+      fs: "node_modules deleted and reinstalled"
+    },
+    assertions: ["expect(log).toContain('Fresh install')"],
+    nextStates: ["staticAnalysis", "failed"]
+  },
+  staticAnalysis: {
+    description: "Run type-check + lint in parallel",
+    severity: "blocking",
+    observables: {
+      log: "Running type-check and lint",
+      exitCode: "pnpm turbo type-check lint"
+    },
+    assertions: ["expect(log).toContain('type-check')", "expect(log).toContain('lint')"],
+    nextStates: ["build", "dbSync", "failed"]
+  },
+  build: {
+    description: "Run turbo build (or pnpm build if no turbo)",
+    severity: "blocking",
+    observables: {
+      log: "Building project",
+      fs: ".next/build-manifest.json created"
+    },
+    assertions: ["expect(log).toContain('build')"],
+    nextStates: ["dbSync", "failed"]
+  },
+  dbSync: {
+    description: "Sync database schema (if database exists)",
+    severity: "non-critical",
+    observables: {
+      log: "Syncing database schema",
+      db: "Schema applied via pg-schema-diff"
+    },
+    assertions: ["expect(log).toContain('db-sync').or.toContain('SKIPPED')"],
+    nextStates: ["manifest"]
+  },
+  manifest: {
+    description: "Generate XState manifests (if manifest task exists)",
+    severity: "non-critical",
+    observables: {
+      log: "Generating manifests",
+      fs: ".runa/manifests/manifest.json created"
+    },
+    assertions: ["expect(log).toContain('manifest').or.toContain('SKIPPED')"],
+    nextStates: ["validate"]
+  },
+  validate: {
+    description: "Validate build outputs (.next, manifests)",
+    severity: "non-critical",
+    observables: { log: "Validating build outputs" },
+    assertions: ["expect(log).toContain('Validating')"],
+    nextStates: ["done"]
+  },
+  done: {
+    description: "Build completed successfully",
+    severity: "final",
+    observables: { log: "Build complete", exitCode: 0 },
+    assertions: ["expect(exitCode).toBe(0)", "expect(log).toContain('Build complete')"],
+    nextStates: []
+  },
+  failed: {
+    description: "Build failed with error",
+    severity: "final",
+    observables: { log: "Build failed", exitCode: 1 },
+    assertions: ["expect(exitCode).toBe(1)", "expect(log).toContain('Build failed')"],
+    nextStates: []
+  }
+};
+
+// src/commands/build/types.ts
+init_esm_shims();
+function hasBlockingFailure(context) {
+  const blockingPhases = ["depsInstall", "typeCheck", "lint", "build"];
+  return blockingPhases.some((phase) => context.phases[phase]?.status === "failed");
+}
+function toOutputPhases(context) {
+  return {
+    depsInstall: context.phases.depsInstall ?? void 0,
+    envCheck: context.phases.envCheck ?? void 0,
+    supabaseStart: context.phases.supabaseStart ?? void 0,
+    clean: context.phases.clean ?? void 0,
+    fresh: context.phases.fresh ?? void 0,
+    typeCheck: context.phases.typeCheck ?? { status: "skipped", durationMs: 0 },
+    lint: context.phases.lint ?? { status: "skipped", durationMs: 0 },
+    build: context.phases.build ?? { status: "skipped", durationMs: 0 },
+    dbSync: context.phases.dbSync ?? void 0,
+    manifest: context.phases.manifest ?? void 0,
+    validate: context.phases.validate ?? { status: "skipped", durationMs: 0 }
+  };
+}
+function resolveWarnings(warnings) {
+  return warnings.length > 0 ? warnings : void 0;
+}
+function createOutput(context) {
+  const durationMs = Date.now() - context.startTime;
+  const blockingFailure = hasBlockingFailure(context);
+  const hasFatalError = Boolean(context.error);
+  return {
+    success: !hasFatalError && !blockingFailure,
+    exitCode: hasFatalError || blockingFailure ? 1 : 0,
+    phases: toOutputPhases(context),
+    durationMs,
+    error: context.error ?? void 0,
+    warnings: resolveWarnings(context.warnings)
+  };
+}
+function createPhaseResult(status, durationMs, error) {
+  return { status, durationMs, error };
+}
+
+// src/commands/build/machine.ts
+function normalizeBuildMachineInput(input) {
+  const normalizedInput = BuildInputSchema.parse(input?.input ?? {});
+  const repoRoot = input?.repoRoot ?? normalizedInput.targetDir ?? process.cwd();
+  return {
+    input: normalizedInput,
+    repoRoot
+  };
+}
+var buildMachine = setup({
+  types: {},
+  actors: {
+    // Setup actors
+    depsInstall: depsInstallActor,
+    envCheck: envCheckActor,
+    supabaseStart: supabaseStartActor,
+    // Clean actors
+    clean: cleanActor,
+    fresh: freshActor,
+    // Core build actors
+    staticChecks: staticChecksActor,
+    build: buildActor,
+    dbSync: dbSyncActor,
+    manifest: manifestActor,
+    validate: validateActor
+  },
+  guards: {
+    shouldClean: guards.shouldClean,
+    shouldFresh: guards.shouldFresh,
+    shouldSkipTypes: guards.shouldSkipTypes,
+    shouldSkipLint: guards.shouldSkipLint,
+    shouldSkipBuild: guards.shouldSkipBuild,
+    shouldSkipStaticAnalysis: guards.shouldSkipStaticAnalysis,
+    shouldSkipDb: guards.shouldSkipDb,
+    shouldSkipManifest: guards.shouldSkipManifest,
+    shouldSkipSetup: guards.shouldSkipSetup,
+    isDryRun: guards.isDryRun
+  }
+}).createMachine({
+  id: "build",
+  initial: "idle",
+  context: ({ input }) => {
+    const normalizedInput = normalizeBuildMachineInput(input);
+    const repoRoot = normalizedInput.repoRoot;
+    return {
+      input: normalizedInput.input,
+      repoRoot,
+      tmpDir: ".runa/tmp/build",
+      hasDatabase: detectDatabase(repoRoot),
+      hasManifestTask: detectManifestTask(repoRoot),
+      hasTurbo: detectTurbo(repoRoot),
+      supabaseRunning: false,
+      phases: {
+        // Setup phase
+        depsInstall: null,
+        envCheck: null,
+        supabaseStart: null,
+        // Clean phase
+        clean: null,
+        fresh: null,
+        // Core phases
+        typeCheck: null,
+        lint: null,
+        build: null,
+        dbSync: null,
+        manifest: null,
+        validate: null
+      },
+      startTime: Date.now(),
+      error: null,
+      warnings: []
+    };
+  },
+  states: {
+    // ============================================================
+    // Idle State
+    // ============================================================
+    idle: {
+      meta: { e2e: buildMachineE2EMeta.idle },
+      on: {
+        START: [
+          // Dry-run mode: show what would be done
+          { guard: "isDryRun", target: "dryRun" },
+          // Skip setup if --no-setup
+          { guard: "shouldSkipSetup", target: "preClean" },
+          // Normal: go to setup first
+          { target: "setup" }
+        ]
+      }
+    },
+    // ============================================================
+    // Dry-run State
+    // ============================================================
+    dryRun: {
+      meta: { e2e: buildMachineE2EMeta.dryRun },
+      entry: ({ context }) => printBuildDryRunPlan(context),
+      always: { target: "done" }
+    },
+    // ============================================================
+    // Setup Phase (Auto-detect and fix prerequisites)
+    // ============================================================
+    setup: {
+      meta: { e2e: buildMachineE2EMeta.setup },
+      initial: "depsInstall",
+      states: {
+        depsInstall: {
+          invoke: {
+            src: "depsInstall",
+            input: ({ context }) => ({
+              repoRoot: context.repoRoot,
+              verbose: context.input.verbose
+            }),
+            onDone: {
+              target: "envCheck",
+              actions: assign({
+                phases: ({ context, event }) => ({
+                  ...context.phases,
+                  depsInstall: event.output.needed ? createPhaseResult(
+                    event.output.installed ? "passed" : "failed",
+                    event.output.durationMs,
+                    event.output.error
+                  ) : createPhaseResult("skipped", event.output.durationMs)
+                })
+              })
+            },
+            onError: {
+              target: "#build.failed",
+              // Blocking - can't build without deps
+              actions: assign({
+                error: ({ event }) => `Dependencies install failed: ${event.error instanceof Error ? event.error.message : String(event.error)}`,
+                phases: ({ context, event }) => ({
+                  ...context.phases,
+                  depsInstall: createPhaseResult(
+                    "failed",
+                    0,
+                    event.error instanceof Error ? event.error.message : String(event.error)
+                  )
+                })
+              })
+            }
+          }
+        },
+        envCheck: {
+          invoke: {
+            src: "envCheck",
+            input: ({ context }) => ({
+              repoRoot: context.repoRoot,
+              verbose: context.input.verbose
+            }),
+            onDone: {
+              target: "supabaseStart",
+              actions: assign({
+                phases: ({ context, event }) => ({
+                  ...context.phases,
+                  envCheck: createPhaseResult(event.output.configured ? "passed" : "skipped", 0)
+                }),
+                warnings: ({ context, event }) => event.output.warning ? [...context.warnings, event.output.warning] : context.warnings
+              })
+            },
+            onError: {
+              target: "supabaseStart",
+              // Non-blocking
+              actions: assign({
+                phases: ({ context }) => ({
+                  ...context.phases,
+                  envCheck: createPhaseResult("skipped", 0)
+                })
+              })
+            }
+          }
+        },
+        supabaseStart: {
+          invoke: {
+            src: "supabaseStart",
+            input: ({ context }) => ({
+              repoRoot: context.repoRoot,
+              verbose: context.input.verbose
+            }),
+            onDone: {
+              target: "done",
+              actions: assign({
+                phases: ({ context, event }) => ({
+                  ...context.phases,
+                  supabaseStart: event.output.needed ? createPhaseResult(
+                    event.output.started || event.output.alreadyRunning ? "passed" : "skipped",
+                    0
+                  ) : createPhaseResult("skipped", 0)
+                }),
+                supabaseRunning: ({ event }) => event.output.started || event.output.alreadyRunning,
+                warnings: ({ context, event }) => event.output.warning ? [...context.warnings, event.output.warning] : context.warnings
+              })
+            },
+            onError: {
+              target: "done",
+              // Non-blocking
+              actions: assign({
+                phases: ({ context, event }) => ({
+                  ...context.phases,
+                  supabaseStart: createPhaseResult(
+                    "skipped",
+                    0,
+                    event.error instanceof Error ? event.error.message : String(event.error)
+                  )
+                }),
+                warnings: ({ context, event }) => [
+                  ...context.warnings,
+                  `Supabase start skipped: ${event.error instanceof Error ? event.error.message : String(event.error)}`
+                ]
+              })
+            }
+          }
+        },
+        done: {
+          type: "final"
+        }
+      },
+      onDone: { target: "preClean" }
+    },
+    // ============================================================
+    // Pre-Clean Decision State
+    // ============================================================
+    preClean: {
+      always: [
+        { guard: "shouldFresh", target: "fresh" },
+        { guard: "shouldClean", target: "clean" },
+        // Skip static analysis if --only doesn't include 'types' or 'lint'
+        // If build is also skipped by --only, jump directly to dbSync.
+        {
+          guard: ({ context }) => guards.shouldSkipStaticAnalysis({ context }) && guards.shouldSkipBuild({ context }),
+          target: "dbSync"
+        },
+        { guard: "shouldSkipStaticAnalysis", target: "build" },
+        { target: "staticAnalysis" }
+      ]
+    },
+    // ============================================================
+    // Clean Phase
+    // ============================================================
+    clean: {
+      meta: { e2e: buildMachineE2EMeta.clean },
+      invoke: {
+        src: "clean",
+        input: ({ context }) => ({
+          repoRoot: context.repoRoot,
+          tmpDir: context.tmpDir,
+          verbose: context.input.verbose
+        }),
+        onDone: {
+          target: "staticAnalysis",
+          actions: assign({
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              clean: createPhaseResult(
+                event.output.passed ? "passed" : "failed",
+                0,
+                event.output.error
+              )
+            }),
+            warnings: ({ context, event }) => event.output.error ? [...context.warnings, `Clean warning: ${event.output.error}`] : context.warnings
+          })
+        },
+        onError: {
+          target: "staticAnalysis",
+          // Non-blocking
+          actions: assign({
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              clean: createPhaseResult(
+                "failed",
+                0,
+                event.error instanceof Error ? event.error.message : String(event.error)
+              )
+            }),
+            warnings: ({ context, event }) => [
+              ...context.warnings,
+              `Clean failed: ${event.error instanceof Error ? event.error.message : String(event.error)}`
+            ]
+          })
+        }
+      }
+    },
+    // ============================================================
+    // Fresh Phase
+    // ============================================================
+    fresh: {
+      meta: { e2e: buildMachineE2EMeta.fresh },
+      invoke: {
+        src: "fresh",
+        input: ({ context }) => ({
+          repoRoot: context.repoRoot,
+          tmpDir: context.tmpDir,
+          verbose: context.input.verbose
+        }),
+        onDone: {
+          target: "staticAnalysis",
+          actions: assign({
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              fresh: createPhaseResult(
+                event.output.passed ? "passed" : "failed",
+                0,
+                event.output.error
+              )
+            })
+          })
+        },
+        onError: {
+          target: "failed",
+          // Blocking
+          actions: assign({
+            error: ({ event }) => `Fresh install failed: ${event.error instanceof Error ? event.error.message : String(event.error)}`,
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              fresh: createPhaseResult(
+                "failed",
+                0,
+                event.error instanceof Error ? event.error.message : String(event.error)
+              )
+            })
+          })
+        }
+      }
+    },
+    // ============================================================
+    // Static Analysis Phase
+    // ============================================================
+    staticAnalysis: {
+      meta: { e2e: buildMachineE2EMeta.staticAnalysis },
+      invoke: {
+        src: "staticChecks",
+        input: ({ context }) => ({
+          repoRoot: context.repoRoot,
+          tmpDir: context.tmpDir,
+          hasTurbo: context.hasTurbo,
+          // Pass skip flags for --only option
+          skipTypes: guards.shouldSkipTypes({ context }),
+          skipLint: guards.shouldSkipLint({ context })
+        }),
+        onDone: [
+          {
+            guard: ({ event }) => !event.output.passed,
+            target: "failed",
+            actions: assign({
+              error: ({ event }) => event.output.error ?? "Static analysis failed",
+              phases: ({ context, event }) => ({
+                ...context.phases,
+                typeCheck: createPhaseResult(
+                  event.output.typeCheckPassed ? "passed" : "failed",
+                  event.output.typeCheckDurationMs ?? 0
+                ),
+                lint: createPhaseResult(
+                  event.output.lintPassed ? "passed" : "failed",
+                  event.output.lintDurationMs ?? 0
+                )
+              })
+            })
+          },
+          // Skip build if --only doesn't include 'build'
+          {
+            guard: "shouldSkipBuild",
+            target: "dbSync",
+            actions: assign({
+              phases: ({ context, event }) => ({
+                ...context.phases,
+                typeCheck: createPhaseResult(
+                  guards.shouldSkipTypes({ context }) ? "skipped" : "passed",
+                  event.output.typeCheckDurationMs ?? 0
+                ),
+                lint: createPhaseResult(
+                  guards.shouldSkipLint({ context }) ? "skipped" : "passed",
+                  event.output.lintDurationMs ?? 0
+                ),
+                build: createPhaseResult("skipped", 0)
+              })
+            })
+          },
+          {
+            target: "build",
+            actions: assign({
+              phases: ({ context, event }) => ({
+                ...context.phases,
+                typeCheck: createPhaseResult(
+                  guards.shouldSkipTypes({ context }) ? "skipped" : "passed",
+                  event.output.typeCheckDurationMs ?? 0
+                ),
+                lint: createPhaseResult(
+                  guards.shouldSkipLint({ context }) ? "skipped" : "passed",
+                  event.output.lintDurationMs ?? 0
+                )
+              })
+            })
+          }
+        ],
+        onError: {
+          target: "failed",
+          actions: assign({
+            error: ({ event }) => `Static analysis failed: ${event.error instanceof Error ? event.error.message : String(event.error)}`,
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              typeCheck: createPhaseResult(
+                "failed",
+                0,
+                event.error instanceof Error ? event.error.message : String(event.error)
+              ),
+              lint: createPhaseResult("skipped", 0)
+            })
+          })
+        }
+      }
+    },
+    // ============================================================
+    // Build Phase
+    // ============================================================
+    build: {
+      meta: { e2e: buildMachineE2EMeta.build },
+      invoke: {
+        src: "build",
+        input: ({ context }) => ({
+          repoRoot: context.repoRoot,
+          tmpDir: context.tmpDir,
+          hasTurbo: context.hasTurbo,
+          e2e: context.input.e2e
+        }),
+        onDone: [
+          {
+            guard: ({ event }) => !event.output.passed,
+            target: "failed",
+            actions: assign({
+              error: ({ event }) => event.output.error ?? "Build failed",
+              phases: ({ context, event }) => ({
+                ...context.phases,
+                build: createPhaseResult("failed", event.output.durationMs, event.output.error)
+              })
+            })
+          },
+          {
+            target: "dbSync",
+            actions: assign({
+              phases: ({ context, event }) => ({
+                ...context.phases,
+                build: createPhaseResult("passed", event.output.durationMs)
+              })
+            })
+          }
+        ],
+        onError: {
+          target: "failed",
+          actions: assign({
+            error: ({ event }) => `Build failed: ${event.error instanceof Error ? event.error.message : String(event.error)}`,
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              build: createPhaseResult(
+                "failed",
+                0,
+                event.error instanceof Error ? event.error.message : String(event.error)
+              )
+            })
+          })
+        }
+      }
+    },
+    // ============================================================
+    // DB Sync Phase
+    // ============================================================
+    dbSync: {
+      meta: { e2e: buildMachineE2EMeta.dbSync },
+      always: [{ guard: "shouldSkipDb", target: "manifest" }],
+      invoke: {
+        src: "dbSync",
+        input: ({ context }) => ({
+          repoRoot: context.repoRoot,
+          tmpDir: context.tmpDir,
+          supabaseRunning: context.supabaseRunning
+        }),
+        onDone: {
+          target: "manifest",
+          actions: assign({
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              dbSync: createPhaseResult(
+                event.output.passed ? "passed" : "failed",
+                event.output.durationMs,
+                event.output.error
+              )
+            }),
+            warnings: ({ context, event }) => {
+              const newWarnings = [...context.warnings];
+              if (event.output.warning) {
+                const normalizedWarning = event.output.warning.toLowerCase();
+                const hasSupabaseSetupWarning = context.warnings.some(
+                  (warning) => warning.toLowerCase().includes("supabase start skipped")
+                );
+                const isSupabaseNotRunningWarning = normalizedWarning.includes(
+                  "supabase is not running for this repo"
+                );
+                const shouldSkipSupabaseDuplicate = hasSupabaseSetupWarning && isSupabaseNotRunningWarning;
+                if (!shouldSkipSupabaseDuplicate && !newWarnings.includes(event.output.warning)) {
+                  newWarnings.push(event.output.warning);
+                }
+              }
+              if (!event.output.passed && event.output.error) {
+                const dbSyncErrorWarning = `DB sync failed: ${event.output.error}`;
+                if (!newWarnings.includes(dbSyncErrorWarning)) {
+                  newWarnings.push(dbSyncErrorWarning);
+                }
+              }
+              return newWarnings;
+            }
+          })
+        },
+        onError: {
+          target: "manifest",
+          // Non-blocking
+          actions: assign({
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              dbSync: createPhaseResult(
+                "failed",
+                0,
+                event.error instanceof Error ? event.error.message : String(event.error)
+              )
+            }),
+            warnings: ({ context, event }) => [
+              ...context.warnings,
+              `DB sync failed: ${event.error instanceof Error ? event.error.message : String(event.error)}`
+            ]
+          })
+        }
+      }
+    },
+    // ============================================================
+    // Manifest Phase
+    // ============================================================
+    manifest: {
+      meta: { e2e: buildMachineE2EMeta.manifest },
+      always: [{ guard: "shouldSkipManifest", target: "validate" }],
+      invoke: {
+        src: "manifest",
+        input: ({ context }) => ({
+          repoRoot: context.repoRoot,
+          tmpDir: context.tmpDir
+        }),
+        onDone: {
+          target: "validate",
+          actions: assign({
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              manifest: createPhaseResult(
+                event.output.passed ? "passed" : "failed",
+                event.output.durationMs,
+                event.output.error
+              )
+            }),
+            error: ({ context, event }) => !event.output.passed ? event.output.error ?? context.error : context.error,
+            warnings: ({ context, event }) => event.output.warning ? [...context.warnings, event.output.warning] : context.warnings
+          })
+        },
+        onError: {
+          target: "validate",
+          // Non-blocking
+          actions: assign({
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              manifest: createPhaseResult(
+                "failed",
+                0,
+                event.error instanceof Error ? event.error.message : String(event.error)
+              )
+            }),
+            warnings: ({ context, event }) => [
+              ...context.warnings,
+              `Manifest generation failed: ${event.error instanceof Error ? event.error.message : String(event.error)}`
+            ]
+          })
+        }
+      }
+    },
+    // ============================================================
+    // Validate Phase
+    // ============================================================
+    validate: {
+      meta: { e2e: buildMachineE2EMeta.validate },
+      invoke: {
+        src: "validate",
+        input: ({ context }) => ({
+          repoRoot: context.repoRoot,
+          skipManifest: context.input.skipManifest || !context.hasManifestTask,
+          skipTables: context.input.skipDb || !context.hasDatabase
+        }),
+        onDone: {
+          target: "done",
+          actions: assign({
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              validate: createPhaseResult(
+                event.output.passed ? "passed" : "failed",
+                0,
+                event.output.error
+              )
+            }),
+            error: ({ context, event }) => !event.output.passed ? event.output.error ?? context.error : context.error,
+            warnings: ({ context, event }) => [...context.warnings, ...event.output.warnings]
+          })
+        },
+        onError: {
+          target: "done",
+          // Non-blocking
+          actions: assign({
+            phases: ({ context, event }) => ({
+              ...context.phases,
+              validate: createPhaseResult(
+                "failed",
+                0,
+                event.error instanceof Error ? event.error.message : String(event.error)
+              )
+            }),
+            warnings: ({ context, event }) => [
+              ...context.warnings,
+              `Validation failed: ${event.error instanceof Error ? event.error.message : String(event.error)}`
+            ]
+          })
+        }
+      }
+    },
+    // ============================================================
+    // Final States
+    // ============================================================
+    done: {
+      meta: { e2e: buildMachineE2EMeta.done },
+      type: "final"
+    },
+    failed: {
+      meta: { e2e: buildMachineE2EMeta.failed },
+      type: "final"
+    }
+  },
+  output: ({ context }) => createOutput(context)
+});
+function getStateName(snapshot) {
+  return getSnapshotStateName(snapshot);
+}
+function isComplete(snapshot) {
+  return isSnapshotComplete(snapshot);
+}
+
+// src/commands/build/commands/build.ts
+function parseOnlyOption(only) {
+  if (!only) return void 0;
+  const phases = only.split(",").map((p) => p.trim().toLowerCase());
+  const valid = [];
+  const invalid = [];
+  for (const phase of phases) {
+    if (VALID_BUILD_PHASES.includes(phase)) {
+      valid.push(phase);
+    } else {
+      invalid.push(phase);
+    }
+  }
+  if (invalid.length > 0) {
+    throw new CLIError(`Invalid phases: ${invalid.join(", ")}`, "INVALID_PHASES", [
+      `Valid phases: ${VALID_BUILD_PHASES.join(", ")}`
+    ]);
+  }
+  return valid.length > 0 ? valid : void 0;
+}
+var handleStateChange = createMachineStateChangeLogger({
+  getState: getStateName,
+  getContext: (snapshot) => snapshot.context,
+  handlers: {
+    idle: (logger) => {
+      logger.section("Build");
+      logger.info("Starting smart build...");
+    },
+    dryRun: (_logger) => {
+    },
+    setup: (logger) => {
+      logger.section("Phase 0: Auto-Setup");
+      logger.info("Checking environment prerequisites...");
+    },
+    "setup.depsInstall": (logger) => {
+      logger.info("  Checking dependencies...");
+    },
+    "setup.envCheck": (logger) => {
+      logger.info("  Checking environment variables...");
+    },
+    "setup.supabaseStart": (logger) => {
+      logger.info("  Checking Supabase...");
+    },
+    preClean: (_logger) => {
+    },
+    clean: (logger) => {
+      logger.section("Phase 1: Clean");
+      logger.info("Cleaning build caches...");
+    },
+    fresh: (logger) => {
+      logger.section("Phase 1: Fresh Install");
+      logger.info("Cleaning all caches and reinstalling dependencies...");
+    },
+    staticAnalysis: (logger) => {
+      logger.section("Phase 2: Static Analysis");
+      logger.info("Running type-check and lint in parallel...");
+    },
+    build: (logger) => {
+      logger.section("Phase 3: Build");
+      logger.info("Building project...");
+    },
+    dbSync: (logger) => {
+      logger.section("Phase 4: Database Sync");
+      logger.info("Syncing database schema and generating types...");
+    },
+    manifest: (logger) => {
+      logger.section("Phase 5: Manifest Generation");
+      logger.info("Generating manifests for E2E tests...");
+    },
+    validate: (logger) => {
+      logger.section("Phase 6: Validation");
+      logger.info("Validating build outputs...");
+    }
+  },
+  useParentState: true
+});
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  if (minutes > 0) {
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+  }
+  return `${seconds}s`;
+}
+function getPhaseIcon(status) {
+  if (status === "passed") return "\u2705";
+  if (status === "failed") return "\u274C";
+  return "\u23ED\uFE0F";
+}
+function printPhaseResults(logger, phases) {
+  for (const { name, result } of phases) {
+    if (!result) continue;
+    const icon = getPhaseIcon(result.status);
+    const duration = result.durationMs > 0 ? ` (${formatDuration(result.durationMs)})` : "";
+    logger.info(`  ${name}: ${icon} ${result.status.toUpperCase()}${duration}`);
+  }
+}
+function printWarnings(logger, warnings) {
+  if (!warnings || warnings.length === 0) return;
+  logger.info("");
+  logger.warn("Warnings:");
+  for (const warning of warnings) {
+    logger.warn(`  \u26A0\uFE0F ${warning}`);
+  }
+}
+function printSummary(logger, output) {
+  logger.section("Summary");
+  const phases = [
+    { name: "Deps Install", result: output.phases.depsInstall },
+    { name: "Env Check", result: output.phases.envCheck },
+    { name: "Supabase", result: output.phases.supabaseStart },
+    { name: "Clean", result: output.phases.clean },
+    { name: "Fresh", result: output.phases.fresh },
+    { name: "Type Check", result: output.phases.typeCheck },
+    { name: "Lint", result: output.phases.lint },
+    { name: "Build", result: output.phases.build },
+    { name: "DB Sync", result: output.phases.dbSync },
+    { name: "Manifest", result: output.phases.manifest },
+    { name: "Validate", result: output.phases.validate }
+  ];
+  printPhaseResults(logger, phases);
+  printWarnings(logger, output.warnings);
+  logger.info("");
+  logger.info(`Total time: ${formatDuration(output.durationMs)}`);
+  if (output.success) {
+    const hasWarnings = output.warnings && output.warnings.length > 0;
+    if (hasWarnings) {
+      logger.success("Build completed with warnings.");
+    } else {
+      logger.success("Build completed successfully!");
+    }
+  } else {
+    logger.error(`Build failed: ${output.error}`);
+  }
+}
+async function runBuildMachine(input, logger) {
+  const repoRoot = input.targetDir ?? findRepoRoot(process.cwd());
+  return new Promise((resolve, reject) => {
+    const actor = createActor(buildMachine, {
+      input: { input, repoRoot }
+    });
+    let previousState = "";
+    actor.subscribe((snapshot) => {
+      const currentState = getStateName(snapshot);
+      if (currentState !== previousState) {
+        handleStateChange(snapshot, previousState, logger);
+        previousState = currentState;
+      }
+      if (isComplete(snapshot)) {
+        const output = snapshot.output;
+        if (output) {
+          resolve(output);
+        }
+      }
+    });
+    actor.subscribe({
+      error: (error) => {
+        reject(error);
+        actor.stop();
+      }
+    });
+    actor.start();
+    actor.send({ type: "START" });
+  });
+}
+async function runBuildAction(options, cmd) {
+  const logger = createCLILogger("build");
+  try {
+    const result = await runBuildMachine(options, logger);
+    printSummary(logger, result);
+    emitJsonSuccess(cmd, BuildOutputSchema, result);
+    if (!result.success) {
+      throw new CLIError(result.error ?? "Build failed", "BUILD_FAILED", [
+        "Run: runa check --verbose (diagnose environment)",
+        "Run: runa db sync (if schema types missing)",
+        "Check logs in .runa/tmp/build/ for details"
+      ]);
+    }
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      error instanceof Error ? error.message : String(error),
+      "BUILD_ERROR",
+      [
+        "Run: runa check --verbose (diagnose environment)",
+        "Check logs in .runa/tmp/build/ for details"
+      ],
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+var buildCommand = new Command("build").description("Smart build with auto-setup (like vercel build / next build)").option("--e2e", "Enable E2E mode (test attributes + fresh cache)").option("--clean", "Clear build caches before building").option("--fresh", "Full clean (including node_modules) + reinstall").option("--skip-db", "Skip database sync step").option("--skip-manifest", "Skip manifest generation step").option("--no-setup", "Skip auto-setup phase (deps, env, Supabase)").option("--verbose", "Show detailed output").option("--check", "Dry-run mode (show what would be done)").option("--target-dir <path>", "Target directory (defaults to repo root)").option("--only <phases>", "Only run specific phases (types,lint,build,db,manifest)").action(async (options, cmd) => {
+  const input = {
+    e2e: options.e2e ?? false,
+    clean: options.clean ?? false,
+    fresh: options.fresh ?? false,
+    skipDb: options.skipDb ?? false,
+    skipManifest: options.skipManifest ?? false,
+    verbose: options.verbose ?? false,
+    check: options.check ?? false,
+    noSetup: options.setup === false,
+    // --no-setup sets setup to false
+    targetDir: options.targetDir,
+    only: parseOnlyOption(options.only)
+  };
+  await runBuildAction(input, cmd);
+});
+
+export { BuildInputSchema, BuildOutputSchema, buildCommand };