scale-stack 0.0.1-alpha.1 → 0.0.1

package/dist/index.js

@@ -2,23 +2,4225 @@
 
 // src/cli/index.ts
 import { Command } from "commander";
+
+// src/cli/commands/init.ts
+import { exec as cpExec } from "child_process";
+import { resolve as resolve3 } from "path";
+import { InvalidArgumentError } from "commander";
+import pc5 from "picocolors";
+
+// src/cli/config.ts
+var DEFAULT_CI_PROVIDER = "github";
+var DEFAULT_ANALYTICS_PROVIDER = "plausible";
+function deriveAuthStrategy(orm) {
+  return orm === "prisma" ? "stateful" : "stateless";
+}
+function resolveConfig(flags, answers) {
+  const projectName = flags.name ?? answers.projectName ?? "my-app";
+  const orm = flags.orm ? "prisma" : answers.orm ?? "none";
+  const authEnabled = flags.auth ?? answers.auth ?? false;
+  const optMods = new Set(answers.optionalModules ?? []);
+  const resolveCi = () => {
+    if (flags.ci !== void 0) {
+      return flags.ci === true ? DEFAULT_CI_PROVIDER : flags.ci;
+    }
+    return answers.ci ?? "none";
+  };
+  const resolveAnalytics = () => {
+    if (flags.analytics !== void 0) {
+      return flags.analytics === true ? DEFAULT_ANALYTICS_PROVIDER : flags.analytics;
+    }
+    return answers.analytics ?? "none";
+  };
+  return {
+    projectName,
+    orm,
+    authStrategy: authEnabled ? deriveAuthStrategy(orm) : "none",
+    aiChat: flags.chat ?? answers.aiChat ?? false,
+    i18n: flags.i18n ?? optMods.has("i18n"),
+    ci: resolveCi(),
+    analytics: resolveAnalytics(),
+    // Coming-soon modules are accepted by the CLI but must not affect the
+    // generator config until their DAG nodes are implemented.
+    jobs: false,
+    a11y: false,
+    apiClient: false,
+    preCommit: flags.preCommit ?? optMods.has("preCommit")
+  };
+}
+
+// src/cli/prompts/tech-picker.ts
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/cli/ui/theme.ts
+import gradient from "gradient-string";
+import pc from "picocolors";
+var ikeaGradient = gradient(["#FFDB00", "#0058A3"]);
+var ikea = {
+  heading: (s) => pc.bold(pc.yellow(s)),
+  accent: pc.yellow,
+  muted: pc.dim,
+  success: pc.green,
+  bullet: pc.yellow("\u25B8"),
+  dimBullet: pc.dim("\u25B8")
+};
+function sectionDivider(title) {
+  const line = "\u2500".repeat(Math.max(1, 40 - title.length));
+  return pc.dim(`  \u2500\u2500 ${pc.yellow(title)} ${line}`);
+}
+
+// src/cli/prompts/tech-picker.ts
+function cancelled() {
+  p.cancel(pc2.yellow("Assembly cancelled \u2014 no parts were harmed."));
+  process.exit(0);
+}
+async function runTechPicker(flags) {
+  const answers = {};
+  p.intro(ikeaGradient(" S K A L S T \xC5 K K "));
+  console.log(sectionDivider("Core Stack"));
+  console.log();
+  if (!flags.name) {
+    const name = await p.text({
+      message: "Project name",
+      placeholder: "my-app",
+      validate: (v = "") => {
+        if (!v.trim()) return "Project name is required";
+        if (!/^[a-z0-9@][a-z0-9._-]*$/i.test(v.trim()))
+          return "Invalid package name";
+      }
+    });
+    if (p.isCancel(name)) cancelled();
+    answers.projectName = name;
+  }
+  if (flags.orm === void 0) {
+    const orm = await p.confirm({
+      message: "Add Prisma ORM? " + ikea.muted(
+        "\u2014 schema, migrations, seed script, singleton client \u2014 v7 + Driver Adapters"
+      ),
+      initialValue: false
+    });
+    if (p.isCancel(orm)) cancelled();
+    answers.orm = orm ? "prisma" : "none";
+  }
+  if (flags.auth === void 0) {
+    const resolvedOrm = flags.orm ? "prisma" : answers.orm ?? "none";
+    const hint = resolvedOrm === "prisma" ? "DB-backed sessions, login/signup pages, Prisma adapter" : "stateless JWT sessions, login/signup pages, no DB required";
+    const auth = await p.confirm({
+      message: "Add authentication? " + ikea.muted(`\u2014 Better Auth \xB7 ${hint}`),
+      initialValue: false
+    });
+    if (p.isCancel(auth)) cancelled();
+    answers.auth = auth;
+  }
+  if (flags.jobs === void 0) {
+    console.log(
+      `  ${pc2.yellow("\u25B8")} Background jobs ` + ikea.muted("\u2014 Inngest (not implemented; skipped)")
+    );
+  }
+  if (flags.chat === void 0) {
+    const chat = await p.confirm({
+      message: "Enable AI chat? " + ikea.muted("\u2014 Vercel AI SDK, streaming /api/chat, AI Elements UI"),
+      initialValue: false
+    });
+    if (p.isCancel(chat)) cancelled();
+    answers.aiChat = chat;
+  }
+  console.log();
+  console.log(sectionDivider("Features"));
+  console.log();
+  if (flags.ci === void 0) {
+    const ci = await p.select({
+      message: "CI pipeline",
+      options: [
+        {
+          value: "github",
+          label: pc2.bold("GitHub Actions"),
+          hint: ikea.muted(
+            "lint and Docker build now; test jobs as TODO no-ops"
+          )
+        },
+        {
+          value: "circleci",
+          label: "CircleCI (coming soon)",
+          hint: ikea.muted("placeholder option for a later release")
+        },
+        {
+          value: "none",
+          label: "None",
+          hint: ikea.muted("no CI pipeline \u2014 add your own later")
+        }
+      ]
+    });
+    if (p.isCancel(ci)) cancelled();
+    answers.ci = ci;
+  }
+  if (flags.analytics === void 0) {
+    const analytics = await p.select({
+      message: "Analytics",
+      options: [
+        {
+          value: "plausible",
+          label: pc2.bold("Plausible"),
+          hint: ikea.muted(
+            "privacy-friendly web analytics with local Compose support"
+          )
+        },
+        {
+          value: "posthog",
+          label: "PostHog (not implemented)",
+          hint: ikea.muted("placeholder option for a later release")
+        },
+        {
+          value: "none",
+          label: "None",
+          hint: ikea.muted("no analytics \u2014 add your own later")
+        }
+      ]
+    });
+    if (p.isCancel(analytics)) cancelled();
+    answers.analytics = analytics;
+  }
+  const alreadySelected = /* @__PURE__ */ new Set();
+  if (flags.a11y) alreadySelected.add("a11y");
+  if (flags.apiClient) alreadySelected.add("apiClient");
+  if (flags.i18n) alreadySelected.add("i18n");
+  if (flags.preCommit) alreadySelected.add("preCommit");
+  const availableModules = [
+    {
+      value: "a11y",
+      label: "Accessibility (coming soon)",
+      hint: ikea.muted("placeholder option for a later release")
+    },
+    {
+      value: "apiClient",
+      label: "API client (coming soon)",
+      hint: ikea.muted("placeholder option for a later release")
+    },
+    {
+      value: "i18n",
+      label: "Internationalization",
+      hint: ikea.muted("next-intl, locale routing, <LocaleSwitcher>")
+    },
+    {
+      value: "preCommit",
+      label: "Pre-commit hooks",
+      hint: ikea.muted("prek hooks for lint, format, and typecheck")
+    }
+  ].filter((m) => !alreadySelected.has(m.value));
+  if (availableModules.length > 0) {
+    console.log();
+    console.log(sectionDivider("Smart-Fittings"));
+    console.log();
+    const selected = await p.multiselect({
+      message: "Optional modules " + ikea.muted("\u2014 pick only what you need"),
+      options: availableModules,
+      required: false
+    });
+    if (p.isCancel(selected)) cancelled();
+    answers.optionalModules = selected;
+  }
+  p.outro(
+    pc2.green("\u2713") + " All parts selected. " + ikea.heading("Ready for assembly.")
+  );
+  return answers;
+}
+
+// src/cli/ui/config-display.ts
+import pc3 from "picocolors";
+
+// src/cli/ui/animate.ts
+function sleep(ms) {
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
+}
+function cursorUp(n) {
+  process.stdout.write(`\x1B[${n}A`);
+}
+async function cascade(lines, delayMs) {
+  for (const line of lines) {
+    console.log(line);
+    await sleep(delayMs);
+  }
+}
+async function typewriter(text2, charDelayMs) {
+  for (const char of text2) {
+    process.stdout.write(char);
+    if (char !== " " && char !== "\n") {
+      await sleep(charDelayMs);
+    }
+  }
+}
+
+// src/cli/ui/config-display.ts
+function row(content) {
+  return `  \u2502  ${content}`;
+}
+function labelRow(key, value, maxKey) {
+  const dots = "\xB7".repeat(Math.max(1, maxKey - key.length + 2));
+  return row(`${ikea.bullet} ${key} ${pc3.dim(dots)} ${value}`);
+}
+function formatValue(val) {
+  if (val === true || val === "yes") return pc3.green("yes");
+  if (val === false || val === "no" || val === "none") return ikea.muted("no");
+  return pc3.green(val);
+}
+function buildLines(config) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const header = "S K A L S T \xC5 K K";
+  const artNo = `Art.${today.replace(/-/g, ".")}`;
+  const coreEntries = [
+    ["Project", config.projectName],
+    ["ORM", config.orm === "none" ? false : config.orm],
+    ["Auth", config.authStrategy === "none" ? false : config.authStrategy],
+    ["Jobs", config.jobs],
+    ["AI Chat", config.aiChat]
+  ];
+  const featureEntries = [
+    ["CI", config.ci === "none" ? false : config.ci],
+    ["Analytics", config.analytics === "none" ? false : config.analytics]
+  ];
+  const moduleEntries = [
+    ["a11y", config.a11y],
+    ["API Client", config.apiClient],
+    ["i18n", config.i18n],
+    ["Pre-commit", config.preCommit]
+  ];
+  const allEntries = [...coreEntries, ...featureEntries, ...moduleEntries];
+  const maxKey = Math.max(...allEntries.map(([k]) => k.length));
+  const lines = [];
+  lines.push(pc3.dim("  \u250C\u2500\u2500"));
+  lines.push(row(ikeaGradient(header) + "     " + ikea.muted(artNo)));
+  lines.push(row(ikea.muted("Assembly summary")));
+  lines.push(pc3.dim("  \u2502"));
+  for (const [key, val] of coreEntries) {
+    lines.push(labelRow(key, formatValue(val), maxKey));
+  }
+  lines.push(pc3.dim("  \u2502"));
+  lines.push(row(pc3.yellow("Features:")));
+  lines.push(pc3.dim("  \u2502"));
+  for (const [key, val] of featureEntries) {
+    lines.push(labelRow(key, formatValue(val), maxKey));
+  }
+  lines.push(pc3.dim("  \u2502"));
+  lines.push(row(pc3.yellow("Smart-Fittings (modules):")));
+  lines.push(pc3.dim("  \u2502"));
+  for (const [key, val] of moduleEntries) {
+    lines.push(labelRow(key, formatValue(val), maxKey));
+  }
+  lines.push(pc3.dim("  \u2502"));
+  lines.push(row(ikea.muted(artNo)));
+  lines.push(pc3.dim("  \u2514\u2500\u2500"));
+  return lines;
+}
+async function animateConfigLabel(config) {
+  const lines = buildLines(config);
+  console.log();
+  await cascade(lines, 25);
+  console.log();
+}
+function printConfigLabel(config) {
+  const lines = buildLines(config);
+  console.log();
+  for (const line of lines) console.log(line);
+  console.log();
+}
+
+// src/engine/runner.ts
+import { exec } from "child_process";
+import { join as join4 } from "path";
+import { promisify } from "util";
+
+// src/engine/dag.ts
+function getDependencies(generator, config) {
+  return [
+    ...generator.dependencies,
+    ...generator.resolveDependencies?.(config) ?? []
+  ];
+}
+function buildDAG(generators2, config) {
+  const active = generators2.filter((g) => !g.condition || g.condition(config));
+  const byName = /* @__PURE__ */ new Map();
+  for (const g of active) {
+    byName.set(g.name, g);
+  }
+  for (const g of active) {
+    for (const dep of getDependencies(g, config)) {
+      if (!byName.has(dep)) {
+        throw new Error(
+          `Generator "${g.name}" depends on "${dep}", which is not registered or was excluded by its condition`
+        );
+      }
+    }
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const g of active) {
+    inDegree.set(g.name, 0);
+    dependents.set(g.name, []);
+  }
+  for (const g of active) {
+    for (const dep of getDependencies(g, config)) {
+      inDegree.set(g.name, (inDegree.get(g.name) ?? 0) + 1);
+      dependents.get(dep).push(g.name);
+    }
+  }
+  const queue = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0) queue.push(name);
+  }
+  queue.sort();
+  const sorted = [];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    sorted.push(byName.get(name));
+    const neighbors = dependents.get(name) ?? [];
+    neighbors.sort();
+    for (const neighbor of neighbors) {
+      const newDeg = (inDegree.get(neighbor) ?? 1) - 1;
+      inDegree.set(neighbor, newDeg);
+      if (newDeg === 0) queue.push(neighbor);
+    }
+    queue.sort();
+  }
+  if (sorted.length !== active.length) {
+    const remaining = active.filter((g) => !sorted.some((s) => s.name === g.name)).map((g) => g.name);
+    throw new Error(
+      `Dependency cycle detected among generators: ${remaining.join(", ")}`
+    );
+  }
+  return sorted;
+}
+
+// src/engine/fs.ts
+import { readFile, writeFile, mkdir, rm, readdir } from "fs/promises";
+import { existsSync } from "fs";
+import { resolve, dirname, relative, join } from "path";
+import { createPatch } from "diff";
+var VirtualFS = class {
+  operations = [];
+  /** Maps absolute path → original content (string) or null if the file was new */
+  committedFiles = /* @__PURE__ */ new Map();
+  targetDir;
+  constructor(targetDir) {
+    this.targetDir = resolve(targetDir);
+  }
+  abs(p2) {
+    return resolve(this.targetDir, p2);
+  }
+  write(path, content) {
+    this.operations.push({ type: "write", path, content });
+  }
+  copy(src, dest) {
+    this.operations.push({ type: "copy", src, dest });
+  }
+  merge(path, mergeFn) {
+    this.operations.push({ type: "merge", path, mergeFn });
+  }
+  async commit() {
+    for (const op of this.operations) {
+      switch (op.type) {
+        case "write": {
+          const abs = this.abs(op.path);
+          await this.trackOriginal(abs);
+          await mkdir(dirname(abs), { recursive: true });
+          await writeFile(abs, op.content, "utf-8");
+          break;
+        }
+        case "copy": {
+          const abs = this.abs(op.dest);
+          await this.trackOriginal(abs);
+          const content = await readFile(resolve(op.src), "utf-8");
+          await mkdir(dirname(abs), { recursive: true });
+          await writeFile(abs, content, "utf-8");
+          break;
+        }
+        case "merge": {
+          const abs = this.abs(op.path);
+          const existing = existsSync(abs) ? await readFile(abs, "utf-8") : "";
+          await this.trackOriginal(abs);
+          const merged = op.mergeFn(existing);
+          await mkdir(dirname(abs), { recursive: true });
+          await writeFile(abs, merged, "utf-8");
+          break;
+        }
+      }
+    }
+  }
+  async rollback() {
+    for (const [abs, original] of this.committedFiles) {
+      if (original === null) {
+        if (existsSync(abs)) await rm(abs);
+      } else {
+        await writeFile(abs, original, "utf-8");
+      }
+    }
+    const dirs = /* @__PURE__ */ new Set();
+    for (const abs of this.committedFiles.keys()) {
+      let dir = dirname(abs);
+      while (dir.startsWith(this.targetDir) && dir !== this.targetDir) {
+        dirs.add(dir);
+        dir = dirname(dir);
+      }
+    }
+    const sortedDirs = [...dirs].sort((a, b) => b.length - a.length);
+    for (const dir of sortedDirs) {
+      try {
+        const entries = await readdir(dir);
+        if (entries.length === 0) await rm(dir, { recursive: true });
+      } catch {
+      }
+    }
+    this.committedFiles.clear();
+  }
+  async dryRun() {
+    const results = [];
+    for (const op of this.operations) {
+      switch (op.type) {
+        case "write": {
+          const abs = this.abs(op.path);
+          if (existsSync(abs)) {
+            const existing = await readFile(abs, "utf-8");
+            results.push({
+              path: op.path,
+              action: "modify",
+              diff: createPatch(op.path, existing, op.content)
+            });
+          } else {
+            results.push({
+              path: op.path,
+              action: "create",
+              content: op.content
+            });
+          }
+          break;
+        }
+        case "copy": {
+          const content = await readFile(resolve(op.src), "utf-8");
+          const abs = this.abs(op.dest);
+          if (existsSync(abs)) {
+            const existing = await readFile(abs, "utf-8");
+            results.push({
+              path: op.dest,
+              action: "modify",
+              diff: createPatch(op.dest, existing, content)
+            });
+          } else {
+            results.push({
+              path: op.dest,
+              action: "copy",
+              content
+            });
+          }
+          break;
+        }
+        case "merge": {
+          const abs = this.abs(op.path);
+          const existing = existsSync(abs) ? await readFile(abs, "utf-8") : "";
+          const merged = op.mergeFn(existing);
+          if (existing) {
+            results.push({
+              path: op.path,
+              action: "modify",
+              diff: createPatch(op.path, existing, merged)
+            });
+          } else {
+            results.push({
+              path: op.path,
+              action: "create",
+              content: merged
+            });
+          }
+          break;
+        }
+      }
+    }
+    return results;
+  }
+  // ── Adopt pattern for external tool output ──────────────
+  async snapshotDir() {
+    const snapshot = /* @__PURE__ */ new Map();
+    if (!existsSync(this.targetDir)) return snapshot;
+    await this.walkDir(this.targetDir, snapshot);
+    return snapshot;
+  }
+  async adoptExternalChanges(before) {
+    const after = await this.snapshotDir();
+    for (const [relPath, content] of after) {
+      const abs = this.abs(relPath);
+      if (this.committedFiles.has(abs)) continue;
+      const prev = before.get(relPath);
+      if (prev === void 0) {
+        this.committedFiles.set(abs, null);
+      } else if (prev !== content) {
+        this.committedFiles.set(abs, prev);
+      }
+    }
+    for (const [relPath] of before) {
+      if (!after.has(relPath)) {
+        const abs = this.abs(relPath);
+        if (!this.committedFiles.has(abs)) {
+          this.committedFiles.set(abs, before.get(relPath));
+        }
+      }
+    }
+  }
+  // ── Private helpers ────────────────────────────────────
+  async trackOriginal(abs) {
+    if (this.committedFiles.has(abs)) return;
+    if (existsSync(abs)) {
+      this.committedFiles.set(abs, await readFile(abs, "utf-8"));
+    } else {
+      this.committedFiles.set(abs, null);
+    }
+  }
+  async walkDir(dir, snapshot) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".git") continue;
+        await this.walkDir(full, snapshot);
+      } else if (entry.isFile()) {
+        try {
+          const content = await readFile(full, "utf-8");
+          snapshot.set(relative(this.targetDir, full), content);
+        } catch {
+        }
+      }
+    }
+  }
+};
+
+// src/engine/template.ts
+import ejs from "ejs";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+function resolveTemplatesDir() {
+  const here = import.meta.dirname ?? new URL(".", import.meta.url).pathname;
+  for (const candidate of [
+    join2(here, "../../templates"),
+    join2(here, "../templates")
+  ]) {
+    if (existsSync2(candidate)) return candidate;
+  }
+  return join2(here, "../../templates");
+}
+var TemplateEngine = class {
+  templatesDir;
+  constructor(templatesDir) {
+    this.templatesDir = resolve2(templatesDir);
+  }
+  async renderFile(templatePath, data) {
+    const full = resolve2(this.templatesDir, templatePath);
+    return ejs.renderFile(full, data);
+  }
+  renderString(template, data) {
+    return ejs.render(template, data);
+  }
+};
+var DEFAULT_TEMPLATE_ENGINE = new TemplateEngine(
+  resolveTemplatesDir()
+);
+function renderTemplateFile(templatePath, data) {
+  return DEFAULT_TEMPLATE_ENGINE.renderFile(templatePath, data);
+}
+
+// src/engine/logger.ts
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import pc4 from "picocolors";
+var Logger = class {
+  entries = [];
+  quiet;
+  constructor(quiet = false) {
+    this.quiet = quiet;
+  }
+  info(generator, message) {
+    this.log("info", generator, message);
+  }
+  success(generator, message) {
+    this.log("success", generator, message);
+  }
+  warn(generator, message) {
+    this.log("warn", generator, message);
+  }
+  error(generator, message, err) {
+    this.log("error", generator, message, void 0, err);
+  }
+  fileWritten(generator, path) {
+    this.log("info", generator, `wrote ${path}`, path);
+  }
+  async flush(logDir) {
+    if (this.entries.length === 0) return;
+    if (!existsSync3(logDir)) {
+      await mkdir2(logDir, { recursive: true });
+    }
+    const logPath = join3(logDir, "generate.log");
+    const ndjson = this.entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    await writeFile2(logPath, ndjson, { flag: "a", encoding: "utf-8" });
+  }
+  // ── Private ───────────────────────────────────────────
+  log(level, generator, message, file, err) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      generator,
+      message,
+      ...file && { file },
+      ...err && { error: err.message }
+    };
+    this.entries.push(entry);
+    if (this.quiet) return;
+    const tag = pc4.dim(`[${generator}]`);
+    const formatted = CONSOLE_FORMATTERS[level](message);
+    console.log(`  ${tag} ${formatted}`);
+  }
+};
+var CONSOLE_FORMATTERS = {
+  info: (msg) => msg,
+  success: (msg) => pc4.green(`\u2713 ${msg}`),
+  warn: (msg) => pc4.yellow(`\u26A0 ${msg}`),
+  error: (msg) => pc4.red(`\u2717 ${msg}`),
+  // The engine never emits "skip"; sync uses it to mark conflict-skipped keys.
+  // Included so CONSOLE_FORMATTERS covers the full LogLevel union.
+  skip: (msg) => pc4.dim(`\u21B7 ${msg}`)
+};
+
+// src/types/env-fragments.ts
+function createEnvFragmentBag() {
+  const fragments = [];
+  return {
+    fragments,
+    push(fragment) {
+      fragments.push(fragment);
+    }
+  };
+}
+
+// src/engine/runner.ts
+var execAsync = promisify(exec);
+function isExecException(e) {
+  return e instanceof Error && ("stdout" in e || "stderr" in e || "code" in e || "signal" in e);
+}
+function asString(v) {
+  if (v === void 0) return "";
+  return typeof v === "string" ? v : v.toString("utf-8");
+}
+async function runCommand(options) {
+  const { cmd, cwd, env, maxBuffer, generator, logger } = options;
+  logger.info(generator, `exec: ${cmd}`);
+  try {
+    const { stdout, stderr } = await execAsync(cmd, { cwd, env, maxBuffer });
+    const stdoutStr = asString(stdout);
+    const stderrStr = asString(stderr);
+    if (stdoutStr) logger.info(generator, stdoutStr.trimEnd());
+    if (stderrStr) logger.warn(generator, stderrStr.trimEnd());
+    return { stdout: stdoutStr, stderr: stderrStr, exitCode: 0 };
+  } catch (e) {
+    if (!isExecException(e)) {
+      throw e instanceof Error ? e : new Error(String(e));
+    }
+    const stdoutStr = asString(e.stdout);
+    const stderrStr = asString(e.stderr);
+    if (stdoutStr) logger.info(generator, stdoutStr.trimEnd());
+    if (stderrStr) logger.warn(generator, stderrStr.trimEnd());
+    const exitCode = typeof e.code === "number" ? e.code : 1;
+    throw new Error(
+      `Command "${cmd}" exited with code ${exitCode}: ${stderrStr}`,
+      { cause: e }
+    );
+  }
+}
+async function run(options) {
+  const {
+    generators: generators2,
+    config,
+    targetDir,
+    dryRun = false,
+    quiet = false
+  } = options;
+  const logger = new Logger(quiet);
+  const template = DEFAULT_TEMPLATE_ENGINE;
+  const envBag = createEnvFragmentBag();
+  let order;
+  try {
+    order = buildDAG(generators2, config);
+  } catch (err) {
+    return {
+      succeeded: [],
+      failed: [
+        {
+          name: "dag",
+          error: err instanceof Error ? err : new Error(String(err))
+        }
+      ],
+      skipped: generators2.map((g) => g.name),
+      envBag
+    };
+  }
+  const succeeded = [];
+  const failed = [];
+  const skipped = [];
+  const allDryRunResults = [];
+  const dryRunVfsInstances = [];
+  for (let i = 0; i < order.length; i++) {
+    const generator = order[i];
+    const vfs = new VirtualFS(targetDir);
+    const execFn = async (cmd, execOpts) => {
+      if (dryRun) {
+        logger.info(generator.name, `[dry-run] would exec: ${cmd}`);
+        allDryRunResults.push({
+          path: cmd,
+          action: "exec",
+          content: `would exec: ${cmd} (file changes not previewable)`
+        });
+        return { stdout: "", stderr: "", exitCode: 0 };
+      }
+      const snapshot = await vfs.snapshotDir();
+      try {
+        return await runCommand({
+          cmd,
+          cwd: execOpts?.cwd ?? targetDir,
+          env: { ...process.env, ...execOpts?.env },
+          maxBuffer: 10 * 1024 * 1024,
+          generator: generator.name,
+          logger
+        });
+      } finally {
+        await vfs.adoptExternalChanges(snapshot);
+      }
+    };
+    const ctx = {
+      config,
+      envBag,
+      fs: vfs,
+      template,
+      logger,
+      targetDir,
+      exec: execFn
+    };
+    try {
+      await generator.execute(ctx);
+      if (dryRun) {
+        const results = await vfs.dryRun();
+        allDryRunResults.push(...results);
+        await vfs.commit();
+        dryRunVfsInstances.push(vfs);
+      } else {
+        await vfs.commit();
+      }
+      succeeded.push(generator.name);
+      logger.success(generator.name, "completed");
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      await vfs.rollback();
+      if (generator.rollback) {
+        try {
+          await generator.rollback(ctx);
+        } catch (rollbackErr) {
+          logger.warn(
+            generator.name,
+            `rollback handler failed: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`
+          );
+        }
+      }
+      logger.error(generator.name, `failed: ${error.message}`, error);
+      failed.push({ name: generator.name, error });
+      for (let j = i + 1; j < order.length; j++) {
+        skipped.push(order[j].name);
+      }
+      break;
+    }
+  }
+  if (dryRun) {
+    for (const vfs of dryRunVfsInstances.reverse()) {
+      await vfs.rollback();
+    }
+  }
+  const logDir = join4(targetDir, ".scale-stack");
+  if (!dryRun) {
+    await logger.flush(logDir);
+  }
+  return {
+    succeeded,
+    failed,
+    skipped,
+    envBag,
+    ...dryRun && { dryRunResults: allDryRunResults }
+  };
+}
+async function runAfterInstall(opts) {
+  const {
+    generators: generators2,
+    config,
+    envBag,
+    targetDir,
+    succeeded,
+    quiet = false
+  } = opts;
+  const logger = new Logger(quiet);
+  const template = DEFAULT_TEMPLATE_ENGINE;
+  let ran = false;
+  for (const name of succeeded) {
+    const generator = generators2.find((g) => g.name === name);
+    if (!generator?.afterInstall) continue;
+    ran = true;
+    const vfs = new VirtualFS(targetDir);
+    const execFn = async (cmd, execOpts) => runCommand({
+      cmd,
+      cwd: execOpts?.cwd ?? targetDir,
+      env: { ...process.env, ...execOpts?.env },
+      maxBuffer: 50 * 1024 * 1024,
+      generator: generator.name,
+      logger
+    });
+    const ctx = {
+      config,
+      envBag,
+      fs: vfs,
+      template,
+      logger,
+      targetDir,
+      exec: execFn
+    };
+    try {
+      await generator.afterInstall(ctx);
+      await vfs.commit();
+    } catch (err) {
+      logger.warn(
+        generator.name,
+        `afterInstall did not complete: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (ran) {
+    await logger.flush(join4(targetDir, ".scale-stack"));
+  }
+}
+
+// src/generators/registry.ts
+var generators = /* @__PURE__ */ new Map();
+function registerGenerator(gen) {
+  if (generators.has(gen.name)) {
+    throw new Error(`Generator "${gen.name}" is already registered`);
+  }
+  generators.set(gen.name, gen);
+}
+function getRegisteredGenerators() {
+  return [...generators.values()];
+}
+
+// src/cli/commands/init.ts
+function parseCiProvider(value) {
+  if (value === "github" || value === "circleci" || value === "none") {
+    return value;
+  }
+  throw new InvalidArgumentError(
+    "CI provider must be one of: github, circleci, none"
+  );
+}
+function parseAnalyticsProvider(value) {
+  if (value === "plausible" || value === "posthog" || value === "none") {
+    return value;
+  }
+  throw new InvalidArgumentError(
+    "Analytics provider must be one of: plausible, posthog, none"
+  );
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("Assemble a new SKALST\xC5KK project").argument("[name]", "Project name").option("--name <name>", "Project name (overrides positional argument)").option("--orm", "Use Prisma ORM").option("--auth", "Enable authentication (Better Auth)").option("--chat", "Enable AI chat").option("--i18n", "Enable internationalization").option(
+    "--ci [provider]",
+    "CI pipeline: github, circleci, or none (default: github)",
+    parseCiProvider
+  ).option(
+    "--analytics [provider]",
+    "Analytics provider: plausible, posthog, or none (default: plausible)",
+    parseAnalyticsProvider
+  ).option("--jobs", "Background jobs (Inngest; not implemented, ignored)").option("--a11y", "Accessibility tooling (coming soon, ignored)").option("--api-client", "API client generation (coming soon, ignored)").option("--pre-commit", "Enable prek pre-commit hooks").option("-y, --yes", "Skip prompts, accept defaults").option("--dry-run", "Show what would be generated without writing files").action(async (positionalName, opts) => {
+    const flags = {
+      ...opts,
+      name: opts.name ?? positionalName
+    };
+    const answers = flags.yes ? {} : await runTechPicker(flags);
+    const config = resolveConfig(flags, answers);
+    if (flags.jobs) {
+      console.log(
+        ikea.muted(
+          `  ${pc5.yellow("\u25B8")} Inngest jobs are not implemented yet; skipping --jobs.`
+        )
+      );
+    }
+    if (flags.a11y || answers.optionalModules?.includes("a11y")) {
+      console.log(
+        ikea.muted(
+          `  ${pc5.yellow("\u25B8")} Accessibility tooling is coming soon; skipping --a11y.`
+        )
+      );
+    }
+    if (flags.apiClient || answers.optionalModules?.includes("apiClient")) {
+      console.log(
+        ikea.muted(
+          `  ${pc5.yellow("\u25B8")} API client generation is coming soon; skipping --api-client.`
+        )
+      );
+    }
+    if (process.stdout.isTTY) {
+      await animateConfigLabel(config);
+    } else {
+      printConfigLabel(config);
+    }
+    const targetDir = resolve3(process.cwd(), config.projectName);
+    const generators2 = getRegisteredGenerators();
+    if (generators2.length === 0) {
+      console.log(
+        ikea.muted(
+          `  ${pc5.yellow("\u25B8")} No generators registered \u2014 config collected only.`
+        )
+      );
+      console.log();
+      return;
+    }
+    const result = await run({
+      generators: generators2,
+      config,
+      targetDir,
+      dryRun: flags.dryRun
+    });
+    if (flags.dryRun && result.dryRunResults) {
+      console.log();
+      console.log(ikea.heading("  Dry-run results:"));
+      console.log();
+      for (const dr of result.dryRunResults) {
+        const tag = dr.action === "exec" ? pc5.cyan("exec") : dr.action === "create" ? pc5.green("create") : dr.action === "copy" ? pc5.blue("copy") : pc5.yellow("modify");
+        console.log(`  ${tag}  ${dr.path}`);
+        if (dr.diff) {
+          for (const line of dr.diff.split("\n").slice(2)) {
+            if (line.startsWith("+")) console.log(`    ${pc5.green(line)}`);
+            else if (line.startsWith("-")) console.log(`    ${pc5.red(line)}`);
+            else console.log(`    ${pc5.dim(line)}`);
+          }
+        }
+      }
+      console.log();
+      return;
+    }
+    if (result.failed.length > 0) {
+      console.log();
+      console.log(
+        pc5.red(
+          `  \u2717 Generation failed at "${result.failed[0].name}": ${result.failed[0].error.message}`
+        )
+      );
+      if (result.succeeded.length > 0) {
+        console.log(
+          ikea.muted(`  Succeeded: ${result.succeeded.join(", ")}`)
+        );
+      }
+      if (result.skipped.length > 0) {
+        console.log(ikea.muted(`  Skipped: ${result.skipped.join(", ")}`));
+      }
+      console.log();
+      process.exitCode = 1;
+      return;
+    }
+    if (!flags.dryRun) {
+      console.log();
+      console.log(ikea.muted(`  ${pc5.cyan("\u25B8")} pnpm install\u2026`));
+      try {
+        await new Promise((resolvePromise, rejectPromise) => {
+          cpExec(
+            "pnpm install",
+            { cwd: targetDir, maxBuffer: 50 * 1024 * 1024 },
+            (err, stdout, stderr) => {
+              if (stdout) process.stdout.write(stdout);
+              if (stderr) process.stderr.write(stderr);
+              if (err) rejectPromise(err);
+              else resolvePromise();
+            }
+          );
+        });
+      } catch (err) {
+        console.log();
+        console.log(
+          pc5.red(
+            `  \u2717 pnpm install failed: ${err instanceof Error ? err.message : String(err)}`
+          )
+        );
+        console.log();
+        process.exitCode = 1;
+        return;
+      }
+      await runAfterInstall({
+        generators: generators2,
+        config,
+        envBag: result.envBag,
+        targetDir,
+        succeeded: result.succeeded
+      });
+    }
+    console.log();
+    console.log(pc5.green(`  \u2713 Project assembled at ${pc5.bold(targetDir)}`));
+    console.log();
+  });
+}
+
+// src/cli/commands/sync.ts
+import { resolve as resolve6 } from "path";
+import pc6 from "picocolors";
+
+// src/sync/run-sync.ts
+import { mkdir as mkdir6, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import { createPatch as createPatch2 } from "diff";
+import { exec as exec2 } from "child_process";
+import { join as join12 } from "path";
+import { promisify as promisify2 } from "util";
+
+// src/sync/cli-version.ts
 import { readFileSync } from "fs";
+import { dirname as dirname2, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
-import { dirname, resolve } from "path";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var pkgVersion = "0.0.0";
-try {
-  const pkg = JSON.parse(
-    readFileSync(resolve(__dirname, "../package.json"), "utf-8")
-  );
-  pkgVersion = pkg.version ?? pkgVersion;
-} catch {
-}
-var program = new Command().name("scale-stack").description("Opinionated scaffolding engine for Next.js projects").version(pkgVersion);
-program.command("init").description("Scaffold a new Scale Stack project").argument("[name]", "Project name").action((_name) => {
-  console.log("init is not yet implemented");
-});
-program.command("sync").description("Update an existing Scale Stack project").action(() => {
-  console.log("sync is not yet implemented");
+var cachedVersion;
+function getCliVersion() {
+  if (cachedVersion !== void 0) return cachedVersion;
+  const __dirname = dirname2(fileURLToPath(import.meta.url));
+  try {
+    const pkg = JSON.parse(
+      readFileSync(resolve4(__dirname, "../package.json"), "utf-8")
+    );
+    cachedVersion = pkg.version ?? "0.0.0";
+  } catch {
+    cachedVersion = "0.0.0";
+  }
+  return cachedVersion;
+}
+
+// src/sync/targets.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+
+// src/config/eslint-config-contents.ts
+function shouldIgnorePrismaGeneratedOutput(config) {
+  return config.orm === "prisma";
+}
+function shouldIgnoreAiElementsGeneratedOutput(config) {
+  return config.aiChat === true;
+}
+function buildEslintConfigMjsContents(config) {
+  return renderTemplateFile("eslint-prettier/eslint.config.mjs.ejs", {
+    ignoreAiElementsGeneratedOutput: shouldIgnoreAiElementsGeneratedOutput(config),
+    ignorePrismaGeneratedOutput: shouldIgnorePrismaGeneratedOutput(config)
+  });
+}
+
+// src/config/ai-chat-fragments.ts
+var AI_SDK_VERSION = "^6.0.175";
+var AI_SDK_REACT_VERSION = "^3.0.177";
+var AI_CHAT_DEPENDENCIES = {
+  "@ai-sdk/react": AI_SDK_REACT_VERSION,
+  ai: AI_SDK_VERSION
+};
+
+// src/config/auth-fragments.ts
+var BETTER_AUTH_VERSION = "^1.6.9";
+var BETTER_AUTH_PRISMA_ADAPTER_VERSION = "^1.6.9";
+var AUTH_DEPENDENCIES = {
+  "@better-auth/prisma-adapter": BETTER_AUTH_PRISMA_ADAPTER_VERSION,
+  "better-auth": BETTER_AUTH_VERSION
+};
+function buildAuthEnvFragment() {
+  return {
+    variables: [
+      {
+        name: "BETTER_AUTH_SECRET",
+        scope: "server",
+        schema: "z.string().min(32)",
+        example: "replace-with-at-least-32-character-secret"
+      },
+      {
+        name: "BETTER_AUTH_URL",
+        scope: "server",
+        schema: "z.string().url()",
+        example: "http://localhost:3000"
+      },
+      {
+        name: "MICROSOFT_CLIENT_ID",
+        scope: "server",
+        schema: "z.string().min(1)",
+        example: "replace-with-microsoft-client-id"
+      },
+      {
+        name: "MICROSOFT_CLIENT_SECRET",
+        scope: "server",
+        schema: "z.string().min(1)",
+        example: "replace-with-microsoft-client-secret"
+      },
+      {
+        name: "MICROSOFT_TENANT_ID",
+        scope: "server",
+        schema: "z.string().min(1)",
+        example: "common"
+      }
+    ]
+  };
+}
+
+// src/config/env-management-fragments.ts
+var T3_ENV_NEXTJS_VERSION = "^0.13.11";
+var ZOD_VERSION = "^4.3.6";
+var ENV_MANAGEMENT_DEPENDENCIES = {
+  "@t3-oss/env-nextjs": T3_ENV_NEXTJS_VERSION,
+  zod: ZOD_VERSION
+};
+
+// src/config/form-handling-fragments.ts
+var HOOKFORM_RESOLVERS_VERSION = "^5.2.2";
+var NEXT_SAFE_ACTION_RHF_ADAPTER_VERSION = "^2.0.6";
+var REACT_HOOK_FORM_VERSION = "^7.74.0";
+var FORM_HANDLING_DEPENDENCIES = {
+  "@hookform/resolvers": HOOKFORM_RESOLVERS_VERSION,
+  "@next-safe-action/adapter-react-hook-form": NEXT_SAFE_ACTION_RHF_ADAPTER_VERSION,
+  "react-hook-form": REACT_HOOK_FORM_VERSION
+};
+
+// src/config/i18n-fragments.ts
+var NEXT_INTL_VERSION = "^4.6.0";
+var I18N_DEPENDENCIES = {
+  "next-intl": NEXT_INTL_VERSION
+};
+
+// src/config/orm-fragments.ts
+var PRISMA_VERSION = "^7.8.0";
+var PRISMA_CLIENT_VERSION = "^7.8.0";
+var PRISMA_ADAPTER_PG_VERSION = "^7.8.0";
+var PG_VERSION = "^8.20.0";
+var TYPES_PG_VERSION = "^8.20.0";
+var TSX_VERSION = "^4.21.0";
+var ORM_DEPENDENCIES = {
+  "@prisma/adapter-pg": PRISMA_ADAPTER_PG_VERSION,
+  "@prisma/client": PRISMA_CLIENT_VERSION,
+  pg: PG_VERSION
+};
+var ORM_DEV_DEPENDENCIES = {
+  "@types/pg": TYPES_PG_VERSION,
+  prisma: PRISMA_VERSION,
+  tsx: TSX_VERSION
+};
+var ORM_SCRIPT_DESCRIPTIONS = {
+  "db:generate": "Regenerate Prisma Client from prisma/schema.prisma.",
+  "db:validate": "Validate prisma/schema.prisma and prisma.config.ts.",
+  "db:migrate": "Create and apply a local development migration.",
+  "db:migrate:deploy": "Apply committed migrations in CI or production.",
+  "db:migrate:status": "Show whether database migrations are in sync.",
+  "db:push": "Push the Prisma schema to the database without a migration.",
+  "db:pull": "Introspect the database and update the Prisma schema.",
+  "db:studio": "Open Prisma Studio for local data browsing."
+};
+function buildOrmHelpScript() {
+  const lines = [
+    "Prisma database commands:",
+    ...Object.entries(ORM_SCRIPT_DESCRIPTIONS).map(
+      ([script, description]) => `  pnpm ${script.padEnd(18)} ${description}`
+    )
+  ];
+  const source = `console.log(${JSON.stringify(lines.join("\n"))})`;
+  return `node -e ${JSON.stringify(source)}`;
+}
+var ORM_SCRIPTS = {
+  "db:help": buildOrmHelpScript(),
+  "db:generate": "prisma generate",
+  "db:validate": "prisma validate",
+  "db:migrate": "prisma migrate dev",
+  "db:migrate:deploy": "prisma migrate deploy",
+  "db:migrate:status": "prisma migrate status",
+  "db:push": "prisma db push",
+  "db:pull": "prisma db pull",
+  "db:studio": "prisma studio"
+};
+function buildPostgresDatabaseName(projectName) {
+  const normalized = projectName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+  return normalized || "app";
+}
+function buildDatabaseUrlExample(projectName) {
+  return `postgresql://postgres:postgres@localhost:5432/${buildPostgresDatabaseName(projectName)}`;
+}
+function buildOrmEnvFragment(projectName) {
+  return {
+    variables: [
+      {
+        name: "DATABASE_URL",
+        scope: "server",
+        schema: "z.string().url()",
+        example: buildDatabaseUrlExample(projectName)
+      }
+    ]
+  };
+}
+
+// src/config/server-actions-fragments.ts
+var NEXT_SAFE_ACTION_VERSION = "^8.5.2";
+var NEXT_SAFE_ACTION_BETTER_AUTH_ADAPTER_VERSION = "^0.1.6";
+var SERVER_ACTIONS_DEPENDENCIES = {
+  "next-safe-action": NEXT_SAFE_ACTION_VERSION
+};
+var SERVER_ACTIONS_AUTH_DEPENDENCIES = {
+  "@next-safe-action/adapter-better-auth": NEXT_SAFE_ACTION_BETTER_AUTH_ADAPTER_VERSION
+};
+
+// src/config/state-fragments.ts
+var NUQS_VERSION = "^2.8.9";
+var ZUSTAND_VERSION = "^5.0.12";
+var STATE_DEPENDENCIES = {
+  nuqs: NUQS_VERSION,
+  zustand: ZUSTAND_VERSION
+};
+
+// src/config/package-deps-baseline.ts
+var PACKAGE_DEPS_BASELINE = {
+  ...AI_CHAT_DEPENDENCIES,
+  ...AUTH_DEPENDENCIES,
+  ...ENV_MANAGEMENT_DEPENDENCIES,
+  ...FORM_HANDLING_DEPENDENCIES,
+  ...I18N_DEPENDENCIES,
+  ...ORM_DEPENDENCIES,
+  ...SERVER_ACTIONS_DEPENDENCIES,
+  ...STATE_DEPENDENCIES
+};
+
+// src/config/eslint-prettier-fragments.ts
+var PRETTIER_VERSION = "^3.8.3";
+var ESLINT_CONFIG_PRETTIER_VERSION = "^10.1.8";
+var PRETTIER_RC_BASELINE = {
+  semi: true,
+  singleQuote: false,
+  trailingComma: "all",
+  printWidth: 80,
+  tabWidth: 2,
+  endOfLine: "lf"
+};
+var ESLINT_PRETTIER_DEV_DEPS = {
+  prettier: PRETTIER_VERSION,
+  "eslint-config-prettier": ESLINT_CONFIG_PRETTIER_VERSION
+};
+var ESLINT_PRETTIER_SCRIPTS = {
+  lint: "eslint && prettier --check .",
+  format: "prettier --write .",
+  "format:check": "prettier --check ."
+};
+
+// src/config/package-dev-deps-baseline.ts
+var PACKAGE_DEV_DEPS_BASELINE = {
+  ...ESLINT_PRETTIER_DEV_DEPS,
+  ...ORM_DEV_DEPENDENCIES
+};
+
+// src/config/package-scripts-baseline.ts
+var PACKAGE_SCRIPTS_BASELINE = {
+  dev: "next dev",
+  build: "next build",
+  start: "next start",
+  ...ESLINT_PRETTIER_SCRIPTS,
+  ...ORM_SCRIPTS
+};
+
+// src/config/pre-commit-fragments.ts
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname3, join as join5, resolve as resolve5 } from "path";
+var PRE_COMMIT_COMMON_SCRIPTS = {
+  typecheck: "tsc --noEmit"
+};
+var PRE_COMMIT_STANDALONE_SCRIPTS = {
+  prepare: "pnpm dlx @j178/prek install"
+};
+var PRE_COMMIT_MONOREPO_SCRIPTS = {
+  "pre-commit": "pnpm dlx @j178/prek run --directory ."
+};
+function buildPrekTomlContents() {
+  return renderTemplateFile("pre-commit/prek.toml.ejs", {});
+}
+function inferPreCommitMode(targetDir) {
+  let current = dirname3(resolve5(targetDir));
+  while (true) {
+    if (existsSync4(join5(current, ".git"))) return "monorepo";
+    const parent = dirname3(current);
+    if (parent === current) return "standalone";
+    current = parent;
+  }
+}
+function buildPreCommitScripts(mode) {
+  return {
+    ...PRE_COMMIT_COMMON_SCRIPTS,
+    ...mode === "standalone" ? PRE_COMMIT_STANDALONE_SCRIPTS : PRE_COMMIT_MONOREPO_SCRIPTS
+  };
+}
+
+// src/config/next-config-contents.ts
+function shouldEnableAuthInterrupts(context) {
+  return context ? context.config.authStrategy !== "none" : false;
+}
+function shouldEnableNextIntl(context) {
+  return context ? context.config.i18n === true : false;
+}
+function buildNextConfigTsContents(context) {
+  return renderTemplateFile("core/next.config.ts.ejs", {
+    authInterrupts: shouldEnableAuthInterrupts(context),
+    nextIntl: shouldEnableNextIntl(context)
+  });
+}
+
+// src/config/tsconfig-managed-baseline.ts
+var BASE_EXCLUDE = [
+  "node_modules",
+  // shadcn/ui registry files are generated vendor code. Imported components
+  // are still checked through their app imports.
+  "src/components/ui/**/*.tsx",
+  "src/hooks/use-mobile.ts"
+];
+function buildTsconfigManagedBaseline(config) {
+  const exclude = [
+    ...BASE_EXCLUDE,
+    ...config.aiChat ? ["src/components/ai-elements/**/*.tsx"] : []
+  ];
+  return {
+    ...TSCONFIG_MANAGED_BASELINE,
+    exclude
+  };
+}
+var TSCONFIG_MANAGED_BASELINE = {
+  compilerOptions: {
+    target: "ES2017",
+    lib: ["dom", "dom.iterable", "esnext"],
+    allowJs: true,
+    skipLibCheck: true,
+    strict: true,
+    noEmit: true,
+    esModuleInterop: true,
+    module: "esnext",
+    moduleResolution: "bundler",
+    resolveJsonModule: true,
+    isolatedModules: true,
+    jsx: "react-jsx",
+    incremental: true,
+    plugins: [{ name: "next" }],
+    // "Super Duper" Strictness Additions
+    noUncheckedIndexedAccess: true,
+    exactOptionalPropertyTypes: true,
+    noPropertyAccessFromIndexSignature: true,
+    noImplicitOverride: true,
+    // Code Cleanliness
+    noUnusedLocals: true,
+    noUnusedParameters: true,
+    noImplicitReturns: true,
+    noFallthroughCasesInSwitch: true,
+    // Modern Environment
+    forceConsistentCasingInFileNames: true,
+    verbatimModuleSyntax: true
+  },
+  include: [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  exclude: BASE_EXCLUDE
+};
+
+// src/sync/targets.ts
+function inferOrmProvider(context) {
+  if (!context) return "none";
+  return existsSync5(join6(context.projectRoot, "prisma/schema.prisma")) ? "prisma" : "none";
+}
+function inferAuthStrategy(context) {
+  if (!context) return "none";
+  return existsSync5(join6(context.projectRoot, "src/lib/auth.ts")) ? "stateless" : "none";
+}
+function inferAiChat(context) {
+  if (!context) return false;
+  return existsSync5(join6(context.projectRoot, "src/app/chat/_hooks/useChat.ts")) || existsSync5(join6(context.projectRoot, "src/app/api/chat/route.ts"));
+}
+function inferI18n(context) {
+  if (!context) return false;
+  return existsSync5(join6(context.projectRoot, "src/i18n/routing.ts")) || existsSync5(join6(context.projectRoot, "messages/en.json"));
+}
+function inferScaleStackConfig(context) {
+  return {
+    projectName: context ? "synced-project" : "project",
+    orm: inferOrmProvider(context),
+    authStrategy: inferAuthStrategy(context),
+    aiChat: inferAiChat(context),
+    i18n: inferI18n(context),
+    ci: "none",
+    analytics: "none",
+    jobs: false,
+    a11y: false,
+    apiClient: false,
+    preCommit: context ? hasPrekConfig(context) : false
+  };
+}
+function hasPrekConfig(context) {
+  return existsSync5(join6(context.projectRoot, "prek.toml"));
+}
+var SYNC_TARGETS = [
+  {
+    relativePath: "tsconfig.json",
+    kind: "json",
+    getDesiredFragment: (context) => structuredClone(
+      buildTsconfigManagedBaseline(inferScaleStackConfig(context))
+    )
+  },
+  {
+    relativePath: "package.json",
+    kind: "json",
+    getDesiredFragment: (context) => ({
+      scripts: {
+        ...structuredClone(PACKAGE_SCRIPTS_BASELINE),
+        ...context && hasPrekConfig(context) ? buildPreCommitScripts(inferPreCommitMode(context.projectRoot)) : {}
+      },
+      dependencies: structuredClone(PACKAGE_DEPS_BASELINE),
+      devDependencies: structuredClone(PACKAGE_DEV_DEPS_BASELINE)
+    })
+  },
+  {
+    relativePath: "next.config.ts",
+    kind: "text",
+    getDesiredContent: (context) => buildNextConfigTsContents({
+      config: {
+        authStrategy: inferAuthStrategy(context),
+        i18n: inferI18n(context)
+      }
+    })
+  },
+  {
+    relativePath: "eslint.config.mjs",
+    kind: "text",
+    getDesiredContent: (context) => buildEslintConfigMjsContents(inferScaleStackConfig(context))
+  },
+  {
+    relativePath: ".prettierrc",
+    kind: "json",
+    getDesiredFragment: () => structuredClone(PRETTIER_RC_BASELINE)
+  },
+  {
+    relativePath: "prek.toml",
+    kind: "text",
+    condition: hasPrekConfig,
+    getDesiredContent: () => buildPrekTomlContents()
+  }
+];
+
+// src/sync/last-sync.ts
+import { readFile as readFile2, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
+
+// src/sync/constants.ts
+var MIGRATION_GUIDE_URL = "https://github.com/scaleapi/scale-stack/blob/main/IMPLEMENTATION_PLAN.md#phase-5--sync-command-early-validation";
+var SCALE_STACK_DIR = ".scale-stack";
+var LAST_SYNC_FILE = ".scale-stack/last-sync.json";
+var SYNC_LOG_FILE = ".scale-stack/sync.log";
+var PRE_SYNC_BACKUP_DIR = ".scale-stack/pre-sync-backup";
+
+// src/sync/last-sync.ts
+import { cloneDeep } from "es-toolkit/compat";
+function isTextMarker(v) {
+  return typeof v === "object" && v !== null && "__content" in v && typeof v.__content === "string";
+}
+async function readLastSync(projectRoot) {
+  const abs = join7(projectRoot, LAST_SYNC_FILE);
+  if (!existsSync6(abs)) return null;
+  try {
+    const raw = await readFile2(abs, "utf-8");
+    const data = JSON.parse(raw);
+    if (!data || typeof data.cliVersion !== "string" || !data.files) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+async function writeLastSync(projectRoot, data) {
+  const abs = join7(projectRoot, LAST_SYNC_FILE);
+  await mkdir3(dirname4(abs), { recursive: true });
+  const body = `${JSON.stringify(data, null, 2)}
+`;
+  await writeFile3(abs, body, "utf-8");
+}
+function getJsonFragment(last, relativePath) {
+  const entry = last?.files?.[relativePath];
+  if (!entry || isTextMarker(entry)) return void 0;
+  return cloneDeep(entry);
+}
+function getTextContent(last, relativePath) {
+  const entry = last?.files?.[relativePath];
+  if (!entry || !isTextMarker(entry)) return void 0;
+  return entry.__content;
+}
+
+// src/sync/version-guard.ts
+import semver from "semver";
+var SyncVersionAbortError = class extends Error {
+  constructor(message, recorded, current) {
+    super(message);
+    this.recorded = recorded;
+    this.current = current;
+    this.name = "SyncVersionAbortError";
+  }
+  recorded;
+  current;
+  code = "SYNC_VERSION_ABORT";
+};
+function assertSyncVersionCompatible(recordedVersion, currentVersion) {
+  if (!recordedVersion?.trim()) return;
+  const rec = semver.coerce(recordedVersion);
+  const cur = semver.coerce(currentVersion);
+  if (!rec || !cur) return;
+  if (cur.major > rec.major + 1) {
+    throw new SyncVersionAbortError(
+      `Scale Stack CLI (${currentVersion}) is more than one major version ahead of the project baseline (${recordedVersion}). See the migration guide: ${MIGRATION_GUIDE_URL}`,
+      recordedVersion,
+      currentVersion
+    );
+  }
+}
+
+// src/sync/internal/log-entry.ts
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { join as join8 } from "path";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function appendSyncLog(projectRoot, entries) {
+  if (entries.length === 0) return;
+  const dir = join8(projectRoot, SCALE_STACK_DIR);
+  await mkdir4(dir, { recursive: true });
+  const logPath = join8(projectRoot, SYNC_LOG_FILE);
+  const lines = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+  await writeFile4(logPath, lines, { flag: "a", encoding: "utf-8" });
+}
+
+// src/sync/internal/backup.ts
+import { cp, mkdir as mkdir5, readdir as readdir2, rm as rm2 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import { join as join9 } from "path";
+async function snapshotFile(projectRoot, backupDir, relativePath) {
+  const src = join9(projectRoot, relativePath);
+  if (!existsSync7(src)) return;
+  const dest = join9(backupDir, relativePath);
+  await mkdir5(join9(dest, ".."), { recursive: true });
+  await cp(src, dest, { force: true });
+}
+async function removeDirIfExists(abs) {
+  if (existsSync7(abs)) await rm2(abs, { recursive: true, force: true });
+}
+async function snapshotBackup(projectRoot, plannedPaths) {
+  if (plannedPaths.length === 0) return void 0;
+  const backupRoot = join9(projectRoot, PRE_SYNC_BACKUP_DIR);
+  const sessionBackup = join9(backupRoot, `backup-${Date.now()}`);
+  await mkdir5(sessionBackup, { recursive: true });
+  const newlyCreated = /* @__PURE__ */ new Set();
+  for (const rel of plannedPaths) {
+    const abs = join9(projectRoot, rel);
+    if (existsSync7(abs)) {
+      await snapshotFile(projectRoot, sessionBackup, rel);
+    } else {
+      newlyCreated.add(rel);
+    }
+  }
+  return { sessionBackup, newlyCreated };
+}
+async function cleanupBackup(projectRoot, session) {
+  await removeDirIfExists(session.sessionBackup);
+  const backupRoot = join9(projectRoot, PRE_SYNC_BACKUP_DIR);
+  try {
+    const entries = await readdir2(backupRoot);
+    if (entries.length === 0) await removeDirIfExists(backupRoot);
+  } catch {
+  }
+}
+async function restoreFromBackup(projectRoot, session, plannedPaths) {
+  for (const rel of plannedPaths) {
+    const abs = join9(projectRoot, rel);
+    if (session?.newlyCreated.has(rel)) {
+      if (existsSync7(abs)) await rm2(abs, { force: true });
+      continue;
+    }
+    if (session) {
+      const snap = join9(session.sessionBackup, rel);
+      if (existsSync7(snap)) {
+        await cp(snap, abs, { force: true });
+      }
+    }
+  }
+}
+
+// src/sync/internal/apply-json-target.ts
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { join as join10 } from "path";
+import { isEqual as isEqual2 } from "es-toolkit/predicate";
+
+// src/lib/merge/managed-json.ts
+import { isEqual } from "es-toolkit/predicate";
+
+// src/lib/merge/json-path-utils.ts
+import { cloneDeep as cloneDeep2, get, set } from "es-toolkit/compat";
+function hasDottedPath(root, dotted) {
+  const parts = dotted.split(".");
+  let cur = root;
+  for (const p2 of parts) {
+    if (cur === null || typeof cur !== "object" || Array.isArray(cur))
+      return false;
+    if (!Object.prototype.hasOwnProperty.call(cur, p2)) return false;
+    cur = cur[p2];
+  }
+  return true;
+}
+function getAt(obj, path) {
+  if (path === "") return obj;
+  return get(obj, path);
+}
+function setAt(root, path, value) {
+  if (path === "") {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      return { ...value };
+    }
+    throw new Error(`setAt: cannot replace root with non-object at empty path`);
+  }
+  const draft = cloneDeep2(root);
+  set(draft, path, value);
+  return draft;
+}
+function deepCloneJson(v) {
+  return cloneDeep2(v);
+}
+
+// src/lib/merge/json-shape.ts
+function listLeafPathsFromBaseline(baseline, options) {
+  const exclude = new Set(options?.excludeExactPaths ?? []);
+  return leafPaths(baseline, "", exclude);
+}
+function leafPaths(v, prefix, exclude) {
+  if (v === null || typeof v !== "object") {
+    return prefix ? [prefix] : [];
+  }
+  if (Array.isArray(v)) {
+    return prefix ? [prefix] : [];
+  }
+  const o = v;
+  const keys = Object.keys(o);
+  if (keys.length === 0) return prefix ? [prefix] : [];
+  const out = [];
+  for (const k of keys) {
+    const p2 = prefix ? `${prefix}.${k}` : k;
+    if (exclude.has(p2)) {
+      continue;
+    }
+    const child = o[k];
+    if (child !== null && typeof child === "object" && !Array.isArray(child)) {
+      const nested = leafPaths(child, p2, exclude);
+      out.push(...nested);
+    } else {
+      out.push(p2);
+    }
+  }
+  return out;
+}
+function extractManagedFragment(disk, baseline) {
+  const out = {};
+  for (const k of Object.keys(baseline)) {
+    const b = baseline[k];
+    const d = disk[k];
+    if (b === null || typeof b !== "object" || Array.isArray(b)) {
+      out[k] = d !== void 0 ? deepCloneLeaf(d) : b;
+    } else if (typeof d === "object" && d !== null && !Array.isArray(d)) {
+      out[k] = extractManagedFragment(
+        d,
+        b
+      );
+    } else {
+      out[k] = d !== void 0 ? deepCloneLeaf(d) : deepCloneLeaf(b);
+    }
+  }
+  return out;
+}
+function deepCloneLeaf(v) {
+  if (v === null || typeof v !== "object") return v;
+  return JSON.parse(JSON.stringify(v));
+}
+
+// src/lib/merge/managed-json.ts
+function mergeManagedJson(options) {
+  const {
+    fileLabel,
+    disk,
+    desiredFragment,
+    lastFileFragment,
+    hasGlobalLastSync,
+    force,
+    managedPaths
+  } = options;
+  const conflicts = [];
+  const skippedPaths = [];
+  const appliedPaths = [];
+  let merged = deepCloneJson(disk);
+  for (const path of managedPaths) {
+    const desiredVal = getAt(desiredFragment, path);
+    const diskVal = getAt(disk, path);
+    let hasConflict = false;
+    if (hasGlobalLastSync && lastFileFragment !== void 0 && hasDottedPath(lastFileFragment, path)) {
+      const prevVal = getAt(lastFileFragment, path);
+      if (!isEqual(diskVal, prevVal)) {
+        hasConflict = true;
+      }
+    }
+    if (hasConflict && !force) {
+      conflicts.push({ relativePath: fileLabel, path });
+      skippedPaths.push(path);
+      continue;
+    }
+    if (hasConflict && force) {
+      merged = setAt(merged, path, desiredVal);
+      appliedPaths.push(path);
+      continue;
+    }
+    if (!isEqual(diskVal, desiredVal)) {
+      merged = setAt(merged, path, desiredVal);
+      appliedPaths.push(path);
+    }
+  }
+  return { merged, conflicts, appliedPaths, skippedPaths };
+}
+function mergeJsonFile(options) {
+  const {
+    relativePath,
+    disk,
+    desiredFragment,
+    lastFileFragment,
+    hasGlobalLastSync,
+    force
+  } = options;
+  const managedPaths = listLeafPathsFromBaseline(desiredFragment);
+  return mergeManagedJson({
+    fileLabel: relativePath,
+    disk,
+    desiredFragment,
+    lastFileFragment,
+    hasGlobalLastSync,
+    force,
+    managedPaths
+  });
+}
+function mergeManagedJsonString(options) {
+  const { relativePath, existingContent, desiredFragment } = options;
+  const disk = JSON.parse(existingContent);
+  const { merged } = mergeJsonFile({
+    relativePath,
+    disk,
+    desiredFragment,
+    lastFileFragment: void 0,
+    hasGlobalLastSync: false,
+    force: false
+  });
+  return merged;
+}
+function formatMergedJson(merged) {
+  return `${JSON.stringify(merged, null, 2)}
+`;
+}
+
+// src/sync/internal/apply-json-target.ts
+async function applyJsonTarget(options) {
+  const { projectRoot, target, lastSync, hasGlobalLastSync, force } = options;
+  const rel = target.relativePath;
+  const abs = join10(projectRoot, rel);
+  const logEntries = [];
+  let diskObj;
+  if (!existsSync8(abs)) {
+    diskObj = {};
+  } else {
+    try {
+      diskObj = JSON.parse(await readFile3(abs, "utf-8"));
+    } catch {
+      const err = new Error(`Invalid JSON: ${rel}`);
+      logEntries.push({
+        timestamp: nowIso(),
+        level: "error",
+        message: err.message,
+        file: rel
+      });
+      return { ok: false, error: err, logEntries };
+    }
+  }
+  const desired = target.getDesiredFragment({ projectRoot });
+  const lastFileFragment = getJsonFragment(lastSync, rel);
+  const outcome = mergeJsonFile({
+    relativePath: rel,
+    disk: diskObj,
+    desiredFragment: desired,
+    lastFileFragment,
+    hasGlobalLastSync,
+    force
+  });
+  for (const c of outcome.conflicts) {
+    logEntries.push({
+      timestamp: nowIso(),
+      level: "skip",
+      message: "Conflict on managed key \u2014 skipped (use --force to overwrite)",
+      file: c.relativePath,
+      path: c.path
+    });
+  }
+  for (const p2 of outcome.appliedPaths) {
+    logEntries.push({
+      timestamp: nowIso(),
+      level: "info",
+      message: "Applied managed key",
+      file: rel,
+      path: p2
+    });
+  }
+  const changed = !isEqual2(outcome.merged, diskObj);
+  let nextFragment = extractManagedFragment(outcome.merged, desired);
+  if (!force && lastFileFragment !== void 0 && outcome.skippedPaths.length > 0) {
+    for (const path of outcome.skippedPaths) {
+      const prev = getAt(lastFileFragment, path);
+      nextFragment = setAt(nextFragment, path, prev);
+    }
+  }
+  let conflictForcedContent;
+  if (!force && outcome.conflicts.length > 0) {
+    const forced = mergeJsonFile({
+      relativePath: rel,
+      disk: diskObj,
+      desiredFragment: desired,
+      lastFileFragment,
+      hasGlobalLastSync,
+      force: true
+    });
+    if (!isEqual2(forced.merged, diskObj)) {
+      conflictForcedContent = formatMergedJson(forced.merged);
+    }
+  }
+  return {
+    ok: true,
+    plannedContent: changed ? formatMergedJson(outcome.merged) : void 0,
+    conflictForcedContent,
+    nextFragment,
+    logEntries
+  };
+}
+
+// src/sync/internal/apply-text-target.ts
+import { readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import { join as join11 } from "path";
+
+// src/lib/merge/text.ts
+function mergeTextFile(options) {
+  const { disk, desired, lastContent, hasGlobalLastSync, force } = options;
+  let conflict = false;
+  if (hasGlobalLastSync && lastContent !== void 0 && disk !== lastContent) {
+    conflict = true;
+  }
+  if (conflict && !force) {
+    return { merged: disk, conflict: true, applied: false };
+  }
+  if (disk === desired) {
+    return { merged: disk, conflict: false, applied: false };
+  }
+  return { merged: desired, conflict, applied: true };
+}
+
+// src/sync/internal/apply-text-target.ts
+async function applyTextTarget(options) {
+  const { projectRoot, target, lastSync, hasGlobalLastSync, force } = options;
+  const rel = target.relativePath;
+  const abs = join11(projectRoot, rel);
+  const logEntries = [];
+  const desired = await target.getDesiredContent({ projectRoot });
+  const diskText = existsSync9(abs) ? await readFile4(abs, "utf-8") : "";
+  const lastContent = getTextContent(lastSync, rel);
+  const out = mergeTextFile({
+    disk: diskText,
+    desired,
+    lastContent,
+    hasGlobalLastSync,
+    force
+  });
+  if (out.conflict && !force) {
+    logEntries.push({
+      timestamp: nowIso(),
+      level: "skip",
+      message: "Conflict on managed file \u2014 skipped (use --force to overwrite)",
+      file: rel
+    });
+  } else if (out.applied) {
+    logEntries.push({
+      timestamp: nowIso(),
+      level: "info",
+      message: "Applied managed file content",
+      file: rel
+    });
+  }
+  const nextContent = out.conflict && !force && lastContent !== void 0 ? lastContent : out.merged;
+  const conflictForcedContent = out.conflict && !force && desired !== diskText ? desired : void 0;
+  return {
+    plannedContent: out.merged !== diskText ? out.merged : void 0,
+    conflictForcedContent,
+    nextMarker: { __content: nextContent },
+    logEntries
+  };
+}
+
+// src/sync/run-sync.ts
+var execAsync2 = promisify2(exec2);
+async function runSync(opts) {
+  const { projectRoot, dryRun, force, keepBackup } = opts;
+  const logEntries = [];
+  const guardResult = await guardProjectRoot(projectRoot);
+  if (!guardResult.ok) {
+    logEntries.push({
+      timestamp: nowIso(),
+      level: "error",
+      message: guardResult.error.message
+    });
+    return { ok: false, error: guardResult.error, logEntries };
+  }
+  const currentCli = getCliVersion();
+  const lastSync = await readLastSync(projectRoot);
+  try {
+    assertSyncVersionCompatible(lastSync?.cliVersion, currentCli);
+  } catch (e) {
+    if (e instanceof SyncVersionAbortError) {
+      logEntries.push({
+        timestamp: nowIso(),
+        level: "error",
+        message: e.message
+      });
+      return { ok: false, error: e, logEntries };
+    }
+    throw e;
+  }
+  const hasGlobalLastSync = lastSync !== null;
+  const nextLast = {
+    cliVersion: currentCli,
+    files: { ...lastSync?.files ?? {} }
+  };
+  const plannedWrites = /* @__PURE__ */ new Map();
+  const conflictForcedWrites = /* @__PURE__ */ new Map();
+  const changedFiles = [];
+  for (const target of SYNC_TARGETS) {
+    const rel = target.relativePath;
+    const context = { projectRoot };
+    if (target.condition && !target.condition(context)) {
+      continue;
+    }
+    if (target.kind === "json") {
+      const outcome2 = await applyJsonTarget({
+        projectRoot,
+        target,
+        lastSync,
+        hasGlobalLastSync,
+        force
+      });
+      logEntries.push(...outcome2.logEntries);
+      if (!outcome2.ok) {
+        return { ok: false, error: outcome2.error, logEntries };
+      }
+      if (outcome2.plannedContent !== void 0) {
+        plannedWrites.set(rel, outcome2.plannedContent);
+        changedFiles.push(rel);
+      }
+      if (outcome2.conflictForcedContent !== void 0) {
+        conflictForcedWrites.set(rel, outcome2.conflictForcedContent);
+      }
+      nextLast.files[rel] = outcome2.nextFragment;
+      continue;
+    }
+    const outcome = await applyTextTarget({
+      projectRoot,
+      target,
+      lastSync,
+      hasGlobalLastSync,
+      force
+    });
+    logEntries.push(...outcome.logEntries);
+    if (outcome.plannedContent !== void 0) {
+      plannedWrites.set(rel, outcome.plannedContent);
+      changedFiles.push(rel);
+    }
+    if (outcome.conflictForcedContent !== void 0) {
+      conflictForcedWrites.set(rel, outcome.conflictForcedContent);
+    }
+    nextLast.files[rel] = outcome.nextMarker;
+  }
+  const conflictDiffs = await buildConflictDiffs(
+    projectRoot,
+    conflictForcedWrites
+  );
+  const agentPrompt = buildAgentPrompt(conflictDiffs);
+  if (dryRun) {
+    await emitDryRunDiffs(projectRoot, plannedWrites);
+    logEntries.push({
+      timestamp: nowIso(),
+      level: "info",
+      message: `Dry-run: ${plannedWrites.size} file(s) would change`
+    });
+    return {
+      ok: true,
+      dryRun: true,
+      changedFiles: [...changedFiles],
+      conflictDiffs,
+      agentPrompt,
+      logEntries
+    };
+  }
+  const rollbackPaths = [.../* @__PURE__ */ new Set([...plannedWrites.keys(), LAST_SYNC_FILE])];
+  const backup = await snapshotBackup(projectRoot, rollbackPaths);
+  try {
+    await commitPlannedWrites(projectRoot, plannedWrites);
+    await writeLastSync(projectRoot, nextLast);
+    await appendSyncLog(projectRoot, logEntries);
+    if (backup && !keepBackup) {
+      await cleanupBackup(projectRoot, backup);
+    }
+    const { skillsStdout, skillsError } = await runSkillsUpdate({
+      projectRoot,
+      enabled: plannedWrites.size > 0
+    });
+    if (skillsError) {
+      await appendSyncLog(projectRoot, [
+        {
+          timestamp: nowIso(),
+          level: "warn",
+          message: skillsError.message
+        }
+      ]);
+    }
+    return {
+      ok: true,
+      dryRun: false,
+      changedFiles: [...changedFiles],
+      conflictDiffs,
+      agentPrompt,
+      logEntries,
+      skillsStdout,
+      ...skillsError && { skillsError }
+    };
+  } catch (e) {
+    const err = e instanceof Error ? e : new Error(String(e));
+    await restoreFromBackup(projectRoot, backup, rollbackPaths);
+    logEntries.push({
+      timestamp: nowIso(),
+      level: "error",
+      message: err.message
+    });
+    return { ok: false, error: err, logEntries };
+  }
+}
+async function guardProjectRoot(projectRoot) {
+  const pkgPath = join12(projectRoot, "package.json");
+  if (!existsSync10(pkgPath)) {
+    return {
+      ok: false,
+      error: new Error(
+        `No package.json in ${projectRoot}. Run scale-stack sync from a project root.`
+      )
+    };
+  }
+  try {
+    const pkgRaw = await readFile5(pkgPath, "utf-8");
+    const pkg = JSON.parse(pkgRaw);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (!deps.next) {
+      return {
+        ok: false,
+        error: new Error(
+          "scale-stack sync applies to Next.js app projects (missing next dependency)."
+        )
+      };
+    }
+    return { ok: true };
+  } catch (e) {
+    return {
+      ok: false,
+      error: e instanceof Error ? e : new Error(`Invalid package.json: ${String(e)}`)
+    };
+  }
+}
+async function emitDryRunDiffs(projectRoot, plannedWrites) {
+  for (const [rel, content] of plannedWrites) {
+    const abs = join12(projectRoot, rel);
+    const before = existsSync10(abs) ? await readFile5(abs, "utf-8") : "";
+    const patch = createPatch2(rel, before, content, "", "");
+    console.log(patch);
+  }
+}
+async function buildConflictDiffs(projectRoot, conflictForcedWrites) {
+  const out = [];
+  for (const [rel, content] of conflictForcedWrites) {
+    const abs = join12(projectRoot, rel);
+    const before = existsSync10(abs) ? await readFile5(abs, "utf-8") : "";
+    const diff = createPatch2(rel, before, content, "current", "canonical");
+    out.push({ file: rel, diff });
+  }
+  return out;
+}
+function buildAgentPrompt(conflictDiffs) {
+  if (conflictDiffs.length === 0) return void 0;
+  const files = conflictDiffs.map((d) => d.file);
+  const fileList = files.map((f) => `  - ${f}`).join("\n");
+  const diffBlocks = conflictDiffs.map(
+    ({ file, diff }) => [
+      `--- BEGIN diff: ${file} ---`,
+      diff.replace(/\n+$/, ""),
+      `--- END diff: ${file} ---`
+    ].join("\n")
+  ).join("\n\n");
+  return [
+    "You are resolving sync conflicts reported by `scale-stack sync`.",
+    "",
+    "Each conflicted file is included below as a unified diff wrapped in",
+    "`--- BEGIN diff: <file> --- ... --- END diff: <file> ---`. Within each block:",
+    "  * `-` lines are the user's current content on disk.",
+    "  * `+` lines are the Scale Stack canonical (what `--force` would write).",
+    "",
+    diffBlocks,
+    "",
+    "For every listed file, produce a merged version that:",
+    "  1. preserves the user's intentional edits that don't contradict the canonical intent,",
+    "  2. incorporates every canonical change (the `+` side),",
+    "  3. is written back to disk at its given relative path.",
+    "",
+    "Conflicted files (relative to project root):",
+    fileList,
+    "",
+    "Do NOT run `scale-stack sync --force` \u2014 it would discard the user's edits.",
+    'After merging, run `scale-stack sync` to verify: it must report "Already up to date".'
+  ].join("\n");
+}
+async function commitPlannedWrites(projectRoot, plannedWrites) {
+  for (const [rel, content] of plannedWrites) {
+    const abs = join12(projectRoot, rel);
+    await mkdir6(join12(abs, ".."), { recursive: true });
+    await writeFile5(abs, content, "utf-8");
+  }
+}
+async function runSkillsUpdate(options) {
+  if (!options.enabled) return {};
+  if (process.env.SCALE_STACK_SKIP_SKILLS_UPDATE === "1") return {};
+  try {
+    const { stdout, stderr } = await execAsync2("pnpm dlx skills update", {
+      cwd: options.projectRoot,
+      maxBuffer: 20 * 1024 * 1024,
+      env: { ...process.env }
+    });
+    return { skillsStdout: (stdout || "") + (stderr || "") };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : `skills update failed: ${String(e)}`;
+    return { skillsError: new Error(`pnpm dlx skills update failed: ${msg}`) };
+  }
+}
+
+// src/cli/commands/sync.ts
+function groupSkipsByFile(entries) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    if (e.level !== "skip" || !e.file) continue;
+    const existing = byFile.get(e.file) ?? [];
+    if (e.path) existing.push(e.path);
+    byFile.set(e.file, existing);
+  }
+  return byFile;
+}
+function renderSkippedConflicts(skips) {
+  const fileCount = skips.size;
+  if (fileCount === 0) return;
+  console.log(
+    pc6.yellow(`  \u26A0 ${fileCount} managed file(s) skipped due to local changes:`)
+  );
+  for (const [file, paths] of skips) {
+    const detail = paths.length > 0 ? ` (${paths.join(", ")})` : "";
+    console.log(pc6.yellow(`    - ${file}${detail}`));
+  }
+  console.log(
+    ikea.muted(
+      `    Run \`scale-stack sync --force\` to overwrite with Scale Stack baselines.`
+    )
+  );
+}
+function colorizeDiffLine(line) {
+  if (line.startsWith("+++") || line.startsWith("---")) return ikea.muted(line);
+  if (line.startsWith("@@")) return pc6.cyan(line);
+  if (line.startsWith("+")) return pc6.green(line);
+  if (line.startsWith("-")) return pc6.red(line);
+  return line;
+}
+function renderConflictDiffs(diffs) {
+  if (diffs.length === 0) return;
+  console.log();
+  console.log(ikea.muted("  Proposed merge (what --force would write):"));
+  for (const { file, diff } of diffs) {
+    console.log();
+    console.log(pc6.cyan(`  \u2508 --- BEGIN diff: ${file} ---`));
+    for (const line of diff.split("\n")) {
+      console.log(colorizeDiffLine(line));
+    }
+    console.log(pc6.cyan(`  \u2508 --- END diff: ${file} ---`));
+  }
+}
+function renderAgentPrompt(prompt) {
+  if (!prompt) return;
+  console.log();
+  console.log(
+    ikea.muted(
+      "  Paste this prompt into an agent to reconcile the conflicts above:"
+    )
+  );
+  console.log();
+  console.log(pc6.cyan("  \u2508 --- BEGIN agent prompt ---"));
+  for (const line of prompt.split("\n")) console.log(line);
+  console.log(pc6.cyan("  \u2508 --- END agent prompt ---"));
+}
+function registerSyncCommand(program2) {
+  program2.command("sync").description("Update an existing SKALST\xC5KK project to the latest fittings").option("--dry-run", "Print diffs without writing files").option(
+    "--force",
+    "Overwrite user-modified managed keys with Scale Stack baselines"
+  ).option("--keep-backup", "Keep .scale-stack/pre-sync-backup/ after success").action(
+    async (opts) => {
+      const projectRoot = resolve6(process.cwd());
+      const result = await runSync({
+        projectRoot,
+        dryRun: Boolean(opts.dryRun),
+        force: Boolean(opts.force),
+        keepBackup: Boolean(opts.keepBackup)
+      });
+      if (!result.ok) {
+        console.log();
+        console.log(
+          pc6.red(
+            `  \u2717 ${result.error instanceof Error ? result.error.message : String(result.error)}`
+          )
+        );
+        console.log();
+        process.exitCode = 1;
+        return;
+      }
+      const skips = groupSkipsByFile(result.logEntries);
+      if (result.dryRun) {
+        console.log();
+        console.log(
+          ikea.muted(
+            `  ${pc6.cyan("\u25B8")} Dry-run complete (${result.changedFiles.length} file(s) would change).`
+          )
+        );
+        if (skips.size > 0) renderSkippedConflicts(skips);
+        renderConflictDiffs(result.conflictDiffs);
+        renderAgentPrompt(result.agentPrompt);
+        console.log();
+        return;
+      }
+      console.log();
+      if (result.changedFiles.length > 0) {
+        console.log(
+          pc6.green(
+            `  \u2713 Sync applied to ${result.changedFiles.length} file(s): ${result.changedFiles.join(", ")}`
+          )
+        );
+      } else if (skips.size === 0) {
+        console.log(
+          ikea.muted(
+            `  ${pc6.green("\u25B8")} Already up to date \u2014 no managed files changed.`
+          )
+        );
+      }
+      if (skips.size > 0) renderSkippedConflicts(skips);
+      renderConflictDiffs(result.conflictDiffs);
+      renderAgentPrompt(result.agentPrompt);
+      if (result.skillsError) {
+        console.log(
+          pc6.yellow(
+            `  \u26A0 skills update step did not complete: ${result.skillsError.message}`
+          )
+        );
+      }
+      console.log();
+    }
+  );
+}
+
+// src/lib/merge/package-json.ts
+function sortPackageSectionKeys(pkg, sectionName) {
+  const section = pkg[sectionName];
+  if (section === null || typeof section !== "object" || Array.isArray(section)) {
+    return pkg;
+  }
+  const sorted = {};
+  for (const key of Object.keys(section).sort()) {
+    sorted[key] = section[key];
+  }
+  return { ...pkg, [sectionName]: sorted };
+}
+function mergeManagedPackageJson(options) {
+  const merged = mergeManagedJsonString({
+    relativePath: "package.json",
+    existingContent: options.existingContent,
+    desiredFragment: options.desiredFragment
+  });
+  const sorted = options.sortSections.reduce(
+    (pkg, sectionName) => sortPackageSectionKeys(pkg, sectionName),
+    merged
+  );
+  return formatMergedJson(sorted);
+}
+
+// src/generators/core/agent-skills-init.ts
+var PHASE_4_1_BASELINE_AGENT_SKILLS = [
+  { repo: "vercel-labs/skills", skill: "find-skills" },
+  { repo: "vercel-labs/next-skills", skill: "next-best-practices" },
+  { repo: "vercel-labs/agent-skills", skill: "vercel-react-view-transitions" },
+  { repo: "vercel-labs/agent-skills", skill: "vercel-react-best-practices" },
+  { repo: "vercel-labs/agent-skills", skill: "vercel-composition-patterns" },
+  { repo: "vercel-labs/agent-skills", skill: "web-design-guidelines" }
+];
+function groupSkillsByRepo(specs) {
+  const order = [];
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const { repo, skill } of specs) {
+    let skills = byRepo.get(repo);
+    if (!skills) {
+      skills = [];
+      byRepo.set(repo, skills);
+      order.push(repo);
+    }
+    skills.push(skill);
+  }
+  return order.map((repo) => ({ repo, skills: byRepo.get(repo) ?? [] }));
+}
+function buildSkillsAddCommand(repo, skills) {
+  const skillFlags = skills.map((s) => `--skill ${s}`).join(" ");
+  return ["pnpm dlx skills add", repo, skillFlags, "-y"].filter(Boolean).join(" ");
+}
+var AGENT_SKILLS_EXEC_ENV = {
+  NPM_CONFIG_LOGLEVEL: "error"
+};
+var agentSkillsInitGenerator = {
+  name: "agent-skills-init",
+  dependencies: ["project-init"],
+  async execute(ctx) {
+    const groups = groupSkillsByRepo(PHASE_4_1_BASELINE_AGENT_SKILLS);
+    for (const { repo, skills } of groups) {
+      await ctx.exec(buildSkillsAddCommand(repo, skills), {
+        cwd: ctx.targetDir,
+        env: { ...AGENT_SKILLS_EXEC_ENV }
+      });
+    }
+  }
+};
+
+// src/generators/app-paths.ts
+function localizeAppRoutePath(outputPath, i18n) {
+  if (!i18n) return outputPath;
+  if (!outputPath.startsWith("src/app/")) return outputPath;
+  if (outputPath.startsWith("src/app/api/")) return outputPath;
+  return outputPath.replace("src/app/", "src/app/[locale]/");
+}
+
+// src/generators/ai-chat/ai-chat.ts
+var PHASE_22_AI_SDK_AGENT_SKILL_COMMAND = buildSkillsAddCommand(
+  "vercel/ai",
+  ["ai-sdk"]
+);
+var PHASE_22_AI_ELEMENTS_AGENT_SKILL_COMMAND = buildSkillsAddCommand(
+  "vercel/ai-elements",
+  ["ai-elements"]
+);
+var PHASE_22_AI_ELEMENTS_COMMAND = "pnpm dlx ai-elements@latest";
+var AI_CHAT_FILES = [
+  {
+    templatePath: "ai-chat/layout.tsx.ejs",
+    outputPath: "src/app/chat/layout.tsx"
+  },
+  {
+    templatePath: "ai-chat/page.tsx.ejs",
+    outputPath: "src/app/chat/page.tsx"
+  },
+  {
+    templatePath: "ai-chat/chat-panel.tsx.ejs",
+    outputPath: "src/app/chat/_components/ChatPanel.tsx"
+  },
+  {
+    templatePath: "ai-chat/use-chat.ts.ejs",
+    outputPath: "src/app/chat/_hooks/useChat.ts"
+  },
+  {
+    templatePath: "ai-chat/route.ts.ejs",
+    outputPath: "src/app/api/chat/route.ts"
+  }
+];
+function mergePackageJson(existing) {
+  const desiredFragment = {
+    dependencies: structuredClone(PACKAGE_DEPS_BASELINE)
+  };
+  return mergeManagedPackageJson({
+    existingContent: existing,
+    desiredFragment,
+    sortSections: ["dependencies"]
+  });
+}
+async function writeAiChatFiles(ctx) {
+  for (const file of AI_CHAT_FILES) {
+    const content = await ctx.template.renderFile(file.templatePath, {
+      i18n: ctx.config.i18n
+    });
+    ctx.fs.write(
+      localizeAppRoutePath(file.outputPath, ctx.config.i18n),
+      content
+    );
+  }
+}
+var aiChatGenerator = {
+  name: "ai-chat",
+  dependencies: ["ui"],
+  condition: (config) => config.aiChat === true,
+  async execute(ctx) {
+    ctx.fs.merge("package.json", mergePackageJson);
+    await ctx.exec(PHASE_22_AI_SDK_AGENT_SKILL_COMMAND, {
+      cwd: ctx.targetDir,
+      env: { ...AGENT_SKILLS_EXEC_ENV }
+    });
+    await ctx.exec(PHASE_22_AI_ELEMENTS_AGENT_SKILL_COMMAND, {
+      cwd: ctx.targetDir,
+      env: { ...AGENT_SKILLS_EXEC_ENV }
+    });
+    await ctx.exec(PHASE_22_AI_ELEMENTS_COMMAND, { cwd: ctx.targetDir });
+    await writeAiChatFiles(ctx);
+  }
+};
+
+// src/generators/ai-assistant/ai-assistant.ts
+var SCALE_STACK_AGENTS_START = "<!-- scale-stack:agents:start -->";
+var SCALE_STACK_AGENTS_END = "<!-- scale-stack:agents:end -->";
+var SCALE_STACK_CLAUDE_START = "<!-- scale-stack:claude:start -->";
+var SCALE_STACK_CLAUDE_END = "<!-- scale-stack:claude:end -->";
+var FALLBACK_AGENTS_MD = `# AGENTS.md
+`;
+var FALLBACK_CLAUDE_MD = `@AGENTS.md
+`;
+function hasAuth(config) {
+  return config.authStrategy !== "none";
+}
+function buildTechnologyGuides(config) {
+  const guides = [
+    {
+      name: "Next.js 16.2+ (App Router)",
+      purpose: "application framework",
+      selected: false
+    },
+    { name: "React 19", purpose: "UI runtime", selected: false },
+    { name: "Node 22+", purpose: "runtime target", selected: false },
+    { name: "pnpm", purpose: "exclusive package manager", selected: false },
+    {
+      name: "TypeScript",
+      purpose: "strict application language",
+      selected: false
+    },
+    { name: "Turbopack", purpose: "Next.js dev bundler", selected: false },
+    {
+      name: "React Compiler",
+      purpose: "default compiler optimization",
+      selected: false
+    },
+    { name: "Tailwind CSS 4", purpose: "styling system", selected: false },
+    { name: "shadcn/ui", purpose: "UI component primitives", selected: false },
+    { name: "Zustand", purpose: "client state management", selected: false },
+    { name: "nuqs", purpose: "URL-synchronized state", selected: false },
+    {
+      name: "@t3-oss/env-nextjs",
+      purpose: "environment schema validation",
+      selected: false
+    },
+    { name: "Zod", purpose: "schema validation", selected: false },
+    {
+      name: "next-safe-action",
+      purpose: "typed and validated Server Actions",
+      selected: false
+    },
+    { name: "react-hook-form", purpose: "form state", selected: false },
+    {
+      name: "@hookform/resolvers",
+      purpose: "Zod form integration",
+      selected: false
+    },
+    { name: "Docker", purpose: "production container build", selected: false },
+    {
+      name: "Docker Compose",
+      purpose: "local service orchestration",
+      selected: false
+    },
+    {
+      name: "OpenTelemetry",
+      purpose: "provider-agnostic tracing",
+      selected: false
+    },
+    {
+      name: "Agent DevTools MCP",
+      purpose: "local Next.js agent debugging",
+      selected: false
+    },
+    {
+      name: "Vercel Agent Skills",
+      purpose: "packaged agent workflows",
+      selected: false
+    },
+    { name: "ESLint", purpose: "linting", selected: false },
+    { name: "Prettier", purpose: "formatting", selected: false }
+  ];
+  if (config.orm === "prisma") {
+    guides.push(
+      { name: "Prisma v7", purpose: "ORM", selected: true },
+      { name: "PostgreSQL", purpose: "database", selected: true },
+      {
+        name: "@prisma/adapter-pg",
+        purpose: "Prisma PostgreSQL driver adapter",
+        selected: true
+      }
+    );
+  }
+  if (hasAuth(config)) {
+    guides.push(
+      { name: "Better Auth", purpose: "authentication", selected: true },
+      {
+        name: "Microsoft Entra OAuth",
+        purpose: "SSO provider",
+        selected: true
+      }
+    );
+  }
+  if (config.aiChat) {
+    guides.push(
+      {
+        name: "AI SDK 6",
+        purpose: "client chat transport and UI message stream contract",
+        selected: true
+      },
+      { name: "AI Elements", purpose: "chat UI components", selected: true }
+    );
+  }
+  if (config.i18n) {
+    guides.push({
+      name: "next-intl",
+      purpose: "internationalization",
+      selected: true
+    });
+  }
+  if (config.ci === "github") {
+    guides.push({
+      name: "GitHub Actions",
+      purpose: "CI/CD pipeline; pnpm lint and Docker build are active, while typecheck/test/e2e steps are TODO no-ops until scripts exist",
+      selected: true
+    });
+  }
+  if (config.analytics === "plausible") {
+    guides.push(
+      {
+        name: "Plausible",
+        purpose: "privacy-focused analytics; runtime script is consent-gated and uses env-driven domain/API host values",
+        selected: true
+      },
+      {
+        name: "ClickHouse",
+        purpose: "Plausible event storage",
+        selected: true
+      }
+    );
+  }
+  if (config.preCommit) {
+    guides.push({
+      name: "prek",
+      purpose: "pre-commit hook runner",
+      selected: true
+    });
+  }
+  return guides;
+}
+function buildBaselineSkillGuides() {
+  return PHASE_4_1_BASELINE_AGENT_SKILLS.map(({ skill }) => {
+    switch (skill) {
+      case "find-skills":
+        return {
+          name: skill,
+          purpose: "discover additional project-relevant Agent Skills"
+        };
+      case "next-best-practices":
+        return {
+          name: skill,
+          purpose: "follow current Next.js conventions"
+        };
+      case "vercel-react-view-transitions":
+        return {
+          name: skill,
+          purpose: "work with React view transitions"
+        };
+      case "vercel-react-best-practices":
+        return {
+          name: skill,
+          purpose: "keep React code idiomatic"
+        };
+      case "vercel-composition-patterns":
+        return {
+          name: skill,
+          purpose: "compose React components consistently"
+        };
+      case "web-design-guidelines":
+        return {
+          name: skill,
+          purpose: "follow web design guidance"
+        };
+      default:
+        return {
+          name: skill,
+          purpose: "follow project-specific coding guidance"
+        };
+    }
+  });
+}
+function buildInstalledSkillGuides(config) {
+  const guides = [
+    ...buildBaselineSkillGuides(),
+    { name: "shadcn/ui", purpose: "use installed shadcn/ui primitives" },
+    { name: "nuqs", purpose: "manage URL-synchronized state" },
+    { name: "zustand-5", purpose: "manage colocated client state" },
+    {
+      name: "next-safe-action",
+      purpose: "write validated, typed Server Actions"
+    }
+  ];
+  if (config.orm === "prisma") {
+    guides.push({
+      name: "prisma/skills",
+      purpose: "work with Prisma schema, migrations, and client code"
+    });
+  }
+  if (hasAuth(config)) {
+    guides.push({
+      name: "better-auth-best-practices",
+      purpose: "follow Better Auth integration patterns"
+    });
+  }
+  if (config.aiChat) {
+    guides.push(
+      {
+        name: "ai-sdk",
+        purpose: "use AI SDK client transport and UI message contracts"
+      },
+      {
+        name: "ai-elements",
+        purpose: "compose generated chat UI with AI Elements components"
+      }
+    );
+  }
+  return guides;
+}
+function replaceManagedSection(existing, startMarker, endMarker, section) {
+  const trimmedExisting = existing.trimEnd();
+  const pattern = new RegExp(
+    `${escapeRegExp(startMarker)}[\\s\\S]*?${escapeRegExp(endMarker)}`
+  );
+  if (pattern.test(trimmedExisting)) {
+    return `${trimmedExisting.replace(pattern, section)}
+`;
+  }
+  return `${trimmedExisting}
+
+${section}
+`;
+}
+function removeManagedSection(existing, startMarker, endMarker) {
+  const pattern = new RegExp(
+    `\\n*${escapeRegExp(startMarker)}[\\s\\S]*?${escapeRegExp(endMarker)}`
+  );
+  return existing.replace(pattern, "");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildAgentsScaleStackSection(config) {
+  const technologyLines = buildTechnologyGuides(config).map(
+    ({ name, purpose, selected }) => `- ${selected ? "Selected" : "Default"}: \`${name}\` - ${purpose}.`
+  );
+  const skillLines = buildInstalledSkillGuides(config).map(
+    ({ name, purpose }) => `- \`${name}\`: ${purpose}.`
+  );
+  return [
+    SCALE_STACK_AGENTS_START,
+    "## Scale Stack Guidance",
+    "",
+    "- Keep route-specific UI, hooks, state, actions, and AI artifacts colocated under private `_folders` inside the route segment that consumes them.",
+    "- Use the listed Technology Stack by default; do not add alternatives unless the task requires it.",
+    "- When adding or changing environment variables, update `src/env.ts` and `env.example`; never bypass the schema.",
+    "- Never commit `.env`, credentials, API keys, tokens, or other secrets.",
+    "",
+    "### Technology Stack",
+    "",
+    ...technologyLines,
+    "",
+    "### Installed Agent Skills",
+    "",
+    ...skillLines,
+    SCALE_STACK_AGENTS_END
+  ].join("\n");
+}
+function mergeAgentsMdContent(existing, config) {
+  const base = existing.trim() ? existing : FALLBACK_AGENTS_MD;
+  return replaceManagedSection(
+    base,
+    SCALE_STACK_AGENTS_START,
+    SCALE_STACK_AGENTS_END,
+    buildAgentsScaleStackSection(config)
+  );
+}
+function mergeClaudeMdContent(existing) {
+  const withImport = existing.includes("@AGENTS.md") ? existing : `${FALLBACK_CLAUDE_MD}
+${existing}`;
+  const withoutOldManagedSection = removeManagedSection(
+    withImport,
+    SCALE_STACK_CLAUDE_START,
+    SCALE_STACK_CLAUDE_END
+  );
+  return `${withoutOldManagedSection.trimEnd()}
+`;
+}
+function buildMcpJson() {
+  return `${JSON.stringify(
+    {
+      mcpServers: {
+        "next-devtools": {
+          command: "npx",
+          args: ["-y", "next-devtools-mcp@latest"]
+        }
+      }
+    },
+    null,
+    2
+  )}
+`;
+}
+var aiAssistantGenerator = {
+  name: "ai-assistant",
+  dependencies: [
+    "docker",
+    "form-handling",
+    "error-handling",
+    "state",
+    "eslint-prettier"
+  ],
+  resolveDependencies: (config) => [
+    ...config.preCommit ? ["pre-commit"] : [],
+    ...config.aiChat ? ["ai-chat"] : [],
+    ...config.ci !== "none" ? ["ci"] : [],
+    ...config.analytics !== "none" ? ["analytics"] : []
+  ],
+  async execute(ctx) {
+    ctx.fs.merge(
+      "AGENTS.md",
+      (existing) => mergeAgentsMdContent(existing, ctx.config)
+    );
+    ctx.fs.merge("CLAUDE.md", mergeClaudeMdContent);
+    ctx.fs.write(".mcp.json", buildMcpJson());
+  }
+};
+
+// src/generators/analytics/analytics.ts
+var ANALYTICS_PROVIDER_PATH = "src/app/_providers/analytics-provider.tsx";
+var ANALYTICS_HELPER_PATH = "src/lib/analytics.ts";
+var POSTHOG_NOT_IMPLEMENTED_MESSAGE = "PostHog analytics is not implemented yet; no analytics runtime files or dependencies generated.";
+var PLAUSIBLE_ENV_FRAGMENT = {
+  variables: [
+    {
+      name: "NEXT_PUBLIC_PLAUSIBLE_API_HOST",
+      scope: "client",
+      schema: "z.string().url()",
+      example: "http://localhost:8000"
+    },
+    {
+      name: "NEXT_PUBLIC_PLAUSIBLE_DOMAIN",
+      scope: "client",
+      schema: "z.string().min(1)",
+      example: "localhost"
+    },
+    {
+      name: "NEXT_PUBLIC_PLAUSIBLE_CAPTURE_LOCALHOST",
+      scope: "client",
+      schema: 'z.enum(["true", "false"])',
+      example: "true"
+    },
+    {
+      name: "NEXT_PUBLIC_PLAUSIBLE_SCRIPT_SRC",
+      scope: "client",
+      schema: "z.string().url()",
+      example: "http://localhost:8000/js/script.js"
+    }
+  ]
+};
+async function writePlausibleFiles(ctx) {
+  const [provider, helper] = await Promise.all([
+    ctx.template.renderFile("analytics/analytics-provider.tsx.ejs", {}),
+    ctx.template.renderFile("analytics/analytics.ts.ejs", {})
+  ]);
+  ctx.envBag.push(structuredClone(PLAUSIBLE_ENV_FRAGMENT));
+  ctx.fs.write(ANALYTICS_PROVIDER_PATH, provider);
+  ctx.fs.write(ANALYTICS_HELPER_PATH, helper);
+}
+var analyticsGenerator = {
+  name: "analytics",
+  dependencies: ["env-management", "ui"],
+  condition: (config) => config.analytics !== "none",
+  async execute(ctx) {
+    if (ctx.config.analytics === "posthog") {
+      ctx.logger.warn("analytics", POSTHOG_NOT_IMPLEMENTED_MESSAGE);
+      return;
+    }
+    await writePlausibleFiles(ctx);
+  }
+};
+
+// src/generators/orm/orm.ts
+var PHASE_13_ORM_AGENT_SKILL_COMMAND = buildSkillsAddCommand(
+  "prisma/skills",
+  []
+);
+var PHASE_13_PRISMA_GENERATE_COMMAND = "pnpm db:generate";
+var ORM_FILES = [
+  {
+    templatePath: "orm/schema.prisma.ejs",
+    outputPath: "prisma/schema.prisma"
+  },
+  {
+    templatePath: "orm/prisma.config.ts.ejs",
+    outputPath: "prisma.config.ts"
+  },
+  {
+    templatePath: "orm/prisma.ts.ejs",
+    outputPath: "src/lib/prisma.ts"
+  }
+];
+function mergePackageJson2(existing) {
+  const desiredFragment = {
+    scripts: structuredClone(PACKAGE_SCRIPTS_BASELINE),
+    dependencies: structuredClone(PACKAGE_DEPS_BASELINE),
+    devDependencies: structuredClone(PACKAGE_DEV_DEPS_BASELINE)
+  };
+  return mergeManagedPackageJson({
+    existingContent: existing,
+    desiredFragment,
+    sortSections: ["dependencies", "devDependencies"]
+  });
+}
+async function writeOrmFiles(ctx) {
+  for (const file of ORM_FILES) {
+    const content = await ctx.template.renderFile(file.templatePath, {});
+    ctx.fs.write(file.outputPath, content);
+  }
+}
+var ormGenerator = {
+  name: "orm",
+  dependencies: ["env-management"],
+  condition: (config) => config.orm === "prisma",
+  async execute(ctx) {
+    ctx.fs.merge("package.json", mergePackageJson2);
+    await writeOrmFiles(ctx);
+    await ctx.exec(PHASE_13_ORM_AGENT_SKILL_COMMAND, {
+      cwd: ctx.targetDir,
+      env: { ...AGENT_SKILLS_EXEC_ENV }
+    });
+    ctx.envBag.push(buildOrmEnvFragment(ctx.config.projectName));
+  },
+  async afterInstall(ctx) {
+    if (ctx.config.authStrategy === "stateful") return;
+    await ctx.exec(PHASE_13_PRISMA_GENERATE_COMMAND, {
+      cwd: ctx.targetDir,
+      env: {
+        DATABASE_URL: buildDatabaseUrlExample(ctx.config.projectName)
+      }
+    });
+  }
+};
+
+// src/generators/auth/auth.ts
+var PHASE_14_AUTH_AGENT_SKILL_COMMAND = buildSkillsAddCommand(
+  "better-auth/skills",
+  ["better-auth-best-practices"]
+);
+var PHASE_14_AUTH_GENERATE_COMMAND = "pnpm dlx auth@latest generate --config src/lib/auth.ts --yes";
+var AUTH_FILES = [
+  {
+    templatePath: "auth/auth.ts.ejs",
+    outputPath: "src/lib/auth.ts"
+  },
+  {
+    templatePath: "auth/auth-client.ts.ejs",
+    outputPath: "src/lib/auth-client.ts"
+  },
+  {
+    templatePath: "auth/route.ts.ejs",
+    outputPath: "src/app/api/auth/[...all]/route.ts"
+  },
+  {
+    templatePath: "auth/sign-in-page.tsx.ejs",
+    outputPath: "src/app/(auth)/sign-in/page.tsx"
+  },
+  {
+    templatePath: "auth/sign-up-page.tsx.ejs",
+    outputPath: "src/app/(auth)/sign-up/page.tsx"
+  },
+  {
+    templatePath: "auth/unauthorized.tsx.ejs",
+    outputPath: "src/app/unauthorized.tsx"
+  }
+];
+function isStatefulAuth(strategy) {
+  return strategy === "stateful";
+}
+function buildAuthAfterInstallEnv(strategy, projectName) {
+  const env = {
+    BETTER_AUTH_SECRET: "replace-with-at-least-32-character-secret",
+    BETTER_AUTH_URL: "http://localhost:3000",
+    MICROSOFT_CLIENT_ID: "replace-with-microsoft-client-id",
+    MICROSOFT_CLIENT_SECRET: "replace-with-microsoft-client-secret",
+    MICROSOFT_TENANT_ID: "common",
+    NODE_ENV: "development",
+    SKIP_ENV_VALIDATION: "1"
+  };
+  if (isStatefulAuth(strategy)) {
+    env.DATABASE_URL = buildDatabaseUrlExample(projectName);
+  }
+  return env;
+}
+function mergePackageJson3(existing) {
+  const desiredFragment = {
+    dependencies: structuredClone(PACKAGE_DEPS_BASELINE)
+  };
+  return mergeManagedPackageJson({
+    existingContent: existing,
+    desiredFragment,
+    sortSections: ["dependencies"]
+  });
+}
+async function writeAuthFiles(ctx) {
+  const isStateful = isStatefulAuth(ctx.config.authStrategy);
+  for (const file of AUTH_FILES) {
+    const content = await ctx.template.renderFile(file.templatePath, {
+      isStateful,
+      i18n: ctx.config.i18n
+    });
+    ctx.fs.write(
+      localizeAppRoutePath(file.outputPath, ctx.config.i18n),
+      content
+    );
+  }
+}
+var authGenerator = {
+  name: "auth",
+  dependencies: ["ui", "env-management"],
+  resolveDependencies: (config) => isStatefulAuth(config.authStrategy) ? ["orm"] : [],
+  condition: (config) => config.authStrategy !== "none",
+  async execute(ctx) {
+    ctx.fs.merge("package.json", mergePackageJson3);
+    await writeAuthFiles(ctx);
+    await ctx.exec(PHASE_14_AUTH_AGENT_SKILL_COMMAND, {
+      cwd: ctx.targetDir,
+      env: { ...AGENT_SKILLS_EXEC_ENV }
+    });
+    ctx.envBag.push(buildAuthEnvFragment());
+  },
+  async afterInstall(ctx) {
+    if (!isStatefulAuth(ctx.config.authStrategy)) return;
+    const env = buildAuthAfterInstallEnv(
+      ctx.config.authStrategy,
+      ctx.config.projectName
+    );
+    await ctx.exec(PHASE_13_PRISMA_GENERATE_COMMAND, {
+      cwd: ctx.targetDir,
+      env
+    });
+    await ctx.exec(PHASE_14_AUTH_GENERATE_COMMAND, {
+      cwd: ctx.targetDir,
+      env
+    });
+    await ctx.exec(PHASE_13_PRISMA_GENERATE_COMMAND, {
+      cwd: ctx.targetDir,
+      env
+    });
+  }
+};
+
+// src/generators/ci/ci.ts
+var GITHUB_ACTIONS_WORKFLOW_PATH = ".github/workflows/ci.yml";
+var CIRCLECI_CONFIG_PATH = ".circleci/config.yml";
+function hasPrisma(config) {
+  return config.orm === "prisma";
+}
+function buildPostgresServiceYaml() {
+  return [
+    "    services:",
+    "      postgres:",
+    "        image: postgres:16-alpine",
+    "        env:",
+    "          POSTGRES_USER: postgres",
+    "          POSTGRES_DB: scale_stack_ci",
+    "          POSTGRES_HOST_AUTH_METHOD: trust",
+    "        ports:",
+    "          - 5432:5432",
+    "        options: >-",
+    '          --health-cmd "pg_isready -U postgres -d scale_stack_ci"',
+    "          --health-interval 5s",
+    "          --health-timeout 5s",
+    "          --health-retries 10"
+  ];
+}
+function buildPrismaMigrationCheckYaml(config) {
+  if (!hasPrisma(config)) return [];
+  return [
+    "      - name: Check Prisma migrations",
+    "        env:",
+    "          DATABASE_URL: postgresql://postgres@localhost:5432/scale_stack_ci",
+    "        run: |",
+    "          pnpm prisma migrate diff \\",
+    "            --from-migrations prisma/migrations \\",
+    "            --to-schema-datamodel prisma/schema.prisma \\",
+    '            --shadow-database-url "$DATABASE_URL" \\',
+    "            --exit-code",
+    ""
+  ];
+}
+function buildGithubActionsWorkflow(config) {
+  return [
+    "name: CI",
+    "",
+    "on:",
+    "  push:",
+    "    branches: [main]",
+    "  pull_request:",
+    "",
+    "permissions:",
+    "  contents: read",
+    "",
+    "jobs:",
+    "  validate:",
+    "    name: Validate",
+    "    runs-on: ubuntu-latest",
+    ...hasPrisma(config) ? buildPostgresServiceYaml() : [],
+    "    steps:",
+    "      - name: Checkout",
+    "        uses: actions/checkout@v4",
+    "",
+    "      - name: Setup pnpm",
+    "        uses: pnpm/action-setup@v4",
+    "",
+    "      - name: Setup Node.js",
+    "        uses: actions/setup-node@v4",
+    "        with:",
+    "          node-version: 24",
+    "          cache: pnpm",
+    "",
+    "      - name: Install dependencies",
+    "        run: pnpm install --frozen-lockfile",
+    "",
+    "      - name: Lint",
+    "        run: pnpm lint",
+    "",
+    "      - name: TODO typecheck",
+    `        run: 'echo "TODO: enable pnpm typecheck after Phase 18 adds the script"'`,
+    "",
+    "      - name: TODO unit tests",
+    `        run: 'echo "TODO: enable pnpm test after Phase 18 adds the script"'`,
+    "",
+    "      - name: TODO end-to-end tests",
+    `        run: 'echo "TODO: enable pnpm test:e2e after Phase 18 adds the script"'`,
+    "",
+    ...buildPrismaMigrationCheckYaml(config),
+    "      - name: Verify Docker build",
+    "        run: docker build .",
+    ""
+  ].join("\n");
+}
+var ciGenerator = {
+  name: "ci",
+  dependencies: ["docker"],
+  resolveDependencies(config) {
+    return hasPrisma(config) ? ["orm"] : [];
+  },
+  condition(config) {
+    return config.ci !== "none";
+  },
+  async execute(ctx) {
+    if (ctx.config.ci === "circleci") {
+      ctx.logger.warn(
+        "ci",
+        `CircleCI coming soon; no ${CIRCLECI_CONFIG_PATH} generated yet.`
+      );
+      return;
+    }
+    ctx.fs.write(
+      GITHUB_ACTIONS_WORKFLOW_PATH,
+      buildGithubActionsWorkflow(ctx.config)
+    );
+  }
+};
+
+// src/generators/core/eslint-prettier.ts
+function buildPrettierRcContents() {
+  return `${JSON.stringify(PRETTIER_RC_BASELINE, null, 2)}
+`;
+}
+function buildPrettierIgnoreContents(config) {
+  return renderTemplateFile("eslint-prettier/.prettierignore.ejs", {
+    ignoreAiElementsGeneratedOutput: shouldIgnoreAiElementsGeneratedOutput(config),
+    ignorePrismaGeneratedOutput: shouldIgnorePrismaGeneratedOutput(config)
+  });
+}
+function mergePackageJson4(existing) {
+  const desiredFragment = {
+    scripts: structuredClone(PACKAGE_SCRIPTS_BASELINE),
+    devDependencies: structuredClone(PACKAGE_DEV_DEPS_BASELINE)
+  };
+  return mergeManagedPackageJson({
+    existingContent: existing,
+    desiredFragment,
+    sortSections: ["devDependencies"]
+  });
+}
+var eslintPrettierGenerator = {
+  name: "eslint-prettier",
+  dependencies: ["project-init", "env-management"],
+  async execute(ctx) {
+    ctx.fs.write(
+      "eslint.config.mjs",
+      await buildEslintConfigMjsContents(ctx.config)
+    );
+    ctx.fs.write(".prettierrc", buildPrettierRcContents());
+    ctx.fs.write(
+      ".prettierignore",
+      await buildPrettierIgnoreContents(ctx.config)
+    );
+    ctx.fs.merge("package.json", mergePackageJson4);
+  },
+  async afterInstall(ctx) {
+    await ctx.exec("pnpm exec prettier --write .");
+  }
+};
+
+// src/generators/core/build-env-files-from-fragments.ts
+function collectVariables(bag) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const fragment of bag.fragments) {
+    for (const variable of fragment.variables) {
+      merged.set(variable.name, variable);
+    }
+  }
+  return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function pickScope(variables, scope) {
+  return variables.filter((variable) => variable.scope === scope);
+}
+function buildSchemaSection(variables) {
+  if (variables.length === 0) return "{}";
+  return `{
+${variables.map((variable) => `    ${variable.name}: ${variable.schema},`).join("\n")}
+  }`;
+}
+function buildRuntimeEnvSection(variables) {
+  if (variables.length === 0) return "{}";
+  return `{
+${variables.map((variable) => `    ${variable.name}: process.env["${variable.name}"],`).join("\n")}
+  }`;
+}
+function buildEnvExample(variables) {
+  const exampleLines = [
+    "# Copy this file to `.env` and replace placeholder values before running the app.",
+    "# `src/env.ts` is the source of truth for validation and types for the variables listed here.",
+    "# Variables managed by Next.js/runtime (for example `NODE_ENV`) are intentionally omitted."
+  ];
+  const userSuppliedVariables = variables.filter(
+    (variable) => variable.includeInExample !== false
+  );
+  if (userSuppliedVariables.length === 0) {
+    return `${exampleLines.join("\n")}
+`;
+  }
+  return `${exampleLines.join("\n")}
+${userSuppliedVariables.map((variable) => `${variable.name}=${variable.example}`).join("\n")}
+`;
+}
+function buildEnvFilesFromFragments(bag) {
+  const variables = collectVariables(bag);
+  const server = pickScope(variables, "server");
+  const client = pickScope(variables, "client");
+  const shared = pickScope(variables, "shared");
+  const runtimeEnv = [...shared, ...client].sort(
+    (a, b) => a.name.localeCompare(b.name)
+  );
+  const envTs = `import { createEnv } from "@t3-oss/env-nextjs";
+import { z } from "zod";
+
+export const env = createEnv({
+  server: ${buildSchemaSection(server)},
+  client: ${buildSchemaSection(client)},
+  shared: ${buildSchemaSection(shared)},
+  experimental__runtimeEnv: ${buildRuntimeEnvSection(runtimeEnv)},
+  skipValidation: process.env["SKIP_ENV_VALIDATION"] === "1",
 });
+`;
+  return { envTs, envExample: buildEnvExample(variables) };
+}
+
+// src/generators/core/env-management.ts
+var BASELINE_ENV_FRAGMENT = {
+  variables: [
+    {
+      name: "NODE_ENV",
+      scope: "shared",
+      schema: 'z.enum(["development", "production", "test"])',
+      example: "development",
+      includeInExample: false
+    }
+  ]
+};
+function mergePackageJson5(existing) {
+  const desiredFragment = {
+    dependencies: structuredClone(PACKAGE_DEPS_BASELINE)
+  };
+  return mergeManagedPackageJson({
+    existingContent: existing,
+    desiredFragment,
+    sortSections: ["dependencies"]
+  });
+}
+var envManagementGenerator = {
+  name: "env-management",
+  dependencies: ["project-init"],
+  async execute(ctx) {
+    ctx.fs.merge("package.json", mergePackageJson5);
+    ctx.envBag.push(structuredClone(BASELINE_ENV_FRAGMENT));
+  },
+  async afterInstall(ctx) {
+    const files = buildEnvFilesFromFragments(ctx.envBag);
+    ctx.fs.write("src/env.ts", files.envTs);
+    ctx.fs.write("env.example", files.envExample);
+  }
+};
+
+// src/generators/core/project-init.ts
+import { basename, dirname as dirname5 } from "path";
+import { rm as rm3 } from "fs/promises";
+var CREATE_NEXT_APP_VERSION = "16.2.6";
+var CNA_FLAGS = "--react-compiler --eslint --app --src-dir --use-pnpm --skip-install --disable-git";
+function buildCreateNextAppCommand(projectDirName) {
+  const q = shellQuoteBasename(projectDirName);
+  return `pnpm create next-app@${CREATE_NEXT_APP_VERSION} ${q} ${CNA_FLAGS}`;
+}
+function shellQuoteBasename(name) {
+  if (/^[a-zA-Z0-9._-]+$/.test(name)) return name;
+  return `'${name.replace(/'/g, `'\\''`)}'`;
+}
+function mergeTsconfigContent(existing, config) {
+  const desiredFragment = structuredClone(
+    buildTsconfigManagedBaseline(config)
+  );
+  const merged = mergeManagedJsonString({
+    relativePath: "tsconfig.json",
+    existingContent: existing,
+    desiredFragment
+  });
+  return formatMergedJson(merged);
+}
+function mergeGitignoreContent(existing) {
+  const needEnv = !/^\.env\*$/m.test(existing);
+  const needScaleStack = !/^\.scale-stack\/?$/m.test(existing);
+  const parts = [existing.replace(/\s+$/, "")];
+  if (needEnv || needScaleStack) {
+    parts.push("");
+    parts.push("# Scale Stack");
+    if (needEnv) parts.push(".env*");
+    if (needScaleStack) parts.push(".scale-stack/");
+  }
+  return `${parts.join("\n")}
+`;
+}
+async function writeNextConfig(ctx) {
+  ctx.fs.write(
+    "next.config.ts",
+    await buildNextConfigTsContents({
+      config: {
+        authStrategy: ctx.config.authStrategy,
+        i18n: ctx.config.i18n
+      }
+    })
+  );
+}
+async function writeAppOverlays(ctx) {
+  const { projectName } = ctx.config;
+  const [layout, loading] = await Promise.all([
+    ctx.template.renderFile("core/layout.tsx.ejs", { projectName }),
+    ctx.template.renderFile("core/loading.tsx.ejs", {})
+  ]);
+  ctx.fs.write("src/app/layout.tsx", layout);
+  ctx.fs.write(
+    localizeAppRoutePath("src/app/loading.tsx", ctx.config.i18n),
+    loading
+  );
+}
+var projectInitGenerator = {
+  name: "project-init",
+  dependencies: [],
+  async execute(ctx) {
+    const folderName = basename(ctx.targetDir);
+    const parentDir = dirname5(ctx.targetDir);
+    const cmd = buildCreateNextAppCommand(folderName);
+    await ctx.exec(cmd, { cwd: parentDir });
+    await writeNextConfig(ctx);
+    await writeAppOverlays(ctx);
+    ctx.fs.merge(
+      "tsconfig.json",
+      (existing) => mergeTsconfigContent(existing, ctx.config)
+    );
+    ctx.fs.merge(".gitignore", mergeGitignoreContent);
+  },
+  async rollback(ctx) {
+    await rm3(ctx.targetDir, { recursive: true, force: true });
+  }
+};
+
+// src/generators/docker/docker.ts
+var DOCKER_NODE_VERSION = "24.13.0-slim";
+var POSTGRES_IMAGE = "postgres:16-alpine";
+var CLICKHOUSE_IMAGE = "clickhouse/clickhouse-server:24.12-alpine";
+var PLAUSIBLE_IMAGE = "ghcr.io/plausible/community-edition:v3.2.0";
+var PLAUSIBLE_LOCAL_SECRET_KEY_BASE = "local-only-change-me-local-only-change-me-local-only-change-me-local-only-change-me";
+function hasPrisma2(config) {
+  return config.orm === "prisma";
+}
+function hasPlausible(config) {
+  return config.analytics === "plausible";
+}
+function buildComposeDatabaseUrl(projectName) {
+  return `postgresql://postgres:postgres@postgres:5432/${buildPostgresDatabaseName(projectName)}`;
+}
+function buildAppEnvironment(config) {
+  const lines = ['      PORT: "3000"', '      HOSTNAME: "0.0.0.0"'];
+  if (hasPrisma2(config)) {
+    lines.push(
+      `      DATABASE_URL: ${buildComposeDatabaseUrl(config.projectName)}`
+    );
+    lines.push('      RUN_MIGRATIONS: "true"');
+  }
+  return lines;
+}
+function buildAppDependsOn(config) {
+  const lines = [];
+  if (hasPrisma2(config)) {
+    lines.push("      postgres:");
+    lines.push("        condition: service_healthy");
+  }
+  if (hasPlausible(config)) {
+    lines.push("      plausible:");
+    lines.push("        condition: service_healthy");
+  }
+  return lines;
+}
+function buildPostgresService(config) {
+  if (!hasPrisma2(config)) return [];
+  const databaseName = buildPostgresDatabaseName(config.projectName);
+  return [
+    "  postgres:",
+    `    image: ${POSTGRES_IMAGE}`,
+    "    environment:",
+    "      POSTGRES_USER: postgres",
+    "      POSTGRES_PASSWORD: postgres",
+    `      POSTGRES_DB: ${databaseName}`,
+    "    volumes:",
+    "      - postgres-data:/var/lib/postgresql/data",
+    "    healthcheck:",
+    `      test: ["CMD-SHELL", "pg_isready -U postgres -d ${databaseName}"]`,
+    "      interval: 5s",
+    "      timeout: 5s",
+    "      retries: 10",
+    "      start_period: 10s"
+  ];
+}
+function buildPlausibleServices() {
+  return [
+    "  plausible-db:",
+    `    image: ${POSTGRES_IMAGE}`,
+    "    environment:",
+    "      POSTGRES_USER: postgres",
+    "      POSTGRES_PASSWORD: postgres",
+    "      POSTGRES_DB: plausible",
+    "    volumes:",
+    "      - plausible-db-data:/var/lib/postgresql/data",
+    "    healthcheck:",
+    '      test: ["CMD-SHELL", "pg_isready -U postgres -d plausible"]',
+    "      interval: 5s",
+    "      timeout: 5s",
+    "      retries: 10",
+    "      start_period: 1m",
+    "",
+    "  plausible-events-db:",
+    `    image: ${CLICKHOUSE_IMAGE}`,
+    "    environment:",
+    '      CLICKHOUSE_SKIP_USER_SETUP: "1"',
+    "    volumes:",
+    "      - plausible-event-data:/var/lib/clickhouse",
+    "      - plausible-event-logs:/var/log/clickhouse-server",
+    "    ulimits:",
+    "      nofile:",
+    "        soft: 262144",
+    "        hard: 262144",
+    "    healthcheck:",
+    "      test:",
+    "        [",
+    '          "CMD-SHELL",',
+    '          "wget --no-verbose --tries=1 -O - http://127.0.0.1:8123/ping || exit 1",',
+    "        ]",
+    "      interval: 5s",
+    "      timeout: 5s",
+    "      retries: 10",
+    "      start_period: 1m",
+    "",
+    "  plausible:",
+    `    image: ${PLAUSIBLE_IMAGE}`,
+    '    command: sh -c "/entrypoint.sh db createdb && /entrypoint.sh db migrate && /entrypoint.sh run"',
+    "    depends_on:",
+    "      plausible-db:",
+    "        condition: service_healthy",
+    "      plausible-events-db:",
+    "        condition: service_healthy",
+    "    ports:",
+    '      - "8000:8000"',
+    "    volumes:",
+    "      - plausible-data:/var/lib/plausible",
+    "    ulimits:",
+    "      nofile:",
+    "        soft: 65535",
+    "        hard: 65535",
+    "    environment:",
+    "      TMPDIR: /var/lib/plausible/tmp",
+    "      BASE_URL: http://localhost:8000",
+    `      SECRET_KEY_BASE: ${PLAUSIBLE_LOCAL_SECRET_KEY_BASE}`,
+    "      DATABASE_URL: postgres://postgres:postgres@plausible-db:5432/plausible",
+    "      CLICKHOUSE_DATABASE_URL: http://plausible-events-db:8123/plausible_events_db",
+    "    healthcheck:",
+    "      test:",
+    "        [",
+    '          "CMD-SHELL",',
+    '          "wget --no-verbose --tries=1 -O - http://127.0.0.1:8000/api/system/health/ready || exit 1",',
+    "        ]",
+    "      interval: 10s",
+    "      timeout: 5s",
+    "      retries: 12",
+    "      start_period: 1m"
+  ];
+}
+function buildVolumes(config) {
+  const lines = [];
+  if (hasPrisma2(config)) {
+    lines.push("  postgres-data:");
+  }
+  if (hasPlausible(config)) {
+    lines.push("  plausible-db-data:");
+    lines.push("  plausible-event-data:");
+    lines.push("  plausible-event-logs:");
+    lines.push("  plausible-data:");
+  }
+  return lines;
+}
+function buildDockerComposeYaml(config) {
+  const appDependsOn = buildAppDependsOn(config);
+  const services = [
+    "services:",
+    "  app:",
+    "    build:",
+    "      context: .",
+    "      dockerfile: Dockerfile",
+    "    environment:",
+    ...buildAppEnvironment(config),
+    "    ports:",
+    '      - "3000:3000"',
+    ...appDependsOn.length > 0 ? ["    depends_on:", ...appDependsOn] : [],
+    ...buildPostgresService(config),
+    ...hasPlausible(config) ? buildPlausibleServices() : []
+  ];
+  const volumes = buildVolumes(config);
+  return [
+    ...services,
+    ...volumes.length > 0 ? ["", "volumes:", ...volumes] : [],
+    ""
+  ].join("\n");
+}
+function buildPrismaRunnerAdditions(config) {
+  if (!hasPrisma2(config)) return [];
+  return [
+    "RUN apt-get update \\",
+    "  && apt-get install -y --no-install-recommends openssl postgresql-client \\",
+    "  && rm -rf /var/lib/apt/lists/* \\",
+    "  && corepack enable pnpm",
+    "",
+    "COPY --from=deps --chown=node:node /app/node_modules ./node_modules",
+    "COPY --from=builder --chown=node:node /app/package.json ./package.json",
+    "COPY --from=builder --chown=node:node /app/pnpm-lock.yaml ./pnpm-lock.yaml",
+    "COPY --from=builder --chown=node:node /app/prisma ./prisma",
+    "COPY --from=builder --chown=node:node /app/prisma.config.ts ./prisma.config.ts",
+    ""
+  ];
+}
+function buildPrismaBuilderEnvironment(config) {
+  if (!hasPrisma2(config)) return [];
+  return [
+    `ENV DATABASE_URL=${buildComposeDatabaseUrl(config.projectName)}`,
+    ""
+  ];
+}
+function buildDockerfile(config) {
+  return [
+    "# syntax=docker/dockerfile:1.7",
+    `ARG NODE_VERSION=${DOCKER_NODE_VERSION}`,
+    "",
+    "FROM node:${NODE_VERSION} AS deps",
+    "WORKDIR /app",
+    "",
+    "COPY package.json pnpm-lock.yaml* .npmrc* ./",
+    "RUN --mount=type=cache,target=/root/.local/share/pnpm/store \\",
+    "  corepack enable pnpm \\",
+    "  && pnpm install --frozen-lockfile --dangerously-allow-all-builds",
+    "",
+    "FROM node:${NODE_VERSION} AS builder",
+    "WORKDIR /app",
+    "",
+    "COPY --from=deps /app/node_modules ./node_modules",
+    "COPY . .",
+    "",
+    "ENV NODE_ENV=production",
+    "ENV NEXT_TELEMETRY_DISABLED=1",
+    ...buildPrismaBuilderEnvironment(config),
+    "",
+    "RUN corepack enable pnpm && pnpm build",
+    "",
+    "FROM node:${NODE_VERSION} AS runner",
+    "WORKDIR /app",
+    "",
+    "ENV NODE_ENV=production",
+    "ENV PORT=3000",
+    'ENV HOSTNAME="0.0.0.0"',
+    "ENV NEXT_TELEMETRY_DISABLED=1",
+    "",
+    ...buildPrismaRunnerAdditions(config),
+    "COPY --from=builder --chown=node:node /app/public ./public",
+    "",
+    "RUN mkdir .next && chown node:node .next",
+    "",
+    "COPY --from=builder --chown=node:node /app/.next/standalone ./",
+    "COPY --from=builder --chown=node:node /app/.next/static ./.next/static",
+    "COPY --chown=node:node start.sh ./start.sh",
+    "RUN chmod +x ./start.sh",
+    "",
+    "USER node",
+    "",
+    "EXPOSE 3000",
+    "",
+    'CMD ["./start.sh"]',
+    ""
+  ].join("\n");
+}
+function buildStartSh(config) {
+  const lines = [
+    "#!/bin/sh",
+    "set -eu",
+    "",
+    'if [ "${RUN_MIGRATIONS:-false}" = "true" ]; then'
+  ];
+  if (hasPrisma2(config)) {
+    lines.push(
+      '  until pg_isready -d "${DATABASE_URL}"; do',
+      '    echo "Waiting for database..."',
+      "    sleep 2",
+      "  done",
+      "",
+      "  pnpm db:migrate:deploy"
+    );
+  } else {
+    lines.push(
+      '  echo "RUN_MIGRATIONS=true was set, but no ORM is configured."'
+    );
+  }
+  lines.push("", "fi", "", "exec node server.js", "");
+  return lines.join("\n");
+}
+function buildDockerignore() {
+  return [
+    ".git",
+    ".scale-stack",
+    ".mcp.json",
+    ".next",
+    "node_modules",
+    "coverage",
+    "dist",
+    ".env*",
+    "*.log",
+    "npm-debug.log*",
+    "yarn-debug.log*",
+    "yarn-error.log*",
+    ".pnpm-store",
+    ".turbo",
+    ".DS_Store",
+    ""
+  ].join("\n");
+}
+var dockerGenerator = {
+  name: "docker",
+  dependencies: ["project-init"],
+  resolveDependencies(config) {
+    return hasPrisma2(config) ? ["orm"] : [];
+  },
+  async execute(ctx) {
+    ctx.fs.write("Dockerfile", buildDockerfile(ctx.config));
+    ctx.fs.write("start.sh", buildStartSh(ctx.config));
+    ctx.fs.write("docker-compose.yml", buildDockerComposeYaml(ctx.config));
+    ctx.fs.write(".dockerignore", buildDockerignore());
+  }
+};
+
+// src/generators/error-handling/error-handling.ts
+var ERROR_HANDLING_FILES = [
+  {
+    templatePath: "error-handling/error.tsx.ejs",
+    outputPath: "src/app/error.tsx"
+  },
+  {
+    templatePath: "error-handling/global-error.tsx.ejs",
+    outputPath: "src/app/global-error.tsx"
+  },
+  {
+    templatePath: "error-handling/not-found.tsx.ejs",
+    outputPath: "src/app/not-found.tsx"
+  },
+  {
+    templatePath: "error-handling/catch-all-not-found-page.tsx.ejs",
+    outputPath: "src/app/[...not-found]/page.tsx"
+  }
+];
+var errorHandlingGenerator = {
+  name: "error-handling",
+  dependencies: ["ui"],
+  async execute(ctx) {
+    for (const file of ERROR_HANDLING_FILES) {
+      const content = await ctx.template.renderFile(file.templatePath, {
+        i18n: ctx.config.i18n
+      });
+      const outputPath = file.outputPath === "src/app/global-error.tsx" || file.outputPath === "src/app/[...not-found]/page.tsx" ? file.outputPath : localizeAppRoutePath(file.outputPath, ctx.config.i18n);
+      ctx.fs.write(outputPath, content);
+    }
+  }
+};
+
+// src/generators/server-actions/server-actions.ts
+var PHASE_15_SERVER_ACTIONS_AGENT_SKILL_COMMAND = buildSkillsAddCommand("next-safe-action/skills", []);
+var SERVER_ACTIONS_FILES = [
+  {
+    templatePath: "server-actions/safe-action.ts.ejs",
+    outputPath: "src/lib/safe-action.ts"
+  }
+];
+function hasAuth2(strategy) {
+  return strategy !== "none";
+}
+function buildDependencies(strategy) {
+  const dependencies = structuredClone(PACKAGE_DEPS_BASELINE);
+  if (hasAuth2(strategy)) {
+    Object.assign(dependencies, SERVER_ACTIONS_AUTH_DEPENDENCIES);
+  }
+  return dependencies;
+}
+function mergePackageJson6(existing, strategy = "none") {
+  const desiredFragment = {
+    dependencies: buildDependencies(strategy)
+  };
+  return mergeManagedPackageJson({
+    existingContent: existing,
+    desiredFragment,
+    sortSections: ["dependencies"]
+  });
+}
+async function writeServerActionFiles(ctx) {
+  const hasAuthClient = hasAuth2(ctx.config.authStrategy);
+  for (const file of SERVER_ACTIONS_FILES) {
+    const content = await ctx.template.renderFile(file.templatePath, {
+      hasAuth: hasAuthClient
+    });
+    ctx.fs.write(file.outputPath, content);
+  }
+}
+var serverActionsGenerator = {
+  name: "server-actions",
+  dependencies: ["ui", "env-management"],
+  resolveDependencies: (config) => hasAuth2(config.authStrategy) ? ["auth"] : [],
+  async execute(ctx) {
+    ctx.fs.merge(
+      "package.json",
+      (existing) => mergePackageJson6(existing, ctx.config.authStrategy)
+    );
+    await writeServerActionFiles(ctx);
+    await ctx.exec(PHASE_15_SERVER_ACTIONS_AGENT_SKILL_COMMAND, {
+      cwd: ctx.targetDir,
+      env: { ...AGENT_SKILLS_EXEC_ENV }
+    });
+  }
+};
+
+// src/generators/form-handling/form-handling.ts
+var FORM_HANDLING_FILES = [
+  {
+    templatePath: "form-handling/example-form-schema.ts.ejs",
+    outputPath: "src/app/dashboard/_lib/example-form-schema.ts"
+  },
+  {
+    templatePath: "form-handling/example-form.tsx.ejs",
+    outputPath: "src/app/dashboard/_components/ExampleForm.tsx"
+  },
+  {
+    templatePath: "form-handling/example-form-action.ts.ejs",
+    outputPath: "src/app/dashboard/_actions/example-form.ts"
+  },
+  {
+    templatePath: "form-handling/dashboard-page.tsx.ejs",
+    outputPath: "src/app/dashboard/page.tsx"
+  }
+];
+function mergePackageJson7(existing) {
+  const desiredFragment = {
+    dependencies: structuredClone(PACKAGE_DEPS_BASELINE)
+  };
+  return mergeManagedPackageJson({
+    existingContent: existing,
+    desiredFragment,
+    sortSections: ["dependencies"]
+  });
+}
+async function writeFormHandlingFiles(ctx) {
+  const hasAuthClient = hasAuth2(ctx.config.authStrategy);
+  for (const file of FORM_HANDLING_FILES) {
+    const content = await ctx.template.renderFile(file.templatePath, {
+      hasAuth: hasAuthClient,
+      i18n: ctx.config.i18n
+    });
+    ctx.fs.write(
+      localizeAppRoutePath(file.outputPath, ctx.config.i18n),
+      content
+    );
+  }
+}
+var formHandlingGenerator = {
+  name: "form-handling",
+  dependencies: ["ui", "server-actions"],
+  async execute(ctx) {
+    ctx.fs.merge("package.json", mergePackageJson7);
+    await writeFormHandlingFiles(ctx);
+  }
+};
+
+// src/generators/i18n/i18n.ts
+var I18N_FILES = [
+  {
+    templatePath: "i18n/routing.ts.ejs",
+    outputPath: "src/i18n/routing.ts"
+  },
+  {
+    templatePath: "i18n/request.ts.ejs",
+    outputPath: "src/i18n/request.ts"
+  },
+  {
+    templatePath: "i18n/navigation.ts.ejs",
+    outputPath: "src/i18n/navigation.ts"
+  },
+  {
+    templatePath: "i18n/next-intl.d.ts.ejs",
+    outputPath: "src/i18n/next-intl.d.ts"
+  },
+  {
+    templatePath: "i18n/locale-layout.tsx.ejs",
+    outputPath: "src/app/[locale]/layout.tsx"
+  },
+  {
+    templatePath: "i18n/en.json.ejs",
+    outputPath: "messages/en.json"
+  },
+  {
+    templatePath: "i18n/ar.json.ejs",
+    outputPath: "messages/ar.json"
+  }
+];
+function mergePackageJson8(existing) {
+  const desiredFragment = {
+    dependencies: structuredClone(PACKAGE_DEPS_BASELINE)
+  };
+  return mergeManagedPackageJson({
+    existingContent: existing,
+    desiredFragment,
+    sortSections: ["dependencies"]
+  });
+}
+async function writeI18nFiles(ctx) {
+  for (const file of I18N_FILES) {
+    const content = await ctx.template.renderFile(file.templatePath, {
+      projectName: ctx.config.projectName
+    });
+    ctx.fs.write(file.outputPath, content);
+  }
+}
+var i18nGenerator = {
+  name: "i18n",
+  dependencies: ["ui", "error-handling", "form-handling"],
+  resolveDependencies: (config) => [
+    ...config.authStrategy !== "none" ? ["auth"] : [],
+    ...config.aiChat ? ["ai-chat"] : []
+  ],
+  condition: (config) => config.i18n === true,
+  async execute(ctx) {
+    ctx.fs.merge("package.json", mergePackageJson8);
+    await writeI18nFiles(ctx);
+  }
+};
+
+// src/generators/pre-commit/pre-commit.ts
+var PHASE_19_GIT_INIT_COMMAND = "git init";
+function mergePackageJson9(existing, mode) {
+  const desiredFragment = {
+    scripts: buildPreCommitScripts(mode)
+  };
+  return mergeManagedPackageJson({
+    existingContent: existing,
+    desiredFragment,
+    sortSections: []
+  });
+}
+var preCommitGenerator = {
+  name: "pre-commit",
+  dependencies: ["eslint-prettier"],
+  condition: (config) => config.preCommit,
+  async execute(ctx) {
+    const mode = inferPreCommitMode(ctx.targetDir);
+    ctx.fs.write("prek.toml", await buildPrekTomlContents());
+    ctx.fs.merge(
+      "package.json",
+      (existing) => mergePackageJson9(existing, mode)
+    );
+    if (mode === "standalone") {
+      await ctx.exec(PHASE_19_GIT_INIT_COMMAND, { cwd: ctx.targetDir });
+    }
+  }
+};
+
+// src/generators/proxy/proxy.ts
+var PROXY_OUTPUT_PATH = "src/proxy.ts";
+var proxyGenerator = {
+  name: "proxy",
+  dependencies: ["project-init"],
+  resolveDependencies: (config) => [
+    ...config.authStrategy !== "none" ? ["auth"] : [],
+    ...config.i18n ? ["i18n"] : []
+  ],
+  async execute(ctx) {
+    const content = await ctx.template.renderFile("proxy/proxy.ts.ejs", {
+      hasAuth: ctx.config.authStrategy !== "none",
+      hasI18n: ctx.config.i18n
+    });
+    ctx.fs.write(PROXY_OUTPUT_PATH, content);
+  }
+};
+
+// src/generators/state/state.ts
+var PHASE_9_STATE_AGENT_SKILL_COMMANDS = [
+  buildSkillsAddCommand("https://github.com/pproenca/dot-skills", ["nuqs"]),
+  buildSkillsAddCommand("https://github.com/prowler-cloud/prowler", [
+    "zustand-5"
+  ])
+];
+function mergePackageJson10(existing) {
+  const desiredFragment = {
+    dependencies: structuredClone(PACKAGE_DEPS_BASELINE)
+  };
+  return mergeManagedPackageJson({
+    existingContent: existing,
+    desiredFragment,
+    sortSections: ["dependencies"]
+  });
+}
+var stateGenerator = {
+  name: "state",
+  dependencies: ["ui"],
+  async execute(ctx) {
+    ctx.fs.merge("package.json", mergePackageJson10);
+    for (const command of PHASE_9_STATE_AGENT_SKILL_COMMANDS) {
+      await ctx.exec(command, {
+        cwd: ctx.targetDir,
+        env: { ...AGENT_SKILLS_EXEC_ENV }
+      });
+    }
+  }
+};
+
+// src/generators/ui/ui.ts
+var SHADCN_PRESET = "nova";
+var REACT_SUSPENSE_IMPORT = 'import { Suspense } from "react";';
+var CLIENT_SIDE_WRAPPERS_IMPORT = 'import { ClientSideWrappers } from "./_providers/client-side-wrappers";';
+var SONNER_OPTIONAL_THEME_CAST = 'theme={theme as ToasterProps["theme"]}';
+var SONNER_NON_NULLABLE_THEME_CAST = 'theme={theme as NonNullable<ToasterProps["theme"]>}';
+var SELF_REFERENTIAL_FONT_SANS = "--font-sans: var(--font-sans);";
+var GEIST_FONT_SANS = "--font-sans: var(--font-geist-sans);";
+var FONT_HEADING_ALIAS = "--font-heading: var(--font-sans);";
+var GEIST_FONT_HEADING = "--font-heading: var(--font-geist-sans);";
+function buildShadcnInitCommand() {
+  return `pnpm dlx shadcn@latest init --template next --preset ${SHADCN_PRESET} --yes`;
+}
+function buildShadcnAddAllCommand() {
+  return "pnpm dlx shadcn@latest add --all --yes";
+}
+function buildShadcnSkillAddCommand() {
+  return "pnpm dlx skills add shadcn/ui -y";
+}
+function mergeRootLayoutWithClientSideWrappers(existing) {
+  if (existing.includes("<ClientSideWrappers>")) return existing;
+  const importMarker = 'import "./globals.css";\n';
+  if (!existing.includes(importMarker)) {
+    throw new Error("Could not find globals.css import in root layout.");
+  }
+  const childrenMarker = [
+    "        {/* Scale Stack: wrap with NuqsAdapter and other root providers under src/app/_providers/ */}",
+    "        {children}"
+  ].join("\n");
+  if (!existing.includes(childrenMarker)) {
+    throw new Error("Could not find root layout children slot.");
+  }
+  return existing.replace(
+    importMarker,
+    `${importMarker}${REACT_SUSPENSE_IMPORT}
+${CLIENT_SIDE_WRAPPERS_IMPORT}
+`
+  ).replace(
+    childrenMarker,
+    [
+      "        <Suspense>",
+      "          <ClientSideWrappers>{children}</ClientSideWrappers>",
+      "        </Suspense>"
+    ].join("\n")
+  );
+}
+function fixSonnerExactOptionalTheme(existing) {
+  if (existing.includes(SONNER_NON_NULLABLE_THEME_CAST)) return existing;
+  return existing.replace(
+    SONNER_OPTIONAL_THEME_CAST,
+    SONNER_NON_NULLABLE_THEME_CAST
+  );
+}
+function fixGeneratedFontVariables(existing) {
+  return existing.replace(SELF_REFERENTIAL_FONT_SANS, GEIST_FONT_SANS).replace(FONT_HEADING_ALIAS, GEIST_FONT_HEADING);
+}
+async function writeUiFiles(ctx) {
+  const [page, clientSideWrappers] = await Promise.all([
+    ctx.template.renderFile("ui/page.tsx.ejs", {
+      projectName: ctx.config.projectName,
+      hasAuth: ctx.config.authStrategy !== "none",
+      hasAiChat: ctx.config.aiChat,
+      isStatefulAuth: ctx.config.authStrategy === "stateful",
+      i18n: ctx.config.i18n
+    }),
+    ctx.template.renderFile("ui/client-side-wrappers.tsx.ejs", {
+      hasAnalyticsProvider: ctx.config.analytics === "plausible"
+    })
+  ]);
+  ctx.fs.write(localizeAppRoutePath("src/app/page.tsx", ctx.config.i18n), page);
+  ctx.fs.write(
+    "src/app/_providers/client-side-wrappers.tsx",
+    clientSideWrappers
+  );
+}
+async function wireRootLayout(ctx) {
+  ctx.fs.merge("src/app/layout.tsx", mergeRootLayoutWithClientSideWrappers);
+}
+async function patchGeneratedComponentFiles(ctx) {
+  ctx.fs.merge("src/app/globals.css", fixGeneratedFontVariables);
+  ctx.fs.merge("src/components/ui/sonner.tsx", fixSonnerExactOptionalTheme);
+}
+var uiGenerator = {
+  name: "ui",
+  dependencies: ["agent-skills-init"],
+  async execute(ctx) {
+    await ctx.exec(buildShadcnInitCommand(), { cwd: ctx.targetDir });
+    await ctx.exec(buildShadcnAddAllCommand(), { cwd: ctx.targetDir });
+    await ctx.exec(buildShadcnSkillAddCommand(), { cwd: ctx.targetDir });
+    await patchGeneratedComponentFiles(ctx);
+    await writeUiFiles(ctx);
+    await wireRootLayout(ctx);
+  }
+};
+
+// src/generators/register.ts
+registerGenerator(projectInitGenerator);
+registerGenerator(proxyGenerator);
+registerGenerator(agentSkillsInitGenerator);
+registerGenerator(envManagementGenerator);
+registerGenerator(eslintPrettierGenerator);
+registerGenerator(uiGenerator);
+registerGenerator(stateGenerator);
+registerGenerator(errorHandlingGenerator);
+registerGenerator(ormGenerator);
+registerGenerator(authGenerator);
+registerGenerator(serverActionsGenerator);
+registerGenerator(formHandlingGenerator);
+registerGenerator(preCommitGenerator);
+registerGenerator(dockerGenerator);
+registerGenerator(ciGenerator);
+registerGenerator(analyticsGenerator);
+registerGenerator(aiChatGenerator);
+registerGenerator(i18nGenerator);
+registerGenerator(aiAssistantGenerator);
+
+// src/cli/ui/banner.ts
+import gradient2 from "gradient-string";
+import pc7 from "picocolors";
+var LOGO = [
+  "                         \xB0         ",
+  "\u2554\u2550\u2557 \u2566\u2554\u2550 \u2554\u2550\u2557 \u2566   \u2554\u2550\u2557 \u2554\u2566\u2557 \u2554\u2550\u2557 \u2566\u2554\u2550 \u2566\u2554\u2550",
+  "\u255A\u2550\u2557 \u2560\u2569\u2557 \u2560\u2550\u2563 \u2551   \u255A\u2550\u2557  \u2551  \u2560\u2550\u2563 \u2560\u2569\u2557 \u2560\u2569\u2557",
+  "\u255A\u2550\u255D \u2569 \u2569 \u2569 \u2569 \u2569\u2550\u255D \u255A\u2550\u255D  \u2569  \u2569 \u2569 \u2569 \u2569 \u2569 \u2569"
+];
+var TAGLINE = "Project foundation w/ smart-fittings";
+var INNER = 43;
+var CONTENT_W = INNER - 6;
+var BORDER_TOP = `  \u256D${"\u2500".repeat(INNER)}\u256E`;
+var BORDER_BOT = `  \u2570${"\u2500".repeat(INNER)}\u256F`;
+var EMPTY_ROW = `  \u2502${" ".repeat(INNER)}\u2502`;
+function boxRow(content, rawLen) {
+  const pad = CONTENT_W - rawLen;
+  return `  \u2502   ${content}${" ".repeat(Math.max(0, pad))}   \u2502`;
+}
+function logoBoxLine(colored, rawLen) {
+  return pc7.dim("  \u2502") + "   " + colored + " ".repeat(Math.max(0, CONTENT_W - rawLen)) + pc7.dim("   \u2502");
+}
+var SWEEP_GRADIENTS = [
+  gradient2(["#6B6B2E", "#2E4A6B"]),
+  gradient2(["#B8A31A", "#1A6B9E"]),
+  ikeaGradient
+];
+var PARTS = "\u2550\u2554\u2557\u2566\u2560\u2569\u2551\u255A\u255D\u2563\u256C\u2500\u2502\u250C\u2510\u2514\u2518\u252C\u2534\u251C\u2524\u253C";
+function scrambleLine(line, resolvedUpTo) {
+  return Array.from(line).map((ch, i) => {
+    if (i < resolvedUpTo) return ch;
+    if (ch === " ") return " ";
+    return PARTS[Math.floor(Math.random() * PARTS.length)];
+  }).join("");
+}
+function progressBar(filled, total, width = 8) {
+  const n = Math.round(filled / total * width);
+  return "\u2588".repeat(n) + "\u2591".repeat(width - n);
+}
+var BOX_CONTENT_LINES = 8;
+async function animateBanner() {
+  const logoText = LOGO.join("\n");
+  const charCount = LOGO[0].length;
+  const FRAMES = 10;
+  const RATTLE = 2;
+  console.log();
+  console.log(pc7.dim(BORDER_TOP));
+  console.log(pc7.dim(EMPTY_ROW));
+  for (let f = 0; f <= FRAMES; f++) {
+    if (f > 0) cursorUp(BOX_CONTENT_LINES);
+    const progress = f <= RATTLE ? 0 : (f - RATTLE) / (FRAMES - RATTLE);
+    const resolved = Math.floor(progress * charCount);
+    const done = resolved >= charCount;
+    for (const line of LOGO) {
+      const text2 = done ? line : scrambleLine(line, resolved);
+      console.log(logoBoxLine(pc7.dim(text2), line.length));
+    }
+    console.log(pc7.dim(EMPTY_ROW));
+    if (done) {
+      console.log(boxRow(ikea.heading(TAGLINE), TAGLINE.length));
+    } else {
+      const bar = progressBar(Math.max(0, f - RATTLE), FRAMES - RATTLE);
+      const plain = `\u25B8 assembling  ${bar}`;
+      console.log(
+        boxRow(`${ikea.bullet} assembling  ${pc7.dim(bar)}`, plain.length)
+      );
+    }
+    console.log(pc7.dim(EMPTY_ROW));
+    console.log(pc7.dim(BORDER_BOT));
+    await sleep(f <= RATTLE ? 120 : done ? 200 : 60);
+  }
+  for (const grad of SWEEP_GRADIENTS) {
+    cursorUp(BOX_CONTENT_LINES);
+    const colored = grad.multiline(logoText).split("\n");
+    for (let i = 0; i < colored.length; i++) {
+      console.log(logoBoxLine(colored[i], LOGO[i].length));
+    }
+    console.log(pc7.dim(EMPTY_ROW));
+    console.log(boxRow(ikea.heading(TAGLINE), TAGLINE.length));
+    console.log(pc7.dim(EMPTY_ROW));
+    console.log(pc7.dim(BORDER_BOT));
+    await sleep(70);
+  }
+  console.log();
+}
+async function animateDescription() {
+  const lines = [
+    "Stop the digital clutter. Flat-packed code efficiency",
+    "delivered straight to your terminal."
+  ];
+  for (const line of lines) {
+    process.stdout.write("  ");
+    await typewriter(pc7.dim(line), 6);
+    console.log();
+  }
+  console.log();
+}
+function printBanner() {
+  const coloredLines = ikeaGradient.multiline(LOGO.join("\n")).split("\n");
+  console.log();
+  console.log(pc7.dim(BORDER_TOP));
+  console.log(pc7.dim(EMPTY_ROW));
+  for (let i = 0; i < coloredLines.length; i++) {
+    console.log(logoBoxLine(coloredLines[i], LOGO[i].length));
+  }
+  console.log(pc7.dim(EMPTY_ROW));
+  console.log(boxRow(ikea.heading(TAGLINE), TAGLINE.length));
+  console.log(pc7.dim(EMPTY_ROW));
+  console.log(pc7.dim(BORDER_BOT));
+  console.log();
+}
+function printDescription() {
+  console.log(
+    ikea.muted(
+      "  Stop the digital clutter. Flat-packed code efficiency\n  delivered straight to your terminal."
+    )
+  );
+  console.log();
+}
+
+// src/cli/index.ts
+var pkgVersion = getCliVersion();
+var argv = process.argv.slice(2);
+var wantsHelp = argv.includes("--help") || argv.includes("-h") || argv.includes("--version") || argv.includes("-V");
+if (process.stdout.isTTY && !wantsHelp) {
+  await animateBanner();
+  await animateDescription();
+} else if (process.stdout.isTTY) {
+  printBanner();
+  printDescription();
+}
+var program = new Command().name("scale-stack").version(pkgVersion);
+registerInitCommand(program);
+registerSyncCommand(program);
 program.parse();