create-projx 1.5.5 → 1.5.6

package/dist/index.js

@@ -1,380 +1,43 @@
 #!/usr/bin/env node
+import {
+  BASELINE_REF,
+  applyTemplate,
+  collectAllFiles,
+  detectPackageNameOverrides,
+  getBaselineRef,
+  getFileAtRef,
+  matchesSkip,
+  saveBaselineRef,
+  writeTemplateToDir
+} from "./chunk-G74HYIE4.js";
+import {
+  COMPONENTS,
+  COMPONENT_MARKER,
+  EXCLUDE,
+  PACKAGE_MANAGERS,
+  cleanupRepo,
+  detectPackageManager,
+  detectPackageManagerFromComponents,
+  detectProjectName,
+  discoverComponentPaths,
+  discoverComponentsFromMarkers,
+  downloadRepo,
+  exec,
+  hasCommand,
+  pmCommands,
+  readComponentMarker,
+  readFileOrNull,
+  readProjxConfig,
+  toKebab,
+  toSnake,
+  toTitle,
+  writeComponentMarker,
+  writeProjxConfig
+} from "./chunk-FTHX7ILT.js";
 
 // src/index.ts
-import { existsSync as existsSync13 } from "fs";
-import { resolve as resolve2 } from "path";
-
-// src/utils.ts
-import { execSync } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { cp, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
-import { join, resolve } from "path";
-import { tmpdir } from "os";
-import { fileURLToPath } from "url";
-var REPO = "ukanhaupa/projx";
-var REPO_URL = `https://github.com/${REPO}`;
-var COMPONENTS = [
-  "fastapi",
-  "fastify",
-  "frontend",
-  "mobile",
-  "e2e",
-  "infra"
-];
-var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
-function pmCommands(pm) {
-  switch (pm) {
-    case "npm":
-      return { name: "npm", install: "npm install", ci: "npm ci", run: "npm run", exec: "npx", dlx: "npx", lockfile: "package-lock.json", prismaExec: "npx prisma", runDev: "npm run dev" };
-    case "pnpm":
-      return { name: "pnpm", install: "pnpm install", ci: "pnpm install --frozen-lockfile", run: "pnpm", exec: "pnpm exec", dlx: "pnpm dlx", lockfile: "pnpm-lock.yaml", prismaExec: "pnpm prisma", runDev: "pnpm dev" };
-    case "yarn":
-      return { name: "yarn", install: "yarn", ci: "yarn --frozen-lockfile", run: "yarn", exec: "yarn", dlx: "yarn dlx", lockfile: "yarn.lock", prismaExec: "yarn prisma", runDev: "yarn dev" };
-    case "bun":
-      return { name: "bun", install: "bun install", ci: "bun install --frozen-lockfile", run: "bun run", exec: "bunx", dlx: "bunx", lockfile: "bun.lockb", prismaExec: "bunx prisma", runDev: "bun run dev" };
-  }
-}
-function detectPackageManager(cwd) {
-  if (existsSync(join(cwd, "bun.lockb"))) return "bun";
-  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
-  if (existsSync(join(cwd, "package-lock.json"))) return "npm";
-  return null;
-}
-function toKebab(s) {
-  return s.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
-}
-function toSnake(s) {
-  return toKebab(s).replace(/-/g, "_");
-}
-function toTitle(s) {
-  return s.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-}
-function hasCommand(cmd) {
-  try {
-    execSync(`command -v ${cmd}`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function exec(cmd, cwd) {
-  execSync(cmd, { cwd, stdio: "pipe" });
-}
-function sharedTemplateDir() {
-  const thisFile = fileURLToPath(import.meta.url);
-  return join(thisFile, "../../src/templates");
-}
-async function downloadRepo(localPath) {
-  if (localPath) {
-    return localPath;
-  }
-  const dest = join(tmpdir(), `projx-${Date.now()}`);
-  await mkdir(dest, { recursive: true });
-  if (hasCommand("git")) {
-    execSync(
-      `git clone --depth 1 ${REPO_URL}.git "${dest}/repo"`,
-      { stdio: "pipe" }
-    );
-    return join(dest, "repo");
-  }
-  const tarUrl = `${REPO_URL}/archive/refs/heads/main.tar.gz`;
-  execSync(
-    `curl -sL "${tarUrl}" | tar xz -C "${dest}"`,
-    { stdio: "pipe" }
-  );
-  const entries = await readdir(dest);
-  const extracted = entries.find((e) => e.startsWith("projx-"));
-  if (!extracted) throw new Error("Failed to extract repo archive.");
-  return join(dest, extracted);
-}
-async function cleanupRepo(repoDir, isLocal) {
-  if (isLocal) return;
-  const parent = resolve(repoDir, "..");
-  if (parent.startsWith(tmpdir())) {
-    await rm(parent, { recursive: true, force: true });
-  }
-}
-var EXCLUDE = /* @__PURE__ */ new Set([
-  "node_modules",
-  "dist",
-  "build",
-  "coverage",
-  "__pycache__",
-  ".dart_tool",
-  ".flutter-plugins",
-  ".flutter-plugins-dependencies",
-  ".venv",
-  ".pytest_cache",
-  ".ruff_cache",
-  ".mypy_cache",
-  "playwright-report",
-  "test-results",
-  ".terraform",
-  "cli"
-]);
-var EXCLUDE_FILES = /* @__PURE__ */ new Set([
-  "uv.lock",
-  "pnpm-lock.yaml",
-  "package-lock.json",
-  "pubspec.lock",
-  ".env",
-  ".env.dev",
-  ".env.staging",
-  ".env.prod",
-  "dev.tfplan",
-  ".coverage"
-]);
-async function copyComponent(repoDir, component, dest) {
-  const src = join(repoDir, component);
-  const out = join(dest, component);
-  const files = [];
-  await cp(src, out, {
-    recursive: true,
-    filter: (source) => {
-      const base = source.split("/").pop();
-      if (EXCLUDE.has(base)) return false;
-      if (EXCLUDE_FILES.has(base)) return false;
-      if (base.endsWith(".pyc")) return false;
-      return true;
-    }
-  });
-  await collectFiles(out, out, files);
-  return files;
-}
-async function copyStaticFiles(repoDir, dest) {
-  const manifest = [];
-  const tpl = repoDir;
-  const statics = [".editorconfig"];
-  for (const file of statics) {
-    const src = join(tpl, file);
-    if (existsSync(src)) {
-      await cp(src, join(dest, file));
-      manifest.push(file);
-    }
-  }
-  const extensionsJson = join(tpl, ".vscode/extensions.json");
-  if (existsSync(extensionsJson)) {
-    await mkdir(join(dest, ".vscode"), { recursive: true });
-    await cp(extensionsJson, join(dest, ".vscode/extensions.json"));
-    manifest.push(".vscode/extensions.json");
-  }
-  const scripts = join(tpl, "scripts");
-  if (existsSync(scripts)) {
-    await cp(scripts, join(dest, "scripts"), { recursive: true });
-    manifest.push("scripts/setup-ssl.sh");
-  }
-  return manifest;
-}
-async function collectFiles(dir, root, files) {
-  const entries = await readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      await collectFiles(full, root, files);
-    } else {
-      files.push(full.slice(root.length + 1));
-    }
-  }
-}
-async function replaceInFile(filePath, find, replace) {
-  if (!existsSync(filePath)) return;
-  const content = await readFile(filePath, "utf-8");
-  if (!content.includes(find)) return;
-  await writeFile(filePath, content.replaceAll(find, replace));
-}
-async function replaceInDir(dir, find, replace, ext) {
-  if (!existsSync(dir)) return;
-  const entries = await readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      await replaceInDir(full, find, replace, ext);
-    } else if (entry.name.endsWith(ext)) {
-      await replaceInFile(full, find, replace);
-    }
-  }
-}
-var COMPONENT_MARKER = ".projx-component";
-async function readFileOrNull(path) {
-  try {
-    return await readFile(path, "utf-8");
-  } catch {
-    return null;
-  }
-}
-async function readComponentMarker(dir) {
-  const raw = await readFileOrNull(join(dir, COMPONENT_MARKER));
-  if (!raw) return null;
-  try {
-    const data = JSON.parse(raw);
-    return {
-      components: data.components ?? (data.component ? [data.component] : []),
-      origin: data.origin,
-      skip: data.skip
-    };
-  } catch {
-    return null;
-  }
-}
-async function writeComponentMarker(dir, component, origin = "scaffold", skip) {
-  const markerPath = join(dir, COMPONENT_MARKER);
-  let components = [component];
-  let existingOrigin = origin;
-  let existingSkip = skip;
-  const existing = await readFileOrNull(markerPath);
-  if (existing) {
-    try {
-      const data = JSON.parse(existing);
-      const prev = data.components ?? (data.component ? [data.component] : []);
-      existingOrigin = origin ?? data.origin ?? "scaffold";
-      existingSkip = skip ?? data.skip;
-      if (!prev.includes(component)) {
-        components = [...prev, component];
-      } else {
-        components = prev;
-      }
-    } catch {
-    }
-  }
-  const marker = { components, origin: existingOrigin };
-  if (existingSkip && existingSkip.length > 0) marker.skip = existingSkip;
-  await writeFile(markerPath, JSON.stringify(marker, null, 2) + "\n");
-}
-async function discoverComponentPaths(cwd, components) {
-  const paths = {};
-  const scan = async (dir) => {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (EXCLUDE.has(entry.name)) continue;
-      if (entry.name.startsWith(".")) continue;
-      const full = join(dir, entry.name);
-      const marker = join(full, COMPONENT_MARKER);
-      if (existsSync(marker)) {
-        try {
-          const data = JSON.parse(await readFile(marker, "utf-8"));
-          const markerComponents = data.components ?? (data.component ? [data.component] : []);
-          for (const mc of markerComponents) {
-            if (components.includes(mc)) {
-              paths[mc] = entry.name;
-            }
-          }
-        } catch {
-        }
-      }
-    }
-  };
-  await scan(cwd);
-  for (const c of components) {
-    if (!paths[c]) paths[c] = c;
-  }
-  return paths;
-}
-async function discoverComponentsFromMarkers(cwd) {
-  const components = [];
-  const paths = {};
-  const entries = await readdir(cwd, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    if (EXCLUDE.has(entry.name)) continue;
-    if (entry.name.startsWith(".")) continue;
-    const full = join(cwd, entry.name);
-    const marker = join(full, COMPONENT_MARKER);
-    if (existsSync(marker)) {
-      try {
-        const data = JSON.parse(await readFile(marker, "utf-8"));
-        const markerComponents = data.components ?? (data.component ? [data.component] : []);
-        for (const mc of markerComponents) {
-          if (COMPONENTS.includes(mc) && !components.includes(mc)) {
-            components.push(mc);
-            paths[mc] = entry.name;
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  for (const c of components) {
-    if (!paths[c]) paths[c] = c;
-  }
-  return { components, paths };
-}
-function render(template, vars) {
-  const components = vars.components;
-  const projectName = vars.projectName;
-  const lines = template.split("\n");
-  const output = [];
-  const stack = [];
-  for (const line of lines) {
-    const ifMatch = line.match(/^<%\s*if\s*\((.+?)\)\s*\{?\s*%>$/);
-    if (ifMatch) {
-      const pmName = vars.pm?.name ?? "npm";
-      const fn = new Function("components", "projectName", "pm", `return ${ifMatch[1]}`);
-      const result = fn(components, projectName, pmName);
-      stack.push({ active: result, matched: result });
-      continue;
-    }
-    const elseIfMatch = line.match(/^<%\s*\}\s*else\s+if\s*\((.+?)\)\s*\{?\s*%>$/);
-    if (elseIfMatch) {
-      if (stack.length > 0) {
-        const top = stack[stack.length - 1];
-        if (top.matched) {
-          top.active = false;
-        } else {
-          const pmN = vars.pm?.name ?? "npm";
-          const fn = new Function("components", "projectName", "pm", `return ${elseIfMatch[1]}`);
-          const result = fn(components, projectName, pmN);
-          top.active = result;
-          if (result) top.matched = true;
-        }
-      }
-      continue;
-    }
-    if (/^<%\s*\}\s*else\s*\{?\s*%>$/.test(line)) {
-      if (stack.length > 0) {
-        const top = stack[stack.length - 1];
-        top.active = !top.matched;
-      }
-      continue;
-    }
-    if (/^<%\s*\}?\s*%>$/.test(line)) {
-      stack.pop();
-      continue;
-    }
-    if (stack.length > 0 && stack.some((v) => !v.active)) continue;
-    const replaced = line.replace(
-      /<%=\s*([\w.]+)\s*%>/g,
-      (_, expr) => {
-        const parts = expr.split(".");
-        let val = vars;
-        for (const p11 of parts) {
-          val = val?.[p11];
-        }
-        return String(val ?? "");
-      }
-    );
-    output.push(replaced);
-  }
-  return output.join("\n").replace(/\n{3,}/g, "\n\n");
-}
-function detectProjectName(cwd, components, componentPaths) {
-  for (const component of components) {
-    const dir = componentPaths[component] ?? component;
-    const pkgPath = join(cwd, dir, "package.json");
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        const n = pkg.name;
-        if (n && n.includes("-")) {
-          return n.substring(0, n.lastIndexOf("-"));
-        }
-      } catch {
-      }
-    }
-  }
-  return toKebab(cwd.split("/").pop());
-}
+import { existsSync as existsSync11 } from "fs";
+import { resolve } from "path";
 
 // src/prompts.ts
 import * as p from "@clack/prompts";
@@ -428,447 +91,10 @@ async function runPrompts(nameArg) {
 }
 
 // src/scaffold.ts
-import { copyFileSync, existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir3, readFile as readFile4 } from "fs/promises";
-import { join as join4 } from "path";
+import { copyFileSync, existsSync } from "fs";
+import { mkdir, readFile } from "fs/promises";
+import { join } from "path";
 import * as p2 from "@clack/prompts";
-
-// src/baseline.ts
-import { existsSync as existsSync2, writeFileSync, unlinkSync } from "fs";
-import { chmod, mkdir as mkdir2, writeFile as writeFile2, rm as rm2, readFile as readFile3 } from "fs/promises";
-import { execSync as execSync2 } from "child_process";
-import { join as join3 } from "path";
-import { tmpdir as tmpdir2 } from "os";
-
-// src/generators/index.ts
-import { readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
-async function renderShared(filename, vars) {
-  const tpl = await readFile2(
-    join2(sharedTemplateDir(), filename),
-    "utf-8"
-  );
-  return render(tpl, vars);
-}
-async function generateDockerCompose(vars) {
-  return renderShared("docker-compose.yml.ejs", vars);
-}
-async function generateDockerComposeDev(vars) {
-  return renderShared("docker-compose.dev.yml.ejs", vars);
-}
-async function generatePreCommit(vars) {
-  return renderShared("pre-commit.ejs", vars);
-}
-async function generateSetupSh(vars) {
-  return renderShared("setup.sh.ejs", vars);
-}
-async function generateCiYml(vars) {
-  return renderShared("ci.yml.ejs", vars);
-}
-async function generateReadme(vars) {
-  return renderShared("README.md.ejs", vars);
-}
-function generateVscodeSettings(vars) {
-  const settings = {};
-  if (vars.components.includes("fastapi")) {
-    settings["[python]"] = {
-      "editor.defaultFormatter": "charliermarsh.ruff",
-      "editor.codeActionsOnSave": { "source.fixAll.ruff": "explicit" }
-    };
-  }
-  settings["[typescript]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
-  settings["[typescriptreact]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
-  settings["[javascript]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
-  settings["[json]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
-  settings["[css]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
-  settings["[yaml]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
-  settings["editor.formatOnSave"] = true;
-  settings["editor.codeActionsOnSave"] = { "source.fixAll.eslint": "explicit" };
-  settings["eslint.useFlatConfig"] = true;
-  const prettierComponent = ["frontend", "fastify", "e2e"].find(
-    (c) => vars.components.includes(c)
-  );
-  if (prettierComponent) {
-    settings["prettier.configPath"] = `${vars.paths[prettierComponent]}/.prettierrc`;
-  }
-  if (vars.components.includes("fastapi")) {
-    settings["ruff.lineLength"] = 120;
-    settings["python.analysis.extraPaths"] = [`${vars.paths.fastapi}/src`];
-    settings["python.analysis.importFormat"] = "absolute";
-  }
-  return JSON.stringify(settings, null, 2) + "\n";
-}
-
-// src/baseline.ts
-var BASELINE_REF = "refs/projx/baseline";
-async function writeManagedProjx(cwd, version, vars, components) {
-  const projxPath = join3(cwd, ".projx");
-  let existing = {};
-  if (existsSync2(projxPath)) {
-    try {
-      existing = JSON.parse(await readFile3(projxPath, "utf-8"));
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.warn(`projx: existing .projx is unreadable (${msg}); writing fresh.`);
-    }
-  }
-  const merged = {
-    ...existing,
-    version
-  };
-  if (components !== void 0) {
-    merged.components = components;
-  }
-  if (typeof merged.createdAt !== "string") {
-    merged.createdAt = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  }
-  const pmObj = vars.pm;
-  if (pmObj?.name && !merged.packageManager) {
-    merged.packageManager = pmObj.name;
-  }
-  await writeFile2(projxPath, JSON.stringify(merged, null, 2) + "\n");
-}
-function matchesSkip(filePath, patterns) {
-  for (const pattern of patterns) {
-    if (pattern === "**") return true;
-    if (pattern.endsWith("/**")) {
-      const prefix = pattern.slice(0, -3);
-      if (filePath.startsWith(prefix + "/") || filePath === prefix) return true;
-    }
-    if (pattern.startsWith("**/")) {
-      const suffix = pattern.slice(3);
-      if (suffix.startsWith("*.")) {
-        const ext = suffix.slice(1);
-        if (filePath.endsWith(ext)) return true;
-      } else if (filePath.endsWith(suffix) || filePath.includes("/" + suffix)) {
-        return true;
-      }
-    }
-    if (pattern.startsWith("*.")) {
-      const ext = pattern.slice(1);
-      if (filePath.endsWith(ext)) return true;
-    }
-    if (filePath === pattern) return true;
-  }
-  return false;
-}
-function saveBaselineRef(cwd) {
-  try {
-    const head = execSync2("git rev-parse HEAD", { cwd, stdio: "pipe" }).toString().trim();
-    execSync2(`git update-ref ${BASELINE_REF} ${head}`, { cwd, stdio: "pipe" });
-  } catch {
-  }
-}
-function getBaselineRef(cwd) {
-  try {
-    return execSync2(`git rev-parse --verify ${BASELINE_REF}`, { cwd, stdio: "pipe" }).toString().trim();
-  } catch {
-  }
-  try {
-    const sha = execSync2("git log -1 --format=%H -- .projx", { cwd, stdio: "pipe" }).toString().trim();
-    if (sha) return sha;
-  } catch {
-  }
-  return null;
-}
-function getFileAtRef(cwd, ref, filePath) {
-  try {
-    return execSync2(`git show ${ref}:"${filePath}"`, { cwd, stdio: "pipe" }).toString();
-  } catch {
-    return null;
-  }
-}
-function mergeFileThreeWay(oursPath, baseContent, theirsContent) {
-  const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const baseTmp = join3(tmpdir2(), `projx-base-${id}`);
-  const theirsTmp = join3(tmpdir2(), `projx-theirs-${id}`);
-  try {
-    writeFileSync(baseTmp, baseContent);
-    writeFileSync(theirsTmp, theirsContent);
-    execSync2(
-      `git merge-file -L "your changes" -L "previous projx baseline" -L "new projx template" "${oursPath}" "${baseTmp}" "${theirsTmp}"`,
-      { stdio: "pipe" }
-    );
-    return true;
-  } catch {
-    return false;
-  } finally {
-    try {
-      unlinkSync(baseTmp);
-    } catch {
-    }
-    try {
-      unlinkSync(theirsTmp);
-    } catch {
-    }
-  }
-}
-async function collectAllFiles(dir, base) {
-  const { readdir: readdir4 } = await import("fs/promises");
-  const results = [];
-  const walk = async (current) => {
-    const entries = await readdir4(current, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = join3(current, entry.name);
-      if (entry.isDirectory()) {
-        await walk(full);
-      } else {
-        results.push(full.slice(base.length + 1));
-      }
-    }
-  };
-  await walk(dir);
-  return results;
-}
-async function tryThreeWayMerge(cwd, templateDir, baselineRef) {
-  const templateFiles = await collectAllFiles(templateDir, templateDir);
-  const merged = [];
-  const conflicted = [];
-  for (const file of templateFiles) {
-    if (file === ".projx") continue;
-    const oursPath = join3(cwd, file);
-    if (!existsSync2(oursPath)) continue;
-    const baseContent = getFileAtRef(cwd, baselineRef, file);
-    if (baseContent === null) continue;
-    let theirsContent;
-    try {
-      theirsContent = await readFile3(join3(templateDir, file), "utf-8");
-    } catch {
-      continue;
-    }
-    const oursContent = await readFile3(oursPath, "utf-8");
-    if (theirsContent === baseContent) continue;
-    if (oursContent === baseContent) {
-      await writeFile2(oursPath, theirsContent);
-      merged.push(file);
-      continue;
-    }
-    if (oursContent === theirsContent) continue;
-    const clean = mergeFileThreeWay(oursPath, baseContent, theirsContent);
-    if (clean) {
-      merged.push(file);
-    } else {
-      conflicted.push(file);
-    }
-  }
-  return { merged, conflicted };
-}
-function createOrphanWorktree(cwd) {
-  const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const branch = `projx/tmp-${id}`;
-  const worktree = join3(tmpdir2(), `projx-wt-${id}`);
-  try {
-    execSync2("git worktree prune", { cwd, stdio: "pipe" });
-  } catch {
-  }
-  execSync2(`git worktree add --orphan -b ${branch} "${worktree}"`, {
-    cwd,
-    stdio: "pipe"
-  });
-  return { worktree, branch };
-}
-function cleanupWorktree(cwd, worktree, branch) {
-  try {
-    execSync2(`git worktree remove "${worktree}" --force`, { cwd, stdio: "pipe" });
-  } catch {
-    try {
-      rm2(worktree, { recursive: true, force: true });
-      execSync2("git worktree prune", { cwd, stdio: "pipe" });
-    } catch {
-    }
-  }
-  try {
-    execSync2(`git branch -D ${branch}`, { cwd, stdio: "pipe" });
-  } catch {
-  }
-}
-async function removeSkippedFiles(dir, skipPatterns) {
-  if (skipPatterns.length === 0) return;
-  const { readdir: readdir4, unlink: unlink2 } = await import("fs/promises");
-  const walk = async (current, base) => {
-    const entries = await readdir4(current, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = join3(current, entry.name);
-      const rel = full.slice(base.length + 1);
-      if (entry.isDirectory()) {
-        await walk(full, base);
-      } else if (entry.name !== ".projx-component" && matchesSkip(rel, skipPatterns)) {
-        await unlink2(full);
-      }
-    }
-  };
-  await walk(dir, dir);
-}
-async function writeTemplateToDir(dest, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip) {
-  const name = vars.projectName;
-  const nameSnake = toSnake(name);
-  for (const component of components) {
-    const targetDir = componentPaths[component];
-    const skipPatterns = componentSkips?.[component] ?? [];
-    const tmpDir = join3(dest, "__cptmp__");
-    await copyComponent(repoDir, component, tmpDir);
-    const srcDir = join3(tmpDir, component);
-    if (skipPatterns.length > 0) {
-      await removeSkippedFiles(srcDir, skipPatterns);
-    }
-    const outDir = join3(dest, targetDir);
-    await mkdir2(outDir, { recursive: true });
-    const { cp: cp2 } = await import("fs/promises");
-    if (existsSync2(srcDir)) {
-      await cp2(srcDir, outDir, { recursive: true, force: true });
-    }
-    await rm2(tmpDir, { recursive: true, force: true });
-    await writeComponentMarker(join3(dest, targetDir), component, origin, skipPatterns.length > 0 ? skipPatterns : void 0);
-  }
-  await substituteNames(dest, components, componentPaths, name, nameSnake);
-  const hasBackend = components.includes("fastapi") || components.includes("fastify");
-  const skip = rootSkip ?? [];
-  const shouldWrite = (file) => !matchesSkip(file, skip);
-  if (hasBackend || components.includes("frontend")) {
-    if (shouldWrite("docker-compose.yml"))
-      await writeFile2(join3(dest, "docker-compose.yml"), await generateDockerCompose(vars));
-    if (shouldWrite("docker-compose.dev.yml"))
-      await writeFile2(join3(dest, "docker-compose.dev.yml"), await generateDockerComposeDev(vars));
-  }
-  if (shouldWrite("README.md"))
-    await writeFile2(join3(dest, "README.md"), await generateReadme(vars));
-  if (shouldWrite(".githooks/pre-commit")) {
-    await mkdir2(join3(dest, ".githooks"), { recursive: true });
-    await writeFile2(join3(dest, ".githooks/pre-commit"), await generatePreCommit(vars));
-    await chmod(join3(dest, ".githooks/pre-commit"), 493);
-  }
-  if (shouldWrite(".github/workflows/ci.yml")) {
-    await mkdir2(join3(dest, ".github/workflows"), { recursive: true });
-    await writeFile2(join3(dest, ".github/workflows/ci.yml"), await generateCiYml(vars));
-  }
-  if (shouldWrite("setup.sh")) {
-    await writeFile2(join3(dest, "setup.sh"), await generateSetupSh(vars));
-    await chmod(join3(dest, "setup.sh"), 493);
-  }
-  await copyStaticFiles(repoDir, dest);
-  if (shouldWrite(".vscode/settings.json")) {
-    await mkdir2(join3(dest, ".vscode"), { recursive: true });
-    await writeFile2(join3(dest, ".vscode/settings.json"), generateVscodeSettings(vars));
-  }
-  await writeManagedProjx(dest, version, vars, components);
-}
-async function substituteNames(dest, components, paths, name, nameSnake) {
-  if (components.includes("fastapi")) {
-    await replaceInFile(join3(dest, `${paths.fastapi}/pyproject.toml`), "projx-fastapi", `${name}-fastapi`);
-  }
-  if (components.includes("fastify")) {
-    await replaceInFile(join3(dest, `${paths.fastify}/package.json`), "projx-fastify", `${name}-fastify`);
-  }
-  if (components.includes("frontend")) {
-    await replaceInFile(join3(dest, `${paths.frontend}/package.json`), "projx-frontend", `${name}-frontend`);
-  }
-  if (components.includes("e2e")) {
-    await replaceInFile(join3(dest, `${paths.e2e}/package.json`), "projx-e2e", `${name}-e2e`);
-  }
-  if (components.includes("mobile")) {
-    await replaceInFile(join3(dest, `${paths.mobile}/pubspec.yaml`), "projx_mobile", `${nameSnake}_mobile`);
-    await replaceInDir(join3(dest, `${paths.mobile}`), "package:projx_mobile/", `package:${nameSnake}_mobile/`, ".dart");
-  }
-}
-async function applyTemplate(cwd, repoDir, components, componentPaths, vars, version, origin = "scaffold", componentSkips, rootSkip) {
-  const hasHead = (() => {
-    try {
-      execSync2("git rev-parse HEAD", { cwd, stdio: "pipe" });
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-  if (!hasHead) {
-    await writeTemplateToDir(cwd, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip);
-    return { status: "clean" };
-  }
-  const { worktree, branch } = createOrphanWorktree(cwd);
-  try {
-    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip);
-    execSync2("git add -A", { cwd: worktree, stdio: "pipe" });
-    const diff2 = execSync2("git diff --cached --stat", { cwd: worktree, stdio: "pipe" }).toString().trim();
-    if (!diff2) {
-      cleanupWorktree(cwd, worktree, branch);
-      return { status: "clean" };
-    }
-    execSync2(
-      `git commit --no-verify -m "projx: template v${version} [${components.join(", ")}]"`,
-      { cwd: worktree, stdio: "pipe" }
-    );
-    try {
-      execSync2(`git worktree remove "${worktree}" --force`, { cwd, stdio: "pipe" });
-    } catch {
-      try {
-        await rm2(worktree, { recursive: true, force: true });
-        execSync2("git worktree prune", { cwd, stdio: "pipe" });
-      } catch {
-      }
-    }
-    let mergeClean = false;
-    try {
-      execSync2(
-        `git merge ${branch} --allow-unrelated-histories -m "projx: update to template v${version}"`,
-        { cwd, stdio: "pipe" }
-      );
-      mergeClean = true;
-    } catch {
-      try {
-        execSync2("git merge --abort", { cwd, stdio: "pipe" });
-      } catch {
-      }
-    }
-    try {
-      execSync2(`git branch -D ${branch}`, { cwd, stdio: "pipe" });
-    } catch {
-    }
-    if (mergeClean) {
-      saveBaselineRef(cwd);
-      return { status: "clean" };
-    }
-    const baselineRef = getBaselineRef(cwd);
-    if (baselineRef) {
-      const tmpTemplate = join3(tmpdir2(), `projx-tpl-${Date.now()}`);
-      await mkdir2(tmpTemplate, { recursive: true });
-      await writeTemplateToDir(tmpTemplate, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip);
-      const result = await tryThreeWayMerge(cwd, tmpTemplate, baselineRef);
-      await rm2(tmpTemplate, { recursive: true, force: true });
-      if (result.conflicted.length === 0) {
-        await writeManagedProjx(cwd, version, vars);
-        execSync2("git add -A", { cwd, stdio: "pipe" });
-        const staged = execSync2("git diff --cached --stat", { cwd, stdio: "pipe" }).toString().trim();
-        if (staged) {
-          execSync2(
-            `git commit --no-verify -m "projx: update to template v${version} (3-way merge)"`,
-            { cwd, stdio: "pipe" }
-          );
-        }
-        saveBaselineRef(cwd);
-        return result.merged.length > 0 ? { status: "merged", mergedFiles: result.merged } : { status: "clean" };
-      }
-      await writeManagedProjx(cwd, version, vars);
-      for (const f of result.merged) {
-        try {
-          execSync2(`git add "${f}"`, { cwd, stdio: "pipe" });
-        } catch {
-        }
-      }
-      execSync2("git add .projx", { cwd, stdio: "pipe" });
-      return {
-        status: "conflicts",
-        mergedFiles: result.merged,
-        conflictedFiles: result.conflicted
-      };
-    }
-    await writeTemplateToDir(cwd, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip);
-    return { status: "conflicts" };
-  } catch (err) {
-    cleanupWorktree(cwd, worktree, branch);
-    throw err;
-  }
-}
-
-// src/scaffold.ts
 async function scaffold(opts, dest, localRepo) {
   const name = toKebab(opts.name);
   const pm = opts.packageManager ?? "npm";
@@ -877,7 +103,7 @@ async function scaffold(opts, dest, localRepo) {
   );
   const vars = { projectName: name, components: opts.components, paths, pm: pmCommands(pm) };
   const isLocal = !!localRepo;
-  await mkdir3(dest, { recursive: true });
+  await mkdir(dest, { recursive: true });
   const dlSpinner = p2.spinner();
   dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
   const repoDir = await downloadRepo(localRepo).catch((err) => {
@@ -887,16 +113,15 @@ async function scaffold(opts, dest, localRepo) {
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    const pkg = JSON.parse(await readFile4(join4(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile(join(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
     p2.log.info(`Scaffolding project in ${dest}`);
     if (opts.git) {
       exec("git init", dest);
-      exec("git config core.hooksPath .githooks", dest);
     }
     const spinner7 = p2.spinner();
     spinner7.start("Scaffolding project");
-    await applyTemplate(dest, repoDir, opts.components, paths, vars, version);
+    await applyTemplate(dest, repoDir, opts.components, paths, vars, version, void 0, void 0, true);
     spinner7.stop("Scaffold complete.");
     if (opts.install) {
       await installDeps(dest, opts.components, pm);
@@ -905,7 +130,8 @@ async function scaffold(opts, dest, localRepo) {
     if (opts.git) {
       try {
         exec("git add -A", dest);
-        exec('git commit --no-verify -m "Initial scaffold from projx"', dest);
+        exec('git commit -m "Initial scaffold from projx"', dest);
+        exec("git config core.hooksPath .githooks", dest);
         saveBaselineRef(dest);
       } catch {
       }
@@ -930,7 +156,7 @@ async function installDeps(dest, components, pm) {
         case "fastapi":
           if (hasCommand("uv")) {
             spinner7.start("Installing FastAPI dependencies (uv sync)");
-            exec("uv sync --all-extras", join4(dest, "fastapi"));
+            exec("uv sync --all-extras", join(dest, "fastapi"));
             spinner7.stop("FastAPI dependencies installed.");
           } else {
             p2.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
@@ -939,7 +165,7 @@ async function installDeps(dest, components, pm) {
         case "fastify":
           if (hasCommand(pmBin)) {
             spinner7.start(`Installing Fastify dependencies (${cmds.install})`);
-            exec(cmds.install, join4(dest, "fastify"));
+            exec(cmds.install, join(dest, "fastify"));
             spinner7.stop("Fastify dependencies installed.");
           } else {
             p2.log.warn(`${pm} not found \u2014 run 'cd fastify && ${cmds.install}' manually.`);
@@ -948,7 +174,7 @@ async function installDeps(dest, components, pm) {
         case "frontend":
           if (hasCommand(pmBin)) {
             spinner7.start(`Installing Frontend dependencies (${cmds.install})`);
-            exec(cmds.install, join4(dest, "frontend"));
+            exec(cmds.install, join(dest, "frontend"));
             spinner7.stop("Frontend dependencies installed.");
           } else {
             p2.log.warn(`${pm} not found \u2014 run 'cd frontend && ${cmds.install}' manually.`);
@@ -957,7 +183,7 @@ async function installDeps(dest, components, pm) {
         case "e2e":
           if (hasCommand(pmBin)) {
             spinner7.start(`Installing E2E dependencies (${cmds.install})`);
-            exec(cmds.install, join4(dest, "e2e"));
+            exec(cmds.install, join(dest, "e2e"));
             spinner7.stop("E2E dependencies installed.");
           } else {
             p2.log.warn(`${pm} not found \u2014 run 'cd e2e && ${cmds.install}' manually.`);
@@ -966,7 +192,7 @@ async function installDeps(dest, components, pm) {
         case "mobile":
           if (hasCommand("flutter")) {
             spinner7.start("Installing Flutter dependencies");
-            exec("flutter pub get", join4(dest, "mobile"));
+            exec("flutter pub get", join(dest, "mobile"));
             spinner7.stop("Flutter dependencies installed.");
           } else {
             p2.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
@@ -982,9 +208,9 @@ async function installDeps(dest, components, pm) {
 }
 function copyEnvExamples(dest, components) {
   for (const component of components) {
-    const example = join4(dest, component, ".env.example");
-    const env = join4(dest, component, ".env");
-    if (existsSync3(example) && !existsSync3(env)) {
+    const example = join(dest, component, ".env.example");
+    const env = join(dest, component, ".env");
+    if (existsSync(example) && !existsSync(env)) {
       try {
         copyFileSync(example, env);
       } catch {
@@ -994,10 +220,10 @@ function copyEnvExamples(dest, components) {
 }
 
 // src/update.ts
-import { existsSync as existsSync4 } from "fs";
-import { readFile as readFile5, writeFile as writeFile3, unlink } from "fs/promises";
-import { execSync as execSync3 } from "child_process";
-import { join as join5 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2, unlink } from "fs/promises";
+import { execSync } from "child_process";
+import { join as join2 } from "path";
 import * as p3 from "@clack/prompts";
 async function update(cwd, localRepo) {
   p3.intro("projx update");
@@ -1007,39 +233,47 @@ async function update(cwd, localRepo) {
     process.exit(1);
   }
   try {
-    execSync3("git worktree prune", { cwd, stdio: "pipe" });
+    execSync("git worktree prune", { cwd, stdio: "pipe" });
   } catch {
   }
+  const raw = await readProjxConfig(cwd);
+  const { components, paths: componentPaths } = await discoverComponentsFromMarkers(cwd);
+  const pendingConflicts = findFilesWithConflictMarkers(cwd);
+  if (pendingConflicts.length > 0) {
+    p3.log.warn(`Found ${pendingConflicts.length} file(s) with unresolved conflict markers from a prior update:`);
+    for (const f of pendingConflicts) p3.log.info(`  ${f}`);
+    p3.log.info("");
+    const resumeVersion = String(raw.version ?? "unknown");
+    const handled = await promptSkipLearning(cwd, componentPaths, resumeVersion, pendingConflicts);
+    if (!handled) {
+      p3.log.info("");
+      p3.log.info("Resolve manually with `git diff` then `git add` / `git checkout --`,");
+      p3.log.info("or re-run `npx create-projx update` to resume the prompt.");
+    }
+    return;
+  }
   if (hasUncommittedChanges(cwd)) {
     p3.log.error("You have uncommitted changes. Commit or stash them first.");
     process.exit(1);
   }
-  const configPath = join5(cwd, ".projx");
-  let config;
-  if (existsSync4(configPath)) {
-    const raw = JSON.parse(await readFile5(configPath, "utf-8"));
-    const { components: discovered } = await discoverComponentsFromMarkers(cwd);
-    config = { ...raw, components: discovered.length > 0 ? discovered : raw.components };
-    p3.log.info(`Found .projx (v${config.version}, components: ${config.components.join(", ")})`);
+  if (components.length === 0) {
+    p3.log.error("No projx components found. Run 'projx init' first.");
+    process.exit(1);
+  }
+  if (Object.keys(raw).length > 0) {
+    p3.log.info(`Found .projx (v${raw.version ?? "unknown"}, components: ${components.join(", ")})`);
   } else {
-    p3.log.warn("No .projx file found. Detecting components from directories.");
-    const { components: discovered } = await discoverComponentsFromMarkers(cwd);
-    if (discovered.length === 0) {
-      p3.log.error("No projx components found. Run 'projx init' first.");
-      process.exit(1);
-    }
-    config = { version: "0.0.0", components: discovered, createdAt: "unknown" };
-    p3.log.info(`Detected: ${discovered.join(", ")}`);
+    p3.log.warn("No .projx file found. Detected components from markers.");
+    p3.log.info(`Detected: ${components.join(", ")}`);
   }
-  const componentPaths = await discoverComponentPaths(cwd, config.components);
-  for (const c of config.components) {
+  for (const c of components) {
     const dir = componentPaths[c];
     p3.log.info(dir !== c ? `${c} \u2192 ${dir}/` : `${c}/`);
   }
   const componentSkips = {};
-  for (const component of config.components) {
+  for (const component of components) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join5(cwd, dir));
+    const marker = await readComponentMarker(join2(cwd, dir));
     if (marker?.skip && marker.skip.length > 0) {
       componentSkips[component] = marker.skip;
     }
@@ -1053,17 +287,36 @@ async function update(cwd, localRepo) {
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    const pkg = JSON.parse(await readFile5(join5(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile2(join2(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
-    const name = detectProjectName(cwd, config.components, componentPaths);
-    const raw = existsSync4(configPath) ? JSON.parse(await readFile5(configPath, "utf-8")) : {};
-    const pm = raw.packageManager ?? "npm";
-    const vars = { projectName: name, components: config.components, paths: componentPaths, pm: pmCommands(pm) };
+    const name = detectProjectName(cwd, components, componentPaths);
+    const recordedPm = raw.packageManager;
+    const detectedPm = detectPackageManagerFromComponents(cwd, componentPaths);
+    const pm = detectedPm ?? recordedPm ?? "npm";
+    if (detectedPm && recordedPm && detectedPm !== recordedPm) {
+      p3.log.warn(`packageManager mismatch: .projx says "${recordedPm}" but lockfile is "${detectedPm}". Using "${detectedPm}".`);
+      await writeProjxConfig(cwd, { ...raw, packageManager: detectedPm });
+    } else if (detectedPm && !recordedPm) {
+      await writeProjxConfig(cwd, { ...raw, packageManager: detectedPm });
+    }
+    const nameOverrides = await detectPackageNameOverrides(cwd, components, componentPaths);
+    const vars = { projectName: name, components, paths: componentPaths, pm: pmCommands(pm), nameOverrides };
     const spinner7 = p3.spinner();
     spinner7.start("Applying template update");
-    const rootSkip = config.skip ?? [];
-    const result = await applyTemplate(cwd, repoDir, config.components, componentPaths, vars, version, "scaffold", componentSkips, rootSkip);
+    const rootSkip = Array.isArray(raw.skip) ? raw.skip : [];
+    const isLegacyMigration = !raw.defaultsApplied;
+    if (isLegacyMigration) {
+      p3.log.info("Legacy project detected \u2014 applying default skip patterns for user-owned files.");
+    }
+    const result = await applyTemplate(cwd, repoDir, components, componentPaths, vars, version, componentSkips, rootSkip, isLegacyMigration);
     spinner7.stop("Template applied.");
+    const pinnedUpdates = await findPinnedFilesWithUpdates(cwd, repoDir, components, componentPaths, vars, version, componentSkips, rootSkip);
+    if (pinnedUpdates.length > 0) {
+      p3.log.info("");
+      p3.log.info(`${pinnedUpdates.length} pinned file(s) have template updates available:`);
+      for (const f of pinnedUpdates) p3.log.info(`  ${f}`);
+      p3.log.info("Run `npx create-projx unpin <file> && npx create-projx update` to opt in.");
+    }
     if (result.status === "merged") {
       saveBaselineRef(cwd);
       p3.log.success(`${result.mergedFiles?.length ?? 0} file(s) merged cleanly.`);
@@ -1079,7 +332,7 @@ async function update(cwd, localRepo) {
           p3.log.info(`  ${f}`);
         }
       }
-      const handled = await promptSkipLearning(cwd, componentPaths, version);
+      const handled = await promptSkipLearning(cwd, componentPaths, version, result.conflictedFiles ?? []);
       if (!handled) {
         p3.log.info("");
         p3.log.info("Review:  git diff");
@@ -1101,7 +354,7 @@ async function update(cwd, localRepo) {
 }
 function isGitRepo(cwd) {
   try {
-    execSync3("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+    execSync("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -1109,33 +362,108 @@ function isGitRepo(cwd) {
 }
 function hasUncommittedChanges(cwd) {
   try {
-    const status = execSync3("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
+    const status = execSync("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
     return status.length > 0;
   } catch {
     return false;
   }
 }
-async function promptSkipLearning(cwd, componentPaths, version) {
-  if (!process.stdin.isTTY) return false;
-  const statusOutput = execSync3("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
-  if (!statusOutput) return false;
-  const entries = statusOutput.split("\n").filter(Boolean).map((line) => ({
-    status: line.slice(0, 2).trim(),
-    file: line.slice(3).trim()
-  }));
-  const changedFiles = entries.map((e) => e.file).filter((f) => {
+async function findPinnedFilesWithUpdates(cwd, repoDir, components, componentPaths, vars, version, componentSkips, rootSkip) {
+  const { mkdir: mkdir5, rm: rm2, readFile: readFile7 } = await import("fs/promises");
+  const { tmpdir: tmpdir2 } = await import("os");
+  const { writeTemplateToDir: writeTemplateToDir2 } = await import("./baseline-72Z7TC2E.js");
+  const config = await readProjxConfig(cwd);
+  const rootPinned = Array.isArray(config.skip) ? config.skip : [];
+  const componentPinned = [];
+  for (const component of components) {
+    const dir = componentPaths[component];
+    const marker = await readComponentMarker(join2(cwd, dir));
+    if (marker?.skip && marker.skip.length > 0) {
+      componentPinned.push({ component, dir, patterns: marker.skip });
+    }
+  }
+  if (rootPinned.length === 0 && componentPinned.length === 0) return [];
+  const tmpTemplate = join2(tmpdir2(), `projx-pinned-${Date.now()}`);
+  await mkdir5(tmpTemplate, { recursive: true });
+  void componentSkips;
+  void rootSkip;
+  try {
+    await writeTemplateToDir2(tmpTemplate, repoDir, components, componentPaths, vars, version, {
+      componentSkips: {},
+      rootSkip: [],
+      realCwd: tmpTemplate
+    });
+    const updates = [];
+    for (const file of rootPinned) {
+      const tmplPath = join2(tmpTemplate, file);
+      const userPath = join2(cwd, file);
+      if (!existsSync2(tmplPath) || !existsSync2(userPath)) continue;
+      const tmplContent = await readFile7(tmplPath, "utf-8");
+      const userContent = await readFile7(userPath, "utf-8");
+      if (tmplContent !== userContent) updates.push(file);
+    }
+    for (const { dir, patterns } of componentPinned) {
+      for (const pattern of patterns) {
+        if (pattern.includes("*")) continue;
+        const rel = `${dir}/${pattern}`;
+        const tmplPath = join2(tmpTemplate, rel);
+        const userPath = join2(cwd, rel);
+        if (!existsSync2(tmplPath) || !existsSync2(userPath)) continue;
+        const tmplContent = await readFile7(tmplPath, "utf-8");
+        const userContent = await readFile7(userPath, "utf-8");
+        if (tmplContent !== userContent) updates.push(rel);
+      }
+    }
+    return updates;
+  } finally {
+    await rm2(tmpTemplate, { recursive: true, force: true });
+  }
+}
+function findFilesWithConflictMarkers(cwd) {
+  try {
+    const out = execSync(
+      `git -c core.quotepath=off grep -lE '^<<<<<<< (your changes|HEAD)'`,
+      { cwd, stdio: "pipe" }
+    ).toString().trim();
+    if (!out) return [];
+    return out.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function promptSkipLearning(cwd, componentPaths, version, conflictedFiles) {
+  const changedFiles = conflictedFiles.filter((f) => {
     const base = f.split("/").pop();
     if (base === ".projx" || base === COMPONENT_MARKER) return false;
     return true;
   });
   if (changedFiles.length === 0) return false;
-  p3.log.warn(`${changedFiles.length} template file(s) differ from your code.`);
+  if (!process.stdin.isTTY) {
+    p3.log.info("Non-interactive: skipping prompt. Resolve conflicts manually with `git diff` then `git add`.");
+    p3.log.info("Re-run `npx create-projx update` later to interactively decide which files to keep.");
+    return false;
+  }
+  const statusOutput = execSync("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
+  const entries = statusOutput.split("\n").filter(Boolean).map((line) => ({
+    status: line.slice(0, 2).trim(),
+    file: line.slice(3).trim()
+  }));
+  p3.log.warn(`${changedFiles.length} file(s) have conflicts to resolve.`);
+  p3.log.info("Each file is currently in your working tree with conflict markers.");
+  p3.log.info("");
+  p3.log.info("CHECKED  = keep your version, resolve markers manually, commit when ready");
+  p3.log.info("UNCHECKED = discard template's changes AND skip this file on future updates");
+  p3.log.info("");
   const selected = await p3.multiselect({
-    message: "Select files to KEEP (unselected will be discarded and skipped on future updates)",
+    message: "Which files do you want to KEEP?",
     options: changedFiles.map((f) => ({ value: f, label: f })),
     required: false
   });
-  if (p3.isCancel(selected)) return false;
+  if (p3.isCancel(selected)) {
+    p3.log.warn("Cancelled. Conflict markers remain in the working tree.");
+    p3.log.info("Re-run `npx create-projx update` later to resume the prompt.");
+    return false;
+  }
   const kept = new Set(selected);
   const discarded = changedFiles.filter((f) => !kept.has(f));
   if (discarded.length > 0) {
@@ -1143,9 +471,9 @@ async function promptSkipLearning(cwd, componentPaths, version) {
       const entry = entries.find((e) => e.file === file);
       try {
         if (entry?.status === "??") {
-          await unlink(join5(cwd, file));
+          await unlink(join2(cwd, file));
         } else {
-          execSync3(`git checkout -- "${file}"`, { cwd, stdio: "pipe" });
+          execSync(`git checkout -- "${file}"`, { cwd, stdio: "pipe" });
         }
       } catch {
       }
@@ -1156,7 +484,7 @@ async function promptSkipLearning(cwd, componentPaths, version) {
     );
   }
   if (kept.size > 0) {
-    p3.log.info(`${kept.size} file(s) kept \u2014 commit when ready:`);
+    p3.log.info(`${kept.size} file(s) kept with conflict markers \u2014 resolve and commit:`);
     p3.log.info(
       `  git add . && git commit -m "projx: update to v${version}"`
     );
@@ -1190,42 +518,33 @@ async function learnSkips(cwd, files, componentPaths) {
   }
   for (const [component, additions] of Object.entries(componentSkipAdds)) {
     const dir = componentPaths[component];
-    const markerPath = join5(cwd, dir, COMPONENT_MARKER);
-    try {
-      const data = JSON.parse(await readFile5(markerPath, "utf-8"));
-      const existing = data.skip ?? [];
-      data.skip = [.../* @__PURE__ */ new Set([...existing, ...additions])];
-      await writeFile3(markerPath, JSON.stringify(data, null, 2) + "\n");
-    } catch {
-    }
+    const marker = await readComponentMarker(join2(cwd, dir));
+    if (!marker) continue;
+    const merged = [.../* @__PURE__ */ new Set([...marker.skip, ...additions])];
+    await writeComponentMarker(join2(cwd, dir), { ...marker, skip: merged });
   }
   if (rootSkipAdds.length > 0) {
-    const configPath = join5(cwd, ".projx");
-    try {
-      const data = JSON.parse(await readFile5(configPath, "utf-8"));
-      const existing = data.skip ?? [];
-      data.skip = [.../* @__PURE__ */ new Set([...existing, ...rootSkipAdds])];
-      await writeFile3(configPath, JSON.stringify(data, null, 2) + "\n");
-    } catch {
-    }
+    const config = await readProjxConfig(cwd);
+    const existing = Array.isArray(config.skip) ? config.skip : [];
+    const merged = [.../* @__PURE__ */ new Set([...existing, ...rootSkipAdds])];
+    await writeProjxConfig(cwd, { ...config, skip: merged });
   }
 }
 
 // src/add.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync5 } from "fs";
-import { readFile as readFile6 } from "fs/promises";
-import { join as join6 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync3 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
 import * as p4 from "@clack/prompts";
 async function add(cwd, newComponents, localRepo, skipInstall = false) {
   p4.intro("projx add");
   const isLocal = !!localRepo;
-  const configPath = join6(cwd, ".projx");
-  if (!existsSync5(configPath)) {
+  if (!existsSync3(join3(cwd, ".projx"))) {
     p4.log.error("No .projx file found. Run 'npx create-projx <name>' to create a project first.");
     process.exit(1);
   }
-  const config = JSON.parse(await readFile6(configPath, "utf-8"));
-  const existing = config.components;
+  const config = await readProjxConfig(cwd);
+  const { components: existing } = await discoverComponentsFromMarkers(cwd);
   const alreadyExists = newComponents.filter((c) => existing.includes(c));
   if (alreadyExists.length > 0) {
     p4.log.warn(`Already present: ${alreadyExists.join(", ")}. Skipping those.`);
@@ -1252,19 +571,19 @@ async function add(cwd, newComponents, localRepo, skipInstall = false) {
     const pm = config.packageManager ?? "npm";
     const name = detectProjectName(cwd, existing, paths);
     const vars = { projectName: name, components: allComponents, paths, pm: pmCommands(pm) };
-    const pkg = JSON.parse(await readFile6(join6(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile3(join3(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
     const spinner7 = p4.spinner();
     spinner7.start("Adding components");
-    await writeTemplateToDir(cwd, repoDir, allComponents, paths, vars, version, "scaffold");
+    await writeTemplateToDir(cwd, repoDir, allComponents, paths, vars, version, { realCwd: cwd });
     spinner7.stop("Components added.");
     if (!skipInstall) {
       await installDeps2(cwd, toAdd, pm);
     }
     for (const component of toAdd) {
-      const example = join6(cwd, component, ".env.example");
-      const env = join6(cwd, component, ".env");
-      if (existsSync5(example) && !existsSync5(env)) {
+      const example = join3(cwd, component, ".env.example");
+      const env = join3(cwd, component, ".env");
+      if (existsSync3(example) && !existsSync3(env)) {
         try {
           copyFileSync2(example, env);
         } catch {
@@ -1288,7 +607,7 @@ async function installDeps2(dest, components, pm) {
         case "fastapi":
           if (hasCommand("uv")) {
             spinner7.start("Installing FastAPI dependencies");
-            exec("uv sync --all-extras", join6(dest, "fastapi"));
+            exec("uv sync --all-extras", join3(dest, "fastapi"));
             spinner7.stop("FastAPI dependencies installed.");
           } else {
             p4.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
@@ -1297,7 +616,7 @@ async function installDeps2(dest, components, pm) {
         case "fastify":
           if (hasCommand(pmBin)) {
             spinner7.start(`Installing Fastify dependencies (${cmds.install})`);
-            exec(cmds.install, join6(dest, "fastify"));
+            exec(cmds.install, join3(dest, "fastify"));
             spinner7.stop("Fastify dependencies installed.");
           } else {
             p4.log.warn(`${pm} not found \u2014 run 'cd fastify && ${cmds.install}' manually.`);
@@ -1306,7 +625,7 @@ async function installDeps2(dest, components, pm) {
         case "frontend":
           if (hasCommand(pmBin)) {
             spinner7.start(`Installing Frontend dependencies (${cmds.install})`);
-            exec(cmds.install, join6(dest, "frontend"));
+            exec(cmds.install, join3(dest, "frontend"));
             spinner7.stop("Frontend dependencies installed.");
           } else {
             p4.log.warn(`${pm} not found \u2014 run 'cd frontend && ${cmds.install}' manually.`);
@@ -1315,7 +634,7 @@ async function installDeps2(dest, components, pm) {
         case "e2e":
           if (hasCommand(pmBin)) {
             spinner7.start(`Installing E2E dependencies (${cmds.install})`);
-            exec(cmds.install, join6(dest, "e2e"));
+            exec(cmds.install, join3(dest, "e2e"));
             spinner7.stop("E2E dependencies installed.");
           } else {
             p4.log.warn(`${pm} not found \u2014 run 'cd e2e && ${cmds.install}' manually.`);
@@ -1324,7 +643,7 @@ async function installDeps2(dest, components, pm) {
         case "mobile":
           if (hasCommand("flutter")) {
             spinner7.start("Installing Flutter dependencies");
-            exec("flutter pub get", join6(dest, "mobile"));
+            exec("flutter pub get", join3(dest, "mobile"));
             spinner7.stop("Flutter dependencies installed.");
           } else {
             p4.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
@@ -1340,22 +659,22 @@ async function installDeps2(dest, components, pm) {
 }
 
 // src/init.ts
-import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile7 } from "fs/promises";
-import { execSync as execSync4 } from "child_process";
-import { join as join8 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { execSync as execSync2 } from "child_process";
+import { join as join5 } from "path";
 import * as p5 from "@clack/prompts";
 
 // src/detect.ts
-import { existsSync as existsSync6 } from "fs";
-import { readdir as readdir2 } from "fs/promises";
-import { join as join7 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { readdir } from "fs/promises";
+import { join as join4 } from "path";
 async function detectComponents(cwd) {
   const results = [];
-  const entries = await readdir2(cwd, { withFileTypes: true });
+  const entries = await readdir(cwd, { withFileTypes: true });
   const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !EXCLUDE.has(e.name)).map((e) => e.name);
   for (const dir of dirs) {
-    const full = join7(cwd, dir);
+    const full = join4(cwd, dir);
     const detections = await scanDirectory(full, dir);
     results.push(...detections);
   }
@@ -1363,7 +682,7 @@ async function detectComponents(cwd) {
 }
 async function scanDirectory(dir, relPath) {
   const results = [];
-  const pyproject = await readFileOrNull(join7(dir, "pyproject.toml"));
+  const pyproject = await readFileOrNull(join4(dir, "pyproject.toml"));
   if (pyproject && /fastapi/i.test(pyproject)) {
     results.push({
       component: "fastapi",
@@ -1400,7 +719,7 @@ async function scanDirectory(dir, relPath) {
       });
     }
   }
-  const pubspec = await readFileOrNull(join7(dir, "pubspec.yaml"));
+  const pubspec = await readFileOrNull(join4(dir, "pubspec.yaml"));
   if (pubspec && /flutter:/i.test(pubspec)) {
     results.push({
       component: "mobile",
@@ -1409,7 +728,7 @@ async function scanDirectory(dir, relPath) {
       evidence: "pubspec.yaml has flutter dependency"
     });
   }
-  const hasTf = existsSync6(join7(dir, "main.tf")) || existsSync6(join7(dir, "variables.tf")) || existsSync6(join7(dir, "stack/main.tf")) || existsSync6(join7(dir, "versions.tf"));
+  const hasTf = existsSync4(join4(dir, "main.tf")) || existsSync4(join4(dir, "variables.tf")) || existsSync4(join4(dir, "stack/main.tf")) || existsSync4(join4(dir, "versions.tf"));
   if (hasTf) {
     results.push({
       component: "infra",
@@ -1421,7 +740,7 @@ async function scanDirectory(dir, relPath) {
   return results;
 }
 async function readPkg(dir) {
-  const content = await readFileOrNull(join7(dir, "package.json"));
+  const content = await readFileOrNull(join4(dir, "package.json"));
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -1434,7 +753,7 @@ async function readPkg(dir) {
 async function init(cwd, localRepo) {
   p5.intro("projx init");
   const isLocal = !!localRepo;
-  if (existsSync7(join8(cwd, ".projx"))) {
+  if (existsSync5(join5(cwd, ".projx"))) {
     p5.log.error("This project is already initialized. Use 'npx create-projx update' or 'npx create-projx add' instead.");
     process.exit(1);
   }
@@ -1494,15 +813,15 @@ async function init(cwd, localRepo) {
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    const pkg = JSON.parse(await readFile7(join8(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile4(join5(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
     const applySpinner = p5.spinner();
     applySpinner.start("Applying template");
-    const result = await applyTemplate(cwd, repoDir, components, paths, vars, version, "init");
+    const result = await applyTemplate(cwd, repoDir, components, paths, vars, version, void 0, void 0, true);
     applySpinner.stop("Template applied.");
-    if (existsSync7(join8(cwd, ".githooks"))) {
+    if (existsSync5(join5(cwd, ".githooks"))) {
       try {
-        execSync4("git config core.hooksPath .githooks", { cwd, stdio: "pipe" });
+        execSync2("git config core.hooksPath .githooks", { cwd, stdio: "pipe" });
       } catch {
       }
     }
@@ -1561,7 +880,7 @@ async function manualSelect(cwd) {
       defaultValue: component
     });
     if (p5.isCancel(dir)) process.exit(0);
-    if (!existsSync7(join8(cwd, dir))) {
+    if (!existsSync5(join5(cwd, dir))) {
       p5.log.warn(`${dir}/ does not exist \u2014 skipping.`);
       continue;
     }
@@ -1571,7 +890,7 @@ async function manualSelect(cwd) {
 }
 function isGitRepo2(cwd) {
   try {
-    execSync4("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+    execSync2("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -1579,7 +898,7 @@ function isGitRepo2(cwd) {
 }
 function hasUncommittedChanges2(cwd) {
   try {
-    const status = execSync4("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
+    const status = execSync2("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
     return status.length > 0;
   } catch {
     return false;
@@ -1587,9 +906,8 @@ function hasUncommittedChanges2(cwd) {
 }
 
 // src/pin.ts
-import { existsSync as existsSync8 } from "fs";
-import { readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
-import { join as join9 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
 import * as p6 from "@clack/prompts";
 function classifyPattern(pattern, componentPaths) {
   const dirToComponent = {};
@@ -1609,12 +927,11 @@ function classifyPattern(pattern, componentPaths) {
 }
 async function pin(cwd, patterns) {
   p6.intro("projx pin");
-  const configPath = join9(cwd, ".projx");
-  if (!existsSync8(configPath)) {
+  if (!existsSync6(join6(cwd, ".projx"))) {
     p6.log.error("No .projx file found. Run 'npx create-projx init' first.");
     process.exit(1);
   }
-  const config = JSON.parse(await readFile8(configPath, "utf-8"));
+  const config = await readProjxConfig(cwd);
   const componentPaths = (await discoverComponentsFromMarkers(cwd)).paths;
   const rootAdds = [];
   const componentAdds = {};
@@ -1633,30 +950,27 @@ async function pin(cwd, patterns) {
   }
   for (const [component, additions] of Object.entries(componentAdds)) {
     const dir = componentPaths[component];
-    const markerPath = join9(cwd, dir, COMPONENT_MARKER);
-    try {
-      const data = JSON.parse(await readFile8(markerPath, "utf-8"));
-      const existing = data.skip ?? [];
-      const merged = [.../* @__PURE__ */ new Set([...existing, ...additions])];
-      const added = merged.length - existing.length;
-      if (added > 0) {
-        data.skip = merged;
-        await writeFile4(markerPath, JSON.stringify(data, null, 2) + "\n");
-        p6.log.success(`${component}: pinned ${additions.join(", ")}`);
-      } else {
-        p6.log.info(`${component}: already pinned.`);
-      }
-    } catch {
+    const marker = await readComponentMarker(join6(cwd, dir));
+    if (!marker) {
       p6.log.error(`Could not read marker for ${component}.`);
+      continue;
+    }
+    const merged = [.../* @__PURE__ */ new Set([...marker.skip, ...additions])];
+    const added = merged.length - marker.skip.length;
+    if (added > 0) {
+      const next = { ...marker, skip: merged };
+      await writeComponentMarker(join6(cwd, dir), next);
+      p6.log.success(`${component}: pinned ${additions.join(", ")}`);
+    } else {
+      p6.log.info(`${component}: already pinned.`);
     }
   }
   if (rootAdds.length > 0) {
-    const existing = config.skip ?? [];
+    const existing = Array.isArray(config.skip) ? config.skip : [];
     const merged = [.../* @__PURE__ */ new Set([...existing, ...rootAdds])];
     const added = merged.length - existing.length;
     if (added > 0) {
-      config.skip = merged;
-      await writeFile4(configPath, JSON.stringify(config, null, 2) + "\n");
+      await writeProjxConfig(cwd, { ...config, skip: merged });
       p6.log.success(`root: pinned ${rootAdds.join(", ")}`);
     } else {
       p6.log.info("root: already pinned.");
@@ -1666,12 +980,11 @@ async function pin(cwd, patterns) {
 }
 async function unpin(cwd, patterns) {
   p6.intro("projx unpin");
-  const configPath = join9(cwd, ".projx");
-  if (!existsSync8(configPath)) {
+  if (!existsSync6(join6(cwd, ".projx"))) {
     p6.log.error("No .projx file found. Run 'npx create-projx init' first.");
     process.exit(1);
   }
-  const config = JSON.parse(await readFile8(configPath, "utf-8"));
+  const config = await readProjxConfig(cwd);
   const componentPaths = (await discoverComponentsFromMarkers(cwd)).paths;
   const rootRemoves = [];
   const componentRemoves = {};
@@ -1686,38 +999,27 @@ async function unpin(cwd, patterns) {
   }
   for (const [component, removals] of Object.entries(componentRemoves)) {
     const dir = componentPaths[component];
-    const markerPath = join9(cwd, dir, COMPONENT_MARKER);
-    try {
-      const data = JSON.parse(await readFile8(markerPath, "utf-8"));
-      const existing = data.skip ?? [];
-      const filtered = existing.filter((s) => !removals.includes(s));
-      const removed = existing.length - filtered.length;
-      if (removed > 0) {
-        if (filtered.length > 0) {
-          data.skip = filtered;
-        } else {
-          delete data.skip;
-        }
-        await writeFile4(markerPath, JSON.stringify(data, null, 2) + "\n");
-        p6.log.success(`${component}: unpinned ${removals.join(", ")}`);
-      } else {
-        p6.log.info(`${component}: not found in skip list.`);
-      }
-    } catch {
+    const marker = await readComponentMarker(join6(cwd, dir));
+    if (!marker) {
       p6.log.error(`Could not read marker for ${component}.`);
+      continue;
+    }
+    const filtered = marker.skip.filter((s) => !removals.includes(s));
+    const removed = marker.skip.length - filtered.length;
+    if (removed > 0) {
+      const next = { ...marker, skip: filtered };
+      await writeComponentMarker(join6(cwd, dir), next);
+      p6.log.success(`${component}: unpinned ${removals.join(", ")}`);
+    } else {
+      p6.log.info(`${component}: not found in skip list.`);
     }
   }
   if (rootRemoves.length > 0) {
-    const existing = config.skip ?? [];
+    const existing = Array.isArray(config.skip) ? config.skip : [];
     const filtered = existing.filter((s) => !rootRemoves.includes(s));
     const removed = existing.length - filtered.length;
     if (removed > 0) {
-      if (filtered.length > 0) {
-        config.skip = filtered;
-      } else {
-        delete config.skip;
-      }
-      await writeFile4(configPath, JSON.stringify(config, null, 2) + "\n");
+      await writeProjxConfig(cwd, { ...config, skip: filtered });
       p6.log.success(`root: unpinned ${rootRemoves.join(", ")}`);
     } else {
       p6.log.info("root: not found in skip list.");
@@ -1727,24 +1029,24 @@ async function unpin(cwd, patterns) {
 }
 async function listPins(cwd) {
   p6.intro("projx pin --list");
-  const configPath = join9(cwd, ".projx");
-  if (!existsSync8(configPath)) {
+  if (!existsSync6(join6(cwd, ".projx"))) {
     p6.log.error("No .projx file found. Run 'npx create-projx init' first.");
     process.exit(1);
   }
-  const config = JSON.parse(await readFile8(configPath, "utf-8"));
+  const config = await readProjxConfig(cwd);
   const { components: discovered, paths: componentPaths } = await discoverComponentsFromMarkers(cwd);
   let hasAny = false;
-  if (config.skip && config.skip.length > 0) {
+  const rootSkip = Array.isArray(config.skip) ? config.skip : [];
+  if (rootSkip.length > 0) {
     hasAny = true;
     p6.log.info("root:");
-    for (const s of config.skip) {
+    for (const s of rootSkip) {
       p6.log.info(`  ${s}`);
     }
   }
   for (const component of discovered) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join9(cwd, dir));
+    const marker = await readComponentMarker(join6(cwd, dir));
     if (marker?.skip && marker.skip.length > 0) {
       hasAny = true;
       const label = dir !== component ? `${component} (${dir}/)` : `${component}`;
@@ -1761,15 +1063,15 @@ async function listPins(cwd) {
 }
 
 // src/doctor.ts
-import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile9, readdir as readdir3 } from "fs/promises";
-import { execSync as execSync5 } from "child_process";
-import { join as join10 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import { execSync as execSync3 } from "child_process";
+import { join as join7 } from "path";
 import * as p7 from "@clack/prompts";
 async function checkConfig(cwd) {
   const results = [];
-  const configPath = join10(cwd, ".projx");
-  if (!existsSync9(configPath)) {
+  const configPath = join7(cwd, ".projx");
+  if (!existsSync7(configPath)) {
     results.push({
       name: ".projx exists",
       status: "fail",
@@ -1778,44 +1080,41 @@ async function checkConfig(cwd) {
     });
     return { results };
   }
-  let config;
-  try {
-    config = JSON.parse(await readFile9(configPath, "utf-8"));
-  } catch {
+  const rootConfig = await readProjxConfig(cwd);
+  if (Object.keys(rootConfig).length === 0) {
     results.push({
       name: ".projx valid JSON",
       status: "fail",
-      message: ".projx contains invalid JSON."
+      message: ".projx contains invalid JSON or is empty."
     });
     return { results };
   }
-  results.push({ name: ".projx exists", status: "pass", message: `v${config.version}` });
-  if (!config.version || !config.components || !Array.isArray(config.components)) {
+  results.push({ name: ".projx exists", status: "pass", message: `v${rootConfig.version ?? "unknown"}` });
+  if (!rootConfig.version) {
     results.push({
       name: ".projx fields",
-      status: "fail",
-      message: "Missing required fields (version, components)."
-    });
-    return { results };
-  }
-  const invalid = config.components.filter((c) => !COMPONENTS.includes(c));
-  if (invalid.length > 0) {
-    results.push({
-      name: "component names",
       status: "warn",
-      message: `Unknown components: ${invalid.join(", ")}`
+      message: "Missing version field."
     });
-  } else {
-    results.push({ name: "component names", status: "pass", message: `${config.components.length} valid` });
   }
-  return { results, config };
+  return { results, rootConfig };
 }
-async function checkComponents(cwd, config, componentPaths) {
+async function checkComponents(cwd, components, componentPaths) {
   const results = [];
-  for (const component of config.components) {
+  if (components.length === 0) {
+    results.push({
+      name: "components",
+      status: "fail",
+      message: `No ${COMPONENT_MARKER} files found in any directory.`,
+      fix: "Run 'npx create-projx init' to detect and mark components."
+    });
+    return results;
+  }
+  results.push({ name: "components", status: "pass", message: `${components.length} discovered from markers` });
+  for (const component of components) {
     const dir = componentPaths[component];
-    const fullDir = join10(cwd, dir);
-    if (!existsSync9(fullDir)) {
+    const fullDir = join7(cwd, dir);
+    if (!existsSync7(fullDir)) {
       results.push({
         name: `${component} directory`,
         status: "fail",
@@ -1833,53 +1132,28 @@ async function checkComponents(cwd, config, componentPaths) {
       });
       continue;
     }
-    if (!marker.components.includes(component)) {
-      results.push({
-        name: `${component} marker`,
-        status: "warn",
-        message: `Marker in ${dir}/ does not list "${component}".`
-      });
-    } else {
-      const label = dir !== component ? `${dir}/ (${component})` : `${component}/`;
-      results.push({ name: `${component} marker`, status: "pass", message: label });
-    }
-  }
-  try {
-    const entries = await readdir3(cwd, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const markerPath = join10(cwd, entry.name, COMPONENT_MARKER);
-      if (!existsSync9(markerPath)) continue;
-      const isKnown = Object.values(componentPaths).includes(entry.name);
-      if (!isKnown) {
-        results.push({
-          name: `orphan marker`,
-          status: "warn",
-          message: `${entry.name}/ has a ${COMPONENT_MARKER} but is not in .projx components.`
-        });
-      }
-    }
-  } catch {
+    const label = dir !== component ? `${dir}/ (${component})` : `${component}/`;
+    results.push({ name: `${component} marker`, status: "pass", message: label });
   }
   return results;
 }
 function checkGit(cwd, fix) {
   const results = [];
   try {
-    execSync5("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+    execSync3("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
     results.push({ name: "git repo", status: "pass", message: "OK" });
   } catch {
     results.push({ name: "git repo", status: "fail", message: "Not a git repository." });
     return results;
   }
   try {
-    const ref = execSync5(`git rev-parse --verify ${BASELINE_REF}`, { cwd, stdio: "pipe" }).toString().trim();
+    const ref = execSync3(`git rev-parse --verify ${BASELINE_REF}`, { cwd, stdio: "pipe" }).toString().trim();
     results.push({ name: "baseline ref", status: "pass", message: ref.slice(0, 8) });
   } catch {
     if (fix) {
       saveBaselineRef(cwd);
       try {
-        execSync5(`git rev-parse --verify ${BASELINE_REF}`, { cwd, stdio: "pipe" });
+        execSync3(`git rev-parse --verify ${BASELINE_REF}`, { cwd, stdio: "pipe" });
         results.push({ name: "baseline ref", status: "pass", message: "Created from git history." });
       } catch {
         results.push({
@@ -1899,11 +1173,11 @@ function checkGit(cwd, fix) {
     }
   }
   try {
-    const worktrees = execSync5("git worktree list --porcelain", { cwd, stdio: "pipe" }).toString();
+    const worktrees = execSync3("git worktree list --porcelain", { cwd, stdio: "pipe" }).toString();
     const stale = worktrees.split("\n").filter((l) => l.includes("projx-wt-") || l.includes("projx/tmp-"));
     if (stale.length > 0) {
       if (fix) {
-        execSync5("git worktree prune", { cwd, stdio: "pipe" });
+        execSync3("git worktree prune", { cwd, stdio: "pipe" });
         results.push({ name: "worktrees", status: "pass", message: "Pruned stale worktrees." });
       } else {
         results.push({
@@ -1921,7 +1195,7 @@ function checkGit(cwd, fix) {
     results.push({ name: "worktrees", status: "pass", message: "OK" });
   }
   try {
-    const status = execSync5("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
+    const status = execSync3("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
     if (status) {
       const count = status.split("\n").length;
       results.push({ name: "working tree", status: "warn", message: `${count} uncommitted change(s).` });
@@ -1932,26 +1206,25 @@ function checkGit(cwd, fix) {
   }
   return results;
 }
-async function checkSkipPatterns(cwd, config, componentPaths) {
+async function checkSkipPatterns(cwd, rootConfig, components, componentPaths) {
   const results = [];
-  if (config.skip && config.skip.length > 0) {
-    for (const pattern of config.skip) {
-      const matches = await patternMatchesAnything(cwd, pattern);
-      if (!matches) {
-        results.push({
-          name: "root skip",
-          status: "warn",
-          message: `"${pattern}" matches no files \u2014 stale?`
-        });
-      }
+  const rootSkip = Array.isArray(rootConfig.skip) ? rootConfig.skip : [];
+  for (const pattern of rootSkip) {
+    const matches = await patternMatchesAnything(cwd, pattern);
+    if (!matches) {
+      results.push({
+        name: "root skip",
+        status: "warn",
+        message: `"${pattern}" matches no files \u2014 stale?`
+      });
     }
   }
-  for (const component of config.components) {
+  for (const component of components) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join10(cwd, dir));
+    const marker = await readComponentMarker(join7(cwd, dir));
     if (marker?.skip && marker.skip.length > 0) {
       for (const pattern of marker.skip) {
-        const matches = await patternMatchesAnything(join10(cwd, dir), pattern);
+        const matches = await patternMatchesAnything(join7(cwd, dir), pattern);
         if (!matches) {
           results.push({
             name: `${component} skip`,
@@ -1962,23 +1235,23 @@ async function checkSkipPatterns(cwd, config, componentPaths) {
       }
     }
   }
-  if (results.length === 0 && (config.skip?.length || config.components.some(() => true))) {
+  if (results.length === 0 && (rootSkip.length > 0 || components.length > 0)) {
     results.push({ name: "skip patterns", status: "pass", message: "All patterns match files." });
   }
   return results;
 }
 async function patternMatchesAnything(dir, pattern) {
   if (pattern === "**") return true;
-  if (!existsSync9(dir)) return false;
+  if (!existsSync7(dir)) return false;
   const walk = async (current, base) => {
     let entries;
     try {
-      entries = await readdir3(current, { withFileTypes: true });
+      entries = await readdir2(current, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
-      const full = join10(current, entry.name);
+      const full = join7(current, entry.name);
       const rel = full.slice(base.length + 1);
       if (entry.isDirectory()) {
         if (await walk(full, base)) return true;
@@ -1993,17 +1266,16 @@ async function patternMatchesAnything(dir, pattern) {
 async function doctor(cwd, fix = false) {
   p7.intro("projx doctor");
   const allResults = [];
-  const { results: configResults, config } = await checkConfig(cwd);
+  const { results: configResults, rootConfig } = await checkConfig(cwd);
   allResults.push(...configResults);
-  if (!config) {
+  if (!rootConfig) {
     printReport(allResults);
     process.exit(1);
   }
-  const { components: discovered, paths: componentPaths } = await discoverComponentsFromMarkers(cwd);
-  const resolvedConfig = { ...config, components: discovered.length > 0 ? discovered : config.components };
-  allResults.push(...await checkComponents(cwd, resolvedConfig, componentPaths));
+  const { components, paths: componentPaths } = await discoverComponentsFromMarkers(cwd);
+  allResults.push(...await checkComponents(cwd, components, componentPaths));
   allResults.push(...checkGit(cwd, fix));
-  allResults.push(...await checkSkipPatterns(cwd, resolvedConfig, componentPaths));
+  allResults.push(...await checkSkipPatterns(cwd, rootConfig, components, componentPaths));
   printReport(allResults);
   const passed = allResults.filter((r) => r.status === "pass").length;
   const warns = allResults.filter((r) => r.status === "warn").length;
@@ -2027,10 +1299,10 @@ function printReport(results) {
 }
 
 // src/diff.ts
-import { existsSync as existsSync10 } from "fs";
-import { readFile as readFile10, mkdir as mkdir4, rm as rm3 } from "fs/promises";
-import { join as join11 } from "path";
-import { tmpdir as tmpdir3 } from "os";
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile5, mkdir as mkdir2, rm } from "fs/promises";
+import { join as join8 } from "path";
+import { tmpdir } from "os";
 import * as p8 from "@clack/prompts";
 function isSkipped(file, componentPaths, componentSkips, rootSkip) {
   for (const [component, dir] of Object.entries(componentPaths)) {
@@ -2053,23 +1325,21 @@ function fileComponent(file, componentPaths) {
 async function diff(cwd, localRepo) {
   p8.intro("projx diff");
   const isLocal = !!localRepo;
-  const configPath = join11(cwd, ".projx");
-  if (!existsSync10(configPath)) {
+  if (!existsSync8(join8(cwd, ".projx"))) {
     p8.log.error("No .projx file found. Run 'npx create-projx init' first.");
     process.exit(1);
   }
-  const raw = JSON.parse(await readFile10(configPath, "utf-8"));
-  const { components: discovered, paths: componentPaths } = await discoverComponentsFromMarkers(cwd);
-  const config = { ...raw, components: discovered.length > 0 ? discovered : raw.components };
+  const raw = await readProjxConfig(cwd);
+  const { components, paths: componentPaths } = await discoverComponentsFromMarkers(cwd);
   const componentSkips = {};
-  for (const component of config.components) {
+  for (const component of components) {
     const dir = componentPaths[component];
-    const marker = await readComponentMarker(join11(cwd, dir));
+    const marker = await readComponentMarker(join8(cwd, dir));
     if (marker?.skip && marker.skip.length > 0) {
       componentSkips[component] = marker.skip;
     }
   }
-  const rootSkip = config.skip ?? [];
+  const rootSkip = Array.isArray(raw.skip) ? raw.skip : [];
   const dlSpinner = p8.spinner();
   dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
   const repoDir = await downloadRepo(localRepo).catch((err) => {
@@ -2079,16 +1349,20 @@ async function diff(cwd, localRepo) {
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    const pkg = JSON.parse(await readFile10(join11(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile5(join8(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
-    p8.log.info(`Current: v${config.version} \u2192 Template: v${version}`);
-    const name = detectProjectName(cwd, config.components, componentPaths);
-    const vars = { projectName: name, components: config.components, paths: componentPaths, pm: pmCommands(raw.packageManager ?? "npm") };
+    p8.log.info(`Current: v${raw.version ?? "unknown"} \u2192 Template: v${version}`);
+    const name = detectProjectName(cwd, components, componentPaths);
+    const vars = { projectName: name, components, paths: componentPaths, pm: pmCommands(raw.packageManager ?? "npm") };
     const spinner7 = p8.spinner();
     spinner7.start("Analyzing changes");
-    const tmpTemplate = join11(tmpdir3(), `projx-diff-${Date.now()}`);
-    await mkdir4(tmpTemplate, { recursive: true });
-    await writeTemplateToDir(tmpTemplate, repoDir, config.components, componentPaths, vars, version, "scaffold", componentSkips, rootSkip);
+    const tmpTemplate = join8(tmpdir(), `projx-diff-${Date.now()}`);
+    await mkdir2(tmpTemplate, { recursive: true });
+    await writeTemplateToDir(tmpTemplate, repoDir, components, componentPaths, vars, version, {
+      componentSkips,
+      rootSkip,
+      realCwd: cwd
+    });
     const baselineRef = getBaselineRef(cwd);
     const templateFiles = await collectAllFiles(tmpTemplate, tmpTemplate);
     const analyses = [];
@@ -2098,16 +1372,16 @@ async function diff(cwd, localRepo) {
         analyses.push({ file, status: "skipped", component });
         continue;
       }
-      const oursPath = join11(cwd, file);
-      if (!existsSync10(oursPath)) {
+      const oursPath = join8(cwd, file);
+      if (!existsSync8(oursPath)) {
         analyses.push({ file, status: "new", component });
         continue;
       }
       let oursContent;
       let theirsContent;
       try {
-        oursContent = await readFile10(oursPath, "utf-8");
-        theirsContent = await readFile10(join11(tmpTemplate, file), "utf-8");
+        oursContent = await readFile5(oursPath, "utf-8");
+        theirsContent = await readFile5(join8(tmpTemplate, file), "utf-8");
       } catch {
         continue;
       }
@@ -2132,7 +1406,7 @@ async function diff(cwd, localRepo) {
         analyses.push({ file, status: "needs-merge", component });
       }
     }
-    await rm3(tmpTemplate, { recursive: true, force: true });
+    await rm(tmpTemplate, { recursive: true, force: true });
     spinner7.stop("Analysis complete.");
     const groups = {
       "new": [],
@@ -2181,9 +1455,9 @@ async function diff(cwd, localRepo) {
 }
 
 // src/gen.ts
-import { existsSync as existsSync11 } from "fs";
-import { readFile as readFile11, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
-import { join as join12 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile6, writeFile, mkdir as mkdir3 } from "fs/promises";
+import { join as join9 } from "path";
 import * as p9 from "@clack/prompts";
 var FIELD_TYPES = ["string", "number", "boolean", "date", "datetime", "text", "json"];
 function toPascal(s) {
@@ -2840,15 +2114,9 @@ async function resolvePrimaryBackend(cwd, hasFastapi, hasFastify, backendFlag) {
   if (backendFlag) return backendFlag;
   if (hasFastapi && !hasFastify) return "fastapi";
   if (hasFastify && !hasFastapi) return "fastify";
-  const configPath = join12(cwd, ".projx");
-  if (existsSync11(configPath)) {
-    try {
-      const data = JSON.parse(await readFile11(configPath, "utf-8"));
-      if (data.primaryBackend === "fastapi" || data.primaryBackend === "fastify") {
-        return data.primaryBackend;
-      }
-    } catch {
-    }
+  const config = await readProjxConfig(cwd);
+  if (config.primaryBackend === "fastapi" || config.primaryBackend === "fastify") {
+    return config.primaryBackend;
   }
   if (!process.stdin.isTTY) return "fastify";
   const choice = await p9.select({
@@ -2860,23 +2128,17 @@ async function resolvePrimaryBackend(cwd, hasFastapi, hasFastify, backendFlag) {
     initialValue: "fastify"
   });
   if (p9.isCancel(choice)) process.exit(0);
-  try {
-    const data = JSON.parse(await readFile11(configPath, "utf-8"));
-    data.primaryBackend = choice;
-    await writeFile5(configPath, JSON.stringify(data, null, 2) + "\n");
-    p9.log.success(`Saved primaryBackend: ${choice} to .projx`);
-  } catch {
-  }
+  await writeProjxConfig(cwd, { ...config, primaryBackend: choice });
+  p9.log.success(`Saved primaryBackend: ${choice} to .projx`);
   return choice;
 }
 async function gen(cwd, entityName, fieldsFlag, backendFlag) {
   p9.intro(`projx gen entity ${entityName}`);
-  const configPath = join12(cwd, ".projx");
-  if (!existsSync11(configPath)) {
+  if (!existsSync9(join9(cwd, ".projx"))) {
     p9.log.error("No .projx file found. Run 'npx create-projx init' first.");
     process.exit(1);
   }
-  const projxData = JSON.parse(await readFile11(configPath, "utf-8"));
+  const projxData = await readProjxConfig(cwd);
   const pmName = projxData.packageManager ?? "npm";
   const pm = pmCommands(pmName);
   const { components: discovered, paths: componentPaths } = await discoverComponentsFromMarkers(cwd);
@@ -2913,37 +2175,37 @@ async function gen(cwd, entityName, fieldsFlag, backendFlag) {
   const generated = [];
   if (genFastapi) {
     const dir = componentPaths.fastapi;
-    const entityDir = join12(cwd, dir, "src/entities", toSnake(config.name));
-    if (existsSync11(entityDir)) {
+    const entityDir = join9(cwd, dir, "src/entities", toSnake(config.name));
+    if (existsSync9(entityDir)) {
       p9.log.warn(`${dir}/src/entities/${toSnake(config.name)}/ already exists. Skipping FastAPI.`);
     } else {
-      await mkdir5(entityDir, { recursive: true });
-      await writeFile5(join12(entityDir, "_model.py"), generateFastAPIModel(config));
-      await writeFile5(join12(entityDir, "__init__.py"), "from ._model import *\n");
+      await mkdir3(entityDir, { recursive: true });
+      await writeFile(join9(entityDir, "_model.py"), generateFastAPIModel(config));
+      await writeFile(join9(entityDir, "__init__.py"), "from ._model import *\n");
       generated.push(`${dir}/src/entities/${toSnake(config.name)}/_model.py`);
       generated.push(`${dir}/src/entities/${toSnake(config.name)}/__init__.py`);
-      const testsDir = join12(cwd, dir, "tests");
-      const testFile = join12(testsDir, `test_${toSnake(config.name)}_entity.py`);
-      if (existsSync11(testsDir) && !existsSync11(testFile)) {
-        await writeFile5(testFile, generateFastapiTest(config));
+      const testsDir = join9(cwd, dir, "tests");
+      const testFile = join9(testsDir, `test_${toSnake(config.name)}_entity.py`);
+      if (existsSync9(testsDir) && !existsSync9(testFile)) {
+        await writeFile(testFile, generateFastapiTest(config));
         generated.push(`${dir}/tests/test_${toSnake(config.name)}_entity.py`);
       }
     }
   }
   if (genFastify) {
     const dir = componentPaths.fastify;
-    const moduleDir = join12(cwd, dir, "src/modules", toKebab(config.name));
-    if (existsSync11(moduleDir)) {
+    const moduleDir = join9(cwd, dir, "src/modules", toKebab(config.name));
+    if (existsSync9(moduleDir)) {
       p9.log.warn(`${dir}/src/modules/${toKebab(config.name)}/ already exists. Skipping Fastify.`);
     } else {
-      await mkdir5(moduleDir, { recursive: true });
-      await writeFile5(join12(moduleDir, "schemas.ts"), generateFastifySchemas(config));
-      await writeFile5(join12(moduleDir, "index.ts"), generateFastifyIndex(config));
+      await mkdir3(moduleDir, { recursive: true });
+      await writeFile(join9(moduleDir, "schemas.ts"), generateFastifySchemas(config));
+      await writeFile(join9(moduleDir, "index.ts"), generateFastifyIndex(config));
       generated.push(`${dir}/src/modules/${toKebab(config.name)}/schemas.ts`);
       generated.push(`${dir}/src/modules/${toKebab(config.name)}/index.ts`);
-      const appPath = join12(cwd, dir, "src/app.ts");
-      if (existsSync11(appPath)) {
-        const appContent = await readFile11(appPath, "utf-8");
+      const appPath = join9(cwd, dir, "src/app.ts");
+      if (existsSync9(appPath)) {
+        const appContent = await readFile6(appPath, "utf-8");
         const importLine = `import './modules/${toKebab(config.name)}/index.js';`;
         if (!appContent.includes(importLine)) {
           const updated = appContent.replace(
@@ -2952,62 +2214,62 @@ async function gen(cwd, entityName, fieldsFlag, backendFlag) {
 `
           );
           if (updated !== appContent) {
-            await writeFile5(appPath, updated);
+            await writeFile(appPath, updated);
             generated.push(`${dir}/src/app.ts (import added)`);
           }
         }
       }
-      const prismaPath = join12(cwd, dir, "prisma/schema.prisma");
-      if (existsSync11(prismaPath)) {
-        const prismaContent = await readFile11(prismaPath, "utf-8");
+      const prismaPath = join9(cwd, dir, "prisma/schema.prisma");
+      if (existsSync9(prismaPath)) {
+        const prismaContent = await readFile6(prismaPath, "utf-8");
         const modelName = `model ${toPascal(config.name)}`;
         if (!prismaContent.includes(modelName)) {
           const prismaModel = generatePrismaModel(config);
-          await writeFile5(prismaPath, prismaContent.trimEnd() + "\n\n" + prismaModel + "\n");
+          await writeFile(prismaPath, prismaContent.trimEnd() + "\n\n" + prismaModel + "\n");
           generated.push(`${dir}/prisma/schema.prisma (model added)`);
         }
       }
-      const testsModulesDir = join12(cwd, dir, "tests/modules");
-      const fastifyTestFile = join12(testsModulesDir, `${toKebab(config.name)}.test.ts`);
-      if (existsSync11(testsModulesDir) && !existsSync11(fastifyTestFile)) {
-        await writeFile5(fastifyTestFile, generateFastifyTest(config));
+      const testsModulesDir = join9(cwd, dir, "tests/modules");
+      const fastifyTestFile = join9(testsModulesDir, `${toKebab(config.name)}.test.ts`);
+      if (existsSync9(testsModulesDir) && !existsSync9(fastifyTestFile)) {
+        await writeFile(fastifyTestFile, generateFastifyTest(config));
         generated.push(`${dir}/tests/modules/${toKebab(config.name)}.test.ts`);
       }
     }
   }
   if (hasFrontend) {
     const dir = componentPaths.frontend;
-    const typesDir = join12(cwd, dir, "src/types");
+    const typesDir = join9(cwd, dir, "src/types");
     const fileName = toKebab(config.name) + ".ts";
-    const filePath = join12(typesDir, fileName);
-    if (existsSync11(filePath)) {
+    const filePath = join9(typesDir, fileName);
+    if (existsSync9(filePath)) {
       p9.log.warn(`${dir}/src/types/${fileName} already exists. Skipping frontend types.`);
     } else {
-      await mkdir5(typesDir, { recursive: true });
-      await writeFile5(filePath, generateFrontendInterface(config));
+      await mkdir3(typesDir, { recursive: true });
+      await writeFile(filePath, generateFrontendInterface(config));
       generated.push(`${dir}/src/types/${fileName}`);
-      const barrelPath = join12(typesDir, "index.ts");
+      const barrelPath = join9(typesDir, "index.ts");
       const exportLine = `export * from './${toKebab(config.name)}';`;
-      if (existsSync11(barrelPath)) {
-        const content = await readFile11(barrelPath, "utf-8");
+      if (existsSync9(barrelPath)) {
+        const content = await readFile6(barrelPath, "utf-8");
         if (!content.includes(exportLine)) {
-          await writeFile5(barrelPath, content.trimEnd() + "\n" + exportLine + "\n");
+          await writeFile(barrelPath, content.trimEnd() + "\n" + exportLine + "\n");
         }
       } else {
-        await writeFile5(barrelPath, exportLine + "\n");
+        await writeFile(barrelPath, exportLine + "\n");
       }
       generated.push(`${dir}/src/types/index.ts`);
     }
   }
   if (hasMobile) {
     const dir = componentPaths.mobile;
-    const entityDir = join12(cwd, dir, "lib/entities", toSnake(config.name));
-    const modelPath = join12(entityDir, "model.dart");
-    if (existsSync11(modelPath)) {
+    const entityDir = join9(cwd, dir, "lib/entities", toSnake(config.name));
+    const modelPath = join9(entityDir, "model.dart");
+    if (existsSync9(modelPath)) {
       p9.log.warn(`${dir}/lib/entities/${toSnake(config.name)}/model.dart already exists. Skipping mobile model.`);
     } else {
-      await mkdir5(entityDir, { recursive: true });
-      await writeFile5(modelPath, generateDartModel(config));
+      await mkdir3(entityDir, { recursive: true });
+      await writeFile(modelPath, generateDartModel(config));
       generated.push(`${dir}/lib/entities/${toSnake(config.name)}/model.dart`);
     }
   }
@@ -3047,9 +2309,9 @@ async function gen(cwd, entityName, fieldsFlag, backendFlag) {
 }
 
 // src/sync.ts
-import { existsSync as existsSync12, readFileSync as readFileSync2 } from "fs";
-import { writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
-import { join as join13 } from "path";
+import { existsSync as existsSync10, readFileSync } from "fs";
+import { writeFile as writeFile2, mkdir as mkdir4 } from "fs/promises";
+import { join as join10 } from "path";
 import * as p10 from "@clack/prompts";
 function toPascal2(s) {
   return s.replace(/(?:^|[_\-\s])([a-zA-Z])/g, (_, c) => c.toUpperCase());
@@ -3220,8 +2482,8 @@ function generateDartModel2(entity) {
 }
 async function sync(cwd, url) {
   p10.intro("projx sync");
-  const configPath = join13(cwd, ".projx");
-  if (!existsSync12(configPath)) {
+  const configPath = join10(cwd, ".projx");
+  if (!existsSync10(configPath)) {
     p10.log.error("No .projx file found. Run 'npx create-projx init' first.");
     process.exit(1);
   }
@@ -3253,18 +2515,18 @@ async function sync(cwd, url) {
   const generated = [];
   if (hasFrontend) {
     const dir = componentPaths.frontend;
-    const typesDir = join13(cwd, dir, "src/types");
-    await mkdir6(typesDir, { recursive: true });
+    const typesDir = join10(cwd, dir, "src/types");
+    await mkdir4(typesDir, { recursive: true });
     const barrelExports = [];
     for (const entity of meta.entities) {
       const fileName = toKebab(toSnake(entity.name)) + ".ts";
-      const filePath = join13(typesDir, fileName);
-      await writeFile6(filePath, generateTsInterface(entity));
+      const filePath = join10(typesDir, fileName);
+      await writeFile2(filePath, generateTsInterface(entity));
       generated.push(`${dir}/src/types/${fileName}`);
       barrelExports.push(`export * from './${toKebab(toSnake(entity.name))}';`);
     }
-    await writeFile6(
-      join13(typesDir, "index.ts"),
+    await writeFile2(
+      join10(typesDir, "index.ts"),
       barrelExports.join("\n") + "\n"
     );
     generated.push(`${dir}/src/types/index.ts`);
@@ -3272,10 +2534,10 @@ async function sync(cwd, url) {
   if (hasMobile) {
     const dir = componentPaths.mobile;
     for (const entity of meta.entities) {
-      const entityDir = join13(cwd, dir, "lib/entities", toSnake(entity.name));
-      await mkdir6(entityDir, { recursive: true });
-      const modelPath = join13(entityDir, "model.dart");
-      await writeFile6(modelPath, generateDartModel2(entity));
+      const entityDir = join10(cwd, dir, "lib/entities", toSnake(entity.name));
+      await mkdir4(entityDir, { recursive: true });
+      const modelPath = join10(entityDir, "model.dart");
+      await writeFile2(modelPath, generateDartModel2(entity));
       generated.push(`${dir}/lib/entities/${toSnake(entity.name)}/model.dart`);
     }
   }
@@ -3298,10 +2560,10 @@ async function sync(cwd, url) {
 function detectMetaUrl(cwd) {
   const envFiles = [".env", ".env.dev", ".env.local"];
   for (const envFile of envFiles) {
-    const envPath = join13(cwd, envFile);
-    if (existsSync12(envPath)) {
+    const envPath = join10(cwd, envFile);
+    if (existsSync10(envPath)) {
       try {
-        const content = readFileSync2(envPath, "utf-8");
+        const content = readFileSync(envPath, "utf-8");
         const match = content.match(/VITE_API_URL\s*=\s*(.+)/);
         if (match) {
           const base = match[1].trim().replace(/["']/g, "");
@@ -3317,10 +2579,10 @@ function detectMetaUrl(cwd) {
     "frontend/.env.dev"
   ];
   for (const envFile of frontendEnvFiles) {
-    const envPath = join13(cwd, envFile);
-    if (existsSync12(envPath)) {
+    const envPath = join10(cwd, envFile);
+    if (existsSync10(envPath)) {
       try {
-        const content = readFileSync2(envPath, "utf-8");
+        const content = readFileSync(envPath, "utf-8");
         const match = content.match(/VITE_API_URL\s*=\s*(.+)/);
         if (match) {
           const base = match[1].trim().replace(/["']/g, "");
@@ -3390,7 +2652,7 @@ function parseArgs() {
       continue;
     }
     if (arg === "--local") {
-      localRepo = resolve2(args[++i] || ".");
+      localRepo = resolve(args[++i] || ".");
       continue;
     }
     if (arg === "--no-git") {
@@ -3562,8 +2824,8 @@ async function main() {
     opts.git = options.git ?? opts.git;
     opts.install = options.install ?? opts.install;
   }
-  const dest = resolve2(process.cwd(), opts.name);
-  if (existsSync13(dest)) {
+  const dest = resolve(process.cwd(), opts.name);
+  if (existsSync11(dest)) {
     console.error(`Error: ${dest} already exists.`);
     process.exit(1);
   }