create-projx 1.3.4 → 1.3.6

package/README.md

@@ -87,23 +87,37 @@ cd my-app
 npx create-projx@latest update
 ```
 
-Uses a `projx/baseline` branch that tracks the raw template state. When you update, the baseline advances to the new template version and merges into your branch using git's three-way merge:
+Updates use a 3-tier merge strategy:
 
-- **Files only the template changed** — auto-merged, no action needed
-- **Files only you changed** — preserved, untouched
-- **Files both sides changed** — git conflict, you resolve
+1. **Git merge** — if the template merges cleanly with your code, it's auto-committed. Done.
+2. **3-way merge** — if git merge fails, each file is merged individually using `git merge-file`. Your additions (extra deps, env vars, custom config) are preserved alongside template updates. Clean merges are auto-staged; only true conflicts need review.
+3. **Direct copy** — if no merge baseline exists, template files are written directly. You pick which changes to keep via an interactive prompt, and discarded files are automatically added to your skip list.
 
-```bash
-# If conflicts occur:
-git status                    # see conflicted files
-# resolve conflicts in your editor
-git add . && git commit       # finish the merge
+Your custom files (controllers, pages, middleware) are never deleted. Files you created that don't exist in the template are always preserved.
+
+### Skip Files
+
+To skip component source files, add `skip` to `.projx-component`:
 
-# Or abort:
-git merge --abort
+```json
+{
+  "components": ["fastapi"],
+  "origin": "init",
+  "skip": ["src/**", "tests/**"]
+}
 ```
 
-Your custom files (controllers, pages, middleware) are never deleted. Files you created that don't exist in the template are always preserved.
+To skip root-level files (docker-compose, README), add `skip` to `.projx`:
+
+```json
+{
+  "version": "1.3.6",
+  "components": ["fastapi", "frontend"],
+  "skip": ["docker-compose.yml", "README.md"]
+}
+```
+
+Skipped files are excluded from template updates.
 
 ## Options
 

package/dist/index.js

@@ -130,11 +130,6 @@ async function copyStaticFiles(repoDir, dest) {
       manifest.push(file);
     }
   }
-  const gitignore = join(tpl, ".gitignore");
-  if (existsSync(gitignore)) {
-    await cp(gitignore, join(dest, ".gitignore"));
-    manifest.push(".gitignore");
-  }
   const extensionsJson = join(tpl, ".vscode/extensions.json");
   if (existsSync(extensionsJson)) {
     await mkdir(join(dest, ".vscode"), { recursive: true });
@@ -282,8 +277,8 @@ function render(template, vars) {
       (_, expr) => {
         const parts = expr.split(".");
         let val = vars;
-        for (const p7 of parts) {
-          val = val?.[p7];
+        for (const p6 of parts) {
+          val = val?.[p6];
         }
         return String(val ?? "");
       }
@@ -335,17 +330,16 @@ async function runPrompts(nameArg) {
 
 // src/scaffold.ts
 import { copyFileSync, existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir3, readFile as readFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile4 } from "fs/promises";
 import { join as join4 } from "path";
-import * as p3 from "@clack/prompts";
+import * as p2 from "@clack/prompts";
 
 // src/baseline.ts
-import { existsSync as existsSync2 } from "fs";
-import { chmod, mkdir as mkdir2, writeFile as writeFile2, rm as rm2 } from "fs/promises";
+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";
-import * as p2 from "@clack/prompts";
 
 // src/generators/index.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -407,47 +401,7 @@ function generateVscodeSettings(vars) {
 }
 
 // src/baseline.ts
-var BASELINE_BRANCH = "projx/baseline";
-function hasBaseline(cwd) {
-  try {
-    execSync2(`git show-ref --verify --quiet refs/heads/${BASELINE_BRANCH}`, {
-      cwd,
-      stdio: "pipe"
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function createWorktree(cwd, branch, orphan) {
-  const worktree = join3(tmpdir2(), `projx-baseline-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  if (orphan) {
-    execSync2(`git worktree add --orphan -b ${branch} "${worktree}"`, {
-      cwd,
-      stdio: "pipe"
-    });
-  } else {
-    execSync2(`git worktree add "${worktree}" ${branch}`, {
-      cwd,
-      stdio: "pipe"
-    });
-  }
-  return worktree;
-}
-function removeWorktree(cwd, worktree) {
-  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 {
-    }
-  }
-}
+var BASELINE_REF = "refs/projx/baseline";
 function matchesSkip(filePath, patterns) {
   for (const pattern of patterns) {
     if (pattern === "**") return true;
@@ -472,9 +426,130 @@ function matchesSkip(filePath, patterns) {
   }
   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 "${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: readdir3 } = await import("fs/promises");
+  const results = [];
+  const walk = async (current) => {
+    const entries = await readdir3(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) {
+    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 (oursContent === baseContent) continue;
+    if (theirsContent === baseContent) 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: readdir3, unlink } = await import("fs/promises");
+  const { readdir: readdir3, unlink: unlink2 } = await import("fs/promises");
   const walk = async (current, base) => {
     const entries = await readdir3(current, { withFileTypes: true });
     for (const entry of entries) {
@@ -483,60 +558,67 @@ async function removeSkippedFiles(dir, skipPatterns) {
       if (entry.isDirectory()) {
         await walk(full, base);
       } else if (entry.name !== ".projx-component" && matchesSkip(rel, skipPatterns)) {
-        await unlink(full);
+        await unlink2(full);
       }
     }
   };
   await walk(dir, dir);
 }
-async function writeTemplateToDir(dest, repoDir, components, componentPaths, vars, version, origin, componentSkips) {
+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];
-    if (targetDir === component) {
-      await copyComponent(repoDir, component, dest);
-    } else {
-      await copyComponent(repoDir, component, join3(dest, "__tmp__"));
-      const { cp: cp2 } = await import("fs/promises");
-      const srcDir = join3(dest, "__tmp__", component);
-      const outDir = join3(dest, targetDir);
-      if (existsSync2(srcDir)) {
-        await cp2(srcDir, outDir, { recursive: true, force: true });
-      }
-      await rm2(join3(dest, "__tmp__"), { recursive: true, force: true });
-    }
     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(join3(dest, targetDir), skipPatterns);
+      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")) {
-    await writeFile2(join3(dest, "docker-compose.yml"), await generateDockerCompose(vars));
-    await writeFile2(join3(dest, "docker-compose.dev.yml"), await generateDockerComposeDev(vars));
-  }
-  await writeFile2(join3(dest, "README.md"), await generateReadme(vars));
-  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);
-  await mkdir2(join3(dest, ".github/workflows"), { recursive: true });
-  await writeFile2(join3(dest, ".github/workflows/ci.yml"), await generateCiYml(vars));
-  await writeFile2(join3(dest, "setup.sh"), await generateSetupSh(vars));
-  await chmod(join3(dest, "setup.sh"), 493);
+    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);
-  await mkdir2(join3(dest, ".vscode"), { recursive: true });
-  await writeFile2(join3(dest, ".vscode/settings.json"), generateVscodeSettings(vars));
+  if (shouldWrite(".vscode/settings.json")) {
+    await mkdir2(join3(dest, ".vscode"), { recursive: true });
+    await writeFile2(join3(dest, ".vscode/settings.json"), generateVscodeSettings(vars));
+  }
   const projxConfig = {
     version,
     components,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-    baseline: {
-      branch: BASELINE_BRANCH,
-      templateVersion: version
-    }
+    createdAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
   };
   await writeFile2(join3(dest, ".projx"), JSON.stringify(projxConfig, null, 2) + "\n");
 }
@@ -558,90 +640,113 @@ async function substituteNames(dest, components, paths, name, nameSnake) {
     await replaceInDir(join3(dest, `${paths.mobile}`), "package:projx_mobile/", `package:${nameSnake}_mobile/`, ".dart");
   }
 }
-async function createBaseline(cwd, repoDir, components, componentPaths, vars, version, origin = "scaffold", componentSkips) {
-  const worktree = createWorktree(cwd, BASELINE_BRANCH, true);
-  try {
-    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, origin, componentSkips);
-    execSync2("git add -A", { cwd: worktree, stdio: "pipe" });
-    execSync2(
-      `git commit --no-verify -m "projx: baseline template v${version} [${components.join(", ")}]"`,
-      { cwd: worktree, stdio: "pipe" }
-    );
-  } finally {
-    removeWorktree(cwd, worktree);
+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" };
   }
-}
-async function updateBaseline(cwd, repoDir, components, componentPaths, vars, version, componentSkips) {
-  const worktree = createWorktree(cwd, BASELINE_BRANCH, false);
+  const { worktree, branch } = createOrphanWorktree(cwd);
   try {
-    execSync2("git rm -rf .", { cwd: worktree, stdio: "pipe" });
-    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, "scaffold", componentSkips);
+    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip);
     execSync2("git add -A", { cwd: worktree, stdio: "pipe" });
     const diff = execSync2("git diff --cached --stat", { cwd: worktree, stdio: "pipe" }).toString().trim();
     if (!diff) {
-      return { changed: false };
+      cleanupWorktree(cwd, worktree, branch);
+      return { status: "clean" };
     }
     execSync2(
-      `git commit --no-verify -m "projx: update baseline to template v${version}"`,
+      `git commit --no-verify -m "projx: template v${version} [${components.join(", ")}]"`,
       { cwd: worktree, stdio: "pipe" }
     );
-    return { changed: true };
-  } finally {
-    removeWorktree(cwd, worktree);
-  }
-}
-async function addToBaseline(cwd, repoDir, newComponents, allComponents, componentPaths, vars, version) {
-  const worktree = createWorktree(cwd, BASELINE_BRANCH, false);
-  try {
-    await writeTemplateToDir(worktree, repoDir, allComponents, componentPaths, vars, version, "scaffold");
-    execSync2("git add -A", { cwd: worktree, stdio: "pipe" });
-    execSync2(
-      `git commit --no-verify -m "projx: add ${newComponents.join(", ")} template v${version}"`,
-      { cwd: worktree, stdio: "pipe" }
-    );
-  } finally {
-    removeWorktree(cwd, worktree);
-  }
-}
-function mergeBaseline(cwd, message, allowUnrelated = false, oursOnConflict = false) {
-  const args2 = [`git merge ${BASELINE_BRANCH}`];
-  args2.push(`-m "${message}"`);
-  if (allowUnrelated) args2.push("--allow-unrelated-histories");
-  if (oursOnConflict) {
     try {
-      execSync2(`${args2.join(" ")} --no-commit`, { cwd, stdio: "pipe" });
+      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 {
+      }
     }
-    execSync2("git checkout --ours .", { cwd, stdio: "pipe" });
-    execSync2("git add -A", { cwd, stdio: "pipe" });
-    execSync2(`git commit --no-verify --no-edit -m "${message}"`, { cwd, stdio: "pipe" });
-    return { status: "clean" };
-  }
-  try {
-    execSync2(args2.join(" "), { cwd, stdio: "pipe" });
-    return { status: "clean" };
-  } catch {
-    const conflicted = execSync2("git diff --name-only --diff-filter=U", { cwd, stdio: "pipe" }).toString().trim();
-    if (!conflicted) {
+    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" };
     }
-    return {
-      status: "conflicts",
-      conflictedFiles: conflicted.split("\n").filter(Boolean)
-    };
+    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 });
+      const projxConfig = {
+        version,
+        components,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+      };
+      await writeFile2(join3(cwd, ".projx"), JSON.stringify(projxConfig, null, 2) + "\n");
+      if (result.conflicted.length === 0) {
+        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" };
+      }
+      for (const f of result.conflicted) {
+        try {
+          execSync2(`git checkout -- "${f}"`, { cwd, stdio: "pipe" });
+        } catch {
+        }
+      }
+      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;
   }
 }
-async function reconstructBaseline(cwd, repoDir, components, componentPaths, vars, version, componentSkips) {
-  p2.log.warn("projx/baseline branch not found. Reconstructing...");
-  await createBaseline(cwd, repoDir, components, componentPaths, vars, version, "scaffold", componentSkips);
-  mergeBaseline(
-    cwd,
-    `projx: reconstructed baseline for template v${version}`,
-    true,
-    true
-  );
-  p2.log.success("Baseline reconstructed.");
-}
 
 // src/scaffold.ts
 async function scaffold(opts, dest, localRepo) {
@@ -652,39 +757,26 @@ async function scaffold(opts, dest, localRepo) {
   const vars = { projectName: name, components: opts.components, paths };
   const isLocal = !!localRepo;
   await mkdir3(dest, { recursive: true });
-  const dlSpinner = p3.spinner();
+  const dlSpinner = p2.spinner();
   dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
   const repoDir = await downloadRepo(localRepo).catch((err) => {
     dlSpinner.stop("Failed.");
-    p3.log.error(String(err));
+    p2.log.error(String(err));
     process.exit(1);
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    const pkg = JSON.parse(await readFile3(join4(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile4(join4(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
-    p3.log.info(`Scaffolding project in ${dest}`);
+    p2.log.info(`Scaffolding project in ${dest}`);
     if (opts.git) {
       exec("git init", dest);
       exec("git config core.hooksPath .githooks", dest);
-      const spinner5 = p3.spinner();
-      spinner5.start("Creating baseline and scaffold");
-      await createBaseline(dest, repoDir, opts.components, paths, vars, version);
-      const result = mergeBaseline(
-        dest,
-        `projx: initial scaffold from template v${version}`,
-        true
-      );
-      spinner5.stop("Scaffold complete.");
-      if (result.status === "conflicts") {
-        p3.log.warn("Unexpected conflicts during scaffold \u2014 this shouldn't happen.");
-      }
-    } else {
-      const spinner5 = p3.spinner();
-      spinner5.start("Copying template files");
-      await createBaseline(dest, repoDir, opts.components, paths, vars, version);
-      spinner5.stop("Template files copied.");
     }
+    const spinner5 = p2.spinner();
+    spinner5.start("Scaffolding project");
+    await applyTemplate(dest, repoDir, opts.components, paths, vars, version);
+    spinner5.stop("Scaffold complete.");
     if (opts.install) {
       await installDeps(dest, opts.components);
     }
@@ -693,13 +785,14 @@ async function scaffold(opts, dest, localRepo) {
       try {
         exec("git add -A", dest);
         exec('git commit --no-verify -m "Initial scaffold from projx"', dest);
+        saveBaselineRef(dest);
       } catch {
       }
     }
   } finally {
     await cleanupRepo(repoDir, isLocal);
   }
-  p3.outro(`Done! Next steps:
+  p2.outro(`Done! Next steps:
 
   cd ${name}
   ./setup.sh
@@ -708,7 +801,7 @@ async function scaffold(opts, dest, localRepo) {
 }
 async function installDeps(dest, components) {
   for (const component of components) {
-    const spinner5 = p3.spinner();
+    const spinner5 = p2.spinner();
     try {
       switch (component) {
         case "fastapi":
@@ -717,7 +810,7 @@ async function installDeps(dest, components) {
             exec("uv sync --all-extras", join4(dest, "fastapi"));
             spinner5.stop("FastAPI dependencies installed.");
           } else {
-            p3.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
+            p2.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
           }
           break;
         case "fastify":
@@ -747,7 +840,7 @@ async function installDeps(dest, components) {
             exec("flutter pub get", join4(dest, "mobile"));
             spinner5.stop("Flutter dependencies installed.");
           } else {
-            p3.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
+            p2.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
           }
           break;
         case "infra":
@@ -773,127 +866,101 @@ function copyEnvExamples(dest, components) {
 
 // src/update.ts
 import { existsSync as existsSync4, readFileSync } from "fs";
-import { readFile as readFile4 } from "fs/promises";
+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 * as p4 from "@clack/prompts";
+import * as p3 from "@clack/prompts";
 async function update(cwd, localRepo) {
-  p4.intro("projx update");
+  p3.intro("projx update");
   const isLocal = !!localRepo;
   if (!isGitRepo(cwd)) {
-    p4.log.error(`projx update requires a git repo. Run 'git init && git add -A && git commit -m "initial"' first.`);
+    p3.log.error("projx update requires a git repo.");
     process.exit(1);
   }
+  try {
+    execSync3("git worktree prune", { cwd, stdio: "pipe" });
+  } catch {
+  }
   if (hasUncommittedChanges(cwd)) {
-    p4.log.error("You have uncommitted changes. Commit or stash them first.");
+    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)) {
-    config = JSON.parse(await readFile4(configPath, "utf-8"));
-    p4.log.info(`Found .projx (v${config.version}, components: ${config.components.join(", ")})`);
+    config = JSON.parse(await readFile5(configPath, "utf-8"));
+    p3.log.info(`Found .projx (v${config.version}, components: ${config.components.join(", ")})`);
   } else {
-    p4.log.warn("No .projx file found. Detecting components from directories.");
+    p3.log.warn("No .projx file found. Detecting components from directories.");
     const detected = COMPONENTS.filter((c) => existsSync4(join5(cwd, c)));
     if (detected.length === 0) {
-      p4.log.error("No projx components found. Run 'projx init' first.");
+      p3.log.error("No projx components found. Run 'projx init' first.");
       process.exit(1);
     }
-    config = {
-      version: "0.0.0",
-      components: detected,
-      createdAt: "unknown"
-    };
-    p4.log.info(`Detected: ${detected.join(", ")}`);
+    config = { version: "0.0.0", components: detected, createdAt: "unknown" };
+    p3.log.info(`Detected: ${detected.join(", ")}`);
   }
   const componentPaths = await discoverComponentPaths(cwd, config.components);
-  const remapped = config.components.filter((c) => componentPaths[c] !== c);
-  if (remapped.length > 0) {
-    for (const c of remapped) {
-      p4.log.info(`${c} \u2192 ${componentPaths[c]}/`);
+  for (const c of config.components) {
+    const dir = componentPaths[c];
+    p3.log.info(dir !== c ? `${c} \u2192 ${dir}/` : `${c}/`);
+  }
+  const componentSkips = {};
+  for (const component of config.components) {
+    const dir = componentPaths[component];
+    const marker = await readComponentMarker(join5(cwd, dir));
+    if (marker?.skip && marker.skip.length > 0) {
+      componentSkips[component] = marker.skip;
     }
   }
-  const dlSpinner = p4.spinner();
+  const dlSpinner = p3.spinner();
   dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
   const repoDir = await downloadRepo(localRepo).catch((err) => {
     dlSpinner.stop("Failed.");
-    p4.log.error(String(err));
+    p3.log.error(String(err));
     process.exit(1);
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    const pkg = JSON.parse(await readFile4(join5(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile5(join5(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
     const name = detectProjectName(cwd, config.components, componentPaths);
     const vars = { projectName: name, components: config.components, paths: componentPaths };
-    const componentSkips = {};
-    for (const component of config.components) {
-      const dir = componentPaths[component];
-      const marker = await readComponentMarker(join5(cwd, dir));
-      if (marker?.skip && marker.skip.length > 0) {
-        componentSkips[component] = marker.skip;
-      } else if (marker?.origin === "init" || !marker?.origin) {
-        componentSkips[component] = ["**"];
+    const spinner5 = p3.spinner();
+    spinner5.start("Applying template update");
+    const rootSkip = config.skip ?? [];
+    const result = await applyTemplate(cwd, repoDir, config.components, componentPaths, vars, version, "scaffold", componentSkips, rootSkip);
+    spinner5.stop("Template applied.");
+    if (result.status === "merged") {
+      saveBaselineRef(cwd);
+      p3.log.success(`${result.mergedFiles?.length ?? 0} file(s) merged cleanly.`);
+      p3.outro(`Updated to template v${version}.`);
+    } else if (result.status === "conflicts") {
+      if (result.mergedFiles && result.mergedFiles.length > 0) {
+        p3.log.success(`${result.mergedFiles.length} file(s) merged cleanly and staged.`);
       }
-    }
-    if (!hasBaseline(cwd)) {
-      const rebuildSpinner = p4.spinner();
-      rebuildSpinner.start("Establishing baseline (first-time migration)");
-      await reconstructBaseline(cwd, repoDir, config.components, componentPaths, vars, config.version || version, componentSkips);
-      rebuildSpinner.stop("Baseline established.");
-    }
-    const updateSpinner = p4.spinner();
-    updateSpinner.start("Updating baseline to latest template");
-    const { changed } = await updateBaseline(cwd, repoDir, config.components, componentPaths, vars, version, componentSkips);
-    if (!changed) {
-      updateSpinner.stop("Already up to date.");
-      p4.outro("No template changes to apply.");
-      return;
-    }
-    updateSpinner.stop("Baseline updated.");
-    const mergeSpinner = p4.spinner();
-    mergeSpinner.start("Merging template changes");
-    const result = mergeBaseline(cwd, `projx: update to template v${version}`);
-    mergeSpinner.stop("Merge complete.");
-    if (result.status === "clean") {
-      const { writeFile: writeFile3 } = await import("fs/promises");
-      const updatedConfig = {
-        ...config,
-        version,
-        baseline: { branch: "projx/baseline", templateVersion: version }
-      };
-      await writeFile3(join5(cwd, ".projx"), JSON.stringify(updatedConfig, null, 2) + "\n");
-      for (const component of config.components) {
-        const dir = componentPaths[component];
-        const skip = componentSkips[component];
-        await writeComponentMarker(
-          join5(cwd, dir),
-          component,
-          skip?.includes("**") ? "init" : "scaffold",
-          skip
-        );
+      const conflictCount = result.conflictedFiles?.length ?? 0;
+      if (conflictCount > 0) {
+        p3.log.warn(`${conflictCount} file(s) need review:`);
+        for (const f of result.conflictedFiles) {
+          p3.log.info(`  ${f}`);
+        }
       }
-      execSync3('git add -A && git commit --no-verify -m "projx: post-update config"', { cwd, stdio: "pipe" });
-    }
-    if (result.status === "conflicts") {
-      p4.log.warn(`Merge conflicts in ${result.conflictedFiles.length} file(s):`);
-      for (const f of result.conflictedFiles) {
-        p4.log.message(`  ${f}`);
+      const handled = await promptSkipLearning(cwd, componentPaths, version);
+      if (!handled) {
+        p3.log.info("");
+        p3.log.info("Review:  git diff");
+        p3.log.info("Keep:    git add <file>");
+        p3.log.info("Discard: git checkout -- <file>");
+        p3.log.info(`Commit:  git add . && git commit -m "projx: update to v${version}"`);
+        p3.outro(`Template v${version} applied. Review with git diff.`);
       }
-      p4.outro(
-        "Resolve conflicts, then:\n  git add . && git commit\n\nOr abort:\n  git merge --abort"
-      );
     } else {
-      p4.outro(`Updated to template v${version}. All changes merged cleanly.`);
+      saveBaselineRef(cwd);
+      p3.outro(`Updated to template v${version}.`);
     }
   } catch (err) {
-    try {
-      execSync3("git merge --abort", { cwd, stdio: "pipe" });
-    } catch {
-    }
-    p4.log.error(`Update failed: ${err}`);
-    p4.log.info("Your code is safe. Run 'git merge --abort' if needed.");
+    p3.log.error(`Update failed: ${err}`);
     process.exit(1);
   } finally {
     await cleanupRepo(repoDir, isLocal);
@@ -915,6 +982,101 @@ function hasUncommittedChanges(cwd) {
     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) => {
+    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.`);
+  const selected = await p3.multiselect({
+    message: "Select files to KEEP (unselected will be discarded and skipped on future updates)",
+    options: changedFiles.map((f) => ({ value: f, label: f })),
+    required: false
+  });
+  if (p3.isCancel(selected)) return false;
+  const kept = new Set(selected);
+  const discarded = changedFiles.filter((f) => !kept.has(f));
+  if (discarded.length > 0) {
+    for (const file of discarded) {
+      const entry = entries.find((e) => e.file === file);
+      try {
+        if (entry?.status === "??") {
+          await unlink(join5(cwd, file));
+        } else {
+          execSync3(`git checkout -- "${file}"`, { cwd, stdio: "pipe" });
+        }
+      } catch {
+      }
+    }
+    await learnSkips(cwd, discarded, componentPaths);
+    p3.log.success(
+      `Discarded ${discarded.length} file(s) and added to skip list.`
+    );
+  }
+  if (kept.size > 0) {
+    p3.log.info(`${kept.size} file(s) kept \u2014 commit when ready:`);
+    p3.log.info(
+      `  git add . && git commit -m "projx: update to v${version}"`
+    );
+    p3.outro(`Template v${version} applied.`);
+  } else {
+    p3.outro("All template changes discarded. Skip list updated.");
+  }
+  return true;
+}
+async function learnSkips(cwd, files, componentPaths) {
+  const componentSkipAdds = {};
+  const rootSkipAdds = [];
+  const dirToComponent = {};
+  for (const [component, dir] of Object.entries(componentPaths)) {
+    dirToComponent[dir] = component;
+  }
+  for (const file of files) {
+    let matched = false;
+    for (const [dir, component] of Object.entries(dirToComponent)) {
+      if (file.startsWith(dir + "/")) {
+        const relative = file.slice(dir.length + 1);
+        if (!componentSkipAdds[component]) componentSkipAdds[component] = [];
+        componentSkipAdds[component].push(relative);
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      rootSkipAdds.push(file);
+    }
+  }
+  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 {
+    }
+  }
+  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 {
+    }
+  }
+}
 function detectProjectName(cwd, components, componentPaths) {
   for (const component of components) {
     const dir = componentPaths[component] ?? component;
@@ -935,34 +1097,34 @@ function detectProjectName(cwd, components, componentPaths) {
 
 // src/add.ts
 import { copyFileSync as copyFileSync2, existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { join as join6 } from "path";
-import * as p5 from "@clack/prompts";
+import * as p4 from "@clack/prompts";
 async function add(cwd, newComponents, localRepo, skipInstall = false) {
-  p5.intro("projx add");
+  p4.intro("projx add");
   const isLocal = !!localRepo;
   const configPath = join6(cwd, ".projx");
   if (!existsSync5(configPath)) {
-    p5.log.error("No .projx file found. Run 'projx <name>' to create a project first.");
+    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 readFile5(configPath, "utf-8"));
+  const config = JSON.parse(await readFile6(configPath, "utf-8"));
   const existing = config.components;
   const alreadyExists = newComponents.filter((c) => existing.includes(c));
   if (alreadyExists.length > 0) {
-    p5.log.warn(`Already present: ${alreadyExists.join(", ")}. Skipping those.`);
+    p4.log.warn(`Already present: ${alreadyExists.join(", ")}. Skipping those.`);
   }
   const toAdd = newComponents.filter((c) => !existing.includes(c));
   if (toAdd.length === 0) {
-    p5.log.info("Nothing new to add.");
+    p4.log.info("Nothing new to add.");
     process.exit(0);
   }
-  p5.log.info(`Adding: ${toAdd.join(", ")}`);
-  const dlSpinner = p5.spinner();
+  p4.log.info(`Adding: ${toAdd.join(", ")}`);
+  const dlSpinner = p4.spinner();
   dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
   const repoDir = await downloadRepo(localRepo).catch((err) => {
     dlSpinner.stop("Failed.");
-    p5.log.error(String(err));
+    p4.log.error(String(err));
     process.exit(1);
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
@@ -973,33 +1135,12 @@ async function add(cwd, newComponents, localRepo, skipInstall = false) {
     for (const c of toAdd) paths[c] = c;
     const name = detectProjectName2(cwd, existing, paths);
     const vars = { projectName: name, components: allComponents, paths };
-    const pkg = JSON.parse(await readFile5(join6(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile6(join6(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
-    if (!hasBaseline(cwd)) {
-      const rebuildSpinner = p5.spinner();
-      rebuildSpinner.start("Establishing baseline");
-      await reconstructBaseline(
-        cwd,
-        repoDir,
-        existing,
-        existingPaths,
-        { projectName: name, components: existing, paths: existingPaths },
-        config.version || version
-      );
-      rebuildSpinner.stop("Baseline established.");
-    }
-    const spinner5 = p5.spinner();
-    spinner5.start("Adding to baseline");
-    await addToBaseline(cwd, repoDir, toAdd, allComponents, paths, vars, version);
-    spinner5.stop("Baseline updated.");
-    const result = mergeBaseline(cwd, `projx: add ${toAdd.join(", ")} from template v${version}`);
-    if (result.status === "conflicts") {
-      p5.log.warn(`Merge conflicts in ${result.conflictedFiles.length} file(s):`);
-      for (const f of result.conflictedFiles) {
-        p5.log.message(`  ${f}`);
-      }
-      p5.log.info("Resolve conflicts, then: git add . && git commit");
-    }
+    const spinner5 = p4.spinner();
+    spinner5.start("Adding components");
+    await writeTemplateToDir(cwd, repoDir, allComponents, paths, vars, version, "scaffold");
+    spinner5.stop("Components added.");
     if (!skipInstall) {
       await installDeps2(cwd, toAdd);
     }
@@ -1013,16 +1154,16 @@ async function add(cwd, newComponents, localRepo, skipInstall = false) {
         }
       }
     }
+    p4.outro(`Added ${toAdd.join(", ")}.
+
+  Like projx? Star it: https://github.com/ukanhaupa/projx`);
   } finally {
     await cleanupRepo(repoDir, isLocal);
   }
-  p5.outro(`Added ${toAdd.join(", ")}.
-
-  Like projx? Star it: https://github.com/ukanhaupa/projx`);
 }
 async function installDeps2(dest, components) {
   for (const component of components) {
-    const spinner5 = p5.spinner();
+    const spinner5 = p4.spinner();
     try {
       switch (component) {
         case "fastapi":
@@ -1031,7 +1172,7 @@ async function installDeps2(dest, components) {
             exec("uv sync --all-extras", join6(dest, "fastapi"));
             spinner5.stop("FastAPI dependencies installed.");
           } else {
-            p5.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
+            p4.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
           }
           break;
         case "fastify":
@@ -1061,7 +1202,7 @@ async function installDeps2(dest, components) {
             exec("flutter pub get", join6(dest, "mobile"));
             spinner5.stop("Flutter dependencies installed.");
           } else {
-            p5.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
+            p4.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
           }
           break;
         case "infra":
@@ -1092,10 +1233,10 @@ function detectProjectName2(cwd, components, paths) {
 
 // src/init.ts
 import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 import { execSync as execSync4 } from "child_process";
 import { join as join8 } from "path";
-import * as p6 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 
 // src/detect.ts
 import { existsSync as existsSync6 } from "fs";
@@ -1183,21 +1324,21 @@ async function readPkg(dir) {
 
 // src/init.ts
 async function init(cwd, localRepo) {
-  p6.intro("projx init");
+  p5.intro("projx init");
   const isLocal = !!localRepo;
   if (existsSync7(join8(cwd, ".projx"))) {
-    p6.log.error("This project is already initialized. Use 'projx update' or 'projx add' instead.");
+    p5.log.error("This project is already initialized. Use 'npx create-projx update' or 'npx create-projx add' instead.");
     process.exit(1);
   }
   if (!isGitRepo2(cwd)) {
-    p6.log.error(`projx init requires a git repo. Run 'git init && git add -A && git commit -m "initial"' first.`);
+    p5.log.error(`projx init requires a git repo. Run 'git init && git add -A && git commit -m "initial"' first.`);
     process.exit(1);
   }
   if (hasUncommittedChanges2(cwd)) {
-    p6.log.error("You have uncommitted changes. Commit or stash them first.");
+    p5.log.error("You have uncommitted changes. Commit or stash them first.");
     process.exit(1);
   }
-  const spinner5 = p6.spinner();
+  const spinner5 = p5.spinner();
   spinner5.start("Scanning for components");
   const detected = await detectComponents(cwd);
   spinner5.stop(
@@ -1210,7 +1351,7 @@ async function init(cwd, localRepo) {
     confirmed = await manualSelect(cwd);
   }
   if (confirmed.length === 0) {
-    p6.log.warn("No components selected. Nothing to do.");
+    p5.log.warn("No components selected. Nothing to do.");
     process.exit(0);
   }
   const components = confirmed.map((c) => c.component);
@@ -1219,55 +1360,57 @@ async function init(cwd, localRepo) {
   );
   const projectName = toKebab(cwd.split("/").pop());
   const vars = { projectName, components, paths };
-  const dlSpinner = p6.spinner();
+  const dlSpinner = p5.spinner();
   dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
   const repoDir = await downloadRepo(localRepo).catch((err) => {
     dlSpinner.stop("Failed.");
-    p6.log.error(String(err));
+    p5.log.error(String(err));
     process.exit(1);
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    const pkg = JSON.parse(await readFile6(join8(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile7(join8(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
-    const componentSkips = {};
-    for (const c of components) {
-      componentSkips[c] = ["**"];
-    }
-    const baselineSpinner = p6.spinner();
-    baselineSpinner.start("Creating template baseline");
-    await createBaseline(cwd, repoDir, components, paths, vars, version, "init", componentSkips);
-    baselineSpinner.stop("Baseline created.");
-    const mergeSpinner = p6.spinner();
-    mergeSpinner.start("Merging baseline (preserving your code)");
-    mergeBaseline(
-      cwd,
-      `projx: adopt template v${version} as baseline`,
-      true,
-      true
-    );
-    mergeSpinner.stop("Baseline merged. Your code is preserved.");
-    if (!existsSync7(join8(cwd, ".githooks"))) {
+    const applySpinner = p5.spinner();
+    applySpinner.start("Applying template");
+    const result = await applyTemplate(cwd, repoDir, components, paths, vars, version, "init");
+    applySpinner.stop("Template applied.");
+    if (existsSync7(join8(cwd, ".githooks"))) {
       try {
         execSync4("git config core.hooksPath .githooks", { cwd, stdio: "pipe" });
-        p6.log.success("Git hooks configured.");
       } catch {
-        p6.log.warn("Failed to configure git hooks.");
       }
     }
+    if (result.status === "clean" || result.status === "merged") {
+      saveBaselineRef(cwd);
+    }
+    if (result.status === "conflicts") {
+      p5.log.warn("Some template files differ from your code. Changes written directly.");
+      p5.log.info("Review changes:");
+      p5.log.info("  git diff");
+      p5.log.info("");
+      p5.log.info("Keep a change:  git add <file>");
+      p5.log.info("Discard a change:  git checkout -- <file>");
+      p5.log.info('Commit when ready:  git add . && git commit -m "projx: init"');
+      p5.log.info("");
+      p5.log.info("To skip files on future updates, add to .projx-component:");
+      p5.log.info('  { "skip": ["src/**", "tests/**"] }');
+      p5.outro("Template applied. Review with git diff.\n\n  Like projx? Star it: https://github.com/ukanhaupa/projx");
+    } else {
+      p5.outro("Project initialized.\n\n  Like projx? Star it: https://github.com/ukanhaupa/projx");
+    }
   } finally {
     await cleanupRepo(repoDir, isLocal);
   }
-  p6.outro("Project initialized. Run './setup.sh' to install dependencies.\n\n  Like projx? Star it: https://github.com/ukanhaupa/projx");
 }
 async function confirmDetections(detected) {
   const confirmed = [];
   for (const d of detected) {
-    const yes = await p6.confirm({
+    const yes = await p5.confirm({
       message: `Found ${LABELS[d.component].label} in ${d.directory}/ \u2014 register as "${d.component}"?`,
       initialValue: true
     });
-    if (p6.isCancel(yes)) process.exit(0);
+    if (p5.isCancel(yes)) process.exit(0);
     if (yes) {
       confirmed.push({ component: d.component, directory: d.directory });
     }
@@ -1275,7 +1418,7 @@ async function confirmDetections(detected) {
   return confirmed;
 }
 async function manualSelect(cwd) {
-  const selected = await p6.multiselect({
+  const selected = await p5.multiselect({
     message: "No components detected. Select manually:",
     options: COMPONENTS.map((c) => ({
       value: c,
@@ -1284,17 +1427,17 @@ async function manualSelect(cwd) {
     })),
     required: false
   });
-  if (p6.isCancel(selected)) process.exit(0);
+  if (p5.isCancel(selected)) process.exit(0);
   const result = [];
   for (const component of selected) {
-    const dir = await p6.text({
+    const dir = await p5.text({
       message: `Directory for ${LABELS[component].label}?`,
       placeholder: component,
       defaultValue: component
     });
-    if (p6.isCancel(dir)) process.exit(0);
+    if (p5.isCancel(dir)) process.exit(0);
     if (!existsSync7(join8(cwd, dir))) {
-      p6.log.warn(`${dir}/ does not exist \u2014 skipping.`);
+      p5.log.warn(`${dir}/ does not exist \u2014 skipping.`);
       continue;
     }
     result.push({ component, directory: dir });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-projx",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "description": "Scaffold production-grade fullstack projects in seconds. FastAPI, Fastify, React, Flutter, Terraform — with auth, database, CI/CD, E2E tests, and Docker. One command, ready to deploy.",
   "type": "module",
   "bin": {