project-auto-wizard 0.1.34 → 0.2.0

package/README.md

@@ -17,7 +17,7 @@ npx project-auto-wizard
 [![node](https://img.shields.io/badge/node-%3E%3D20.12-brightgreen)](package.json)
 
 <!-- AUTO-VERSION-SECTION: DO NOT EDIT MANUALLY -->
-## 최신 버전 : v0.1.33 (2026-08-10)
+## 최신 버전 : v0.1.34 (2026-08-10)
 
 [전체 버전 기록 보기](CHANGELOG.md)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-auto-wizard",
-  "version": "0.1.34",
+  "version": "0.2.0",
   "description": "One command DevOps: npx wizard that installs GitHub-native AI Release Automation into any project",
   "license": "MIT",
   "type": "module",

package/src/commands/full.js

@@ -10,9 +10,10 @@ import { buildVersionYml, parseExisting } from "../core/version-yml.js";
 import { readVersionYmlTemplate } from "../core/assets.js";
 import { markerForType } from "../core/detect.js";
 import { addVersionSectionToReadme } from "../core/copy/readme.js";
-import { copyWorkflows } from "../core/copy/workflows.js";
+import { copyWorkflows, computeBaselineEntries, makeSrcText } from "../core/copy/workflows.js";
 import { copyScripts } from "../core/copy/simple.js";
 import { ensureGitignore } from "../core/copy/gitignore.js";
+import { readBaseline, writeBaseline } from "../core/baseline.js";
 
 // context: { version, types, paths:Map, branch, versionCode, includeNexus, includeSecretBackup,
 //            force, repoName, resolvers, now, today }
@@ -56,5 +57,19 @@ export function runFull(context, payloadRoot, targetRoot = ".", hooks = {}) {
   const gitignoreUpdated = wfCounters.backupAdded > 0 || wfCounters.templateAdded > 0;
   if (gitignoreUpdated) ensureGitignore(targetRoot);
 
+  // 6. baseline 기록 (issue #69) — 다음 업데이트에서 "누가 바꿨는지"를 가를 기준점.
+  //    env 치환까지 전부 끝난 뒤에 해시해야 디스크 내용이 최종형이다. 그래서 copyWorkflows 안이
+  //    아니라 여기서 기록한다.
+  //    기존 baseline은 병합 대상 — 이번에 건드리지 않은 파일의 기준점을 잃지 않는다.
+  writeBaseline(targetRoot, {
+    templateVersion,
+    installedAt: now || today || "",
+    entries: computeBaselineEntries(
+      wfCounters.baselineTargets || new Map(),
+      join(targetRoot, PATHS.workflowsDir),
+      makeSrcText(context.branches || null)),
+    previous: readBaseline(targetRoot),
+  });
+
   return { workflows: wfCounters, gitignoreUpdated };
 }

package/src/commands/interactive.js

@@ -12,7 +12,7 @@ import { resolveProjectPaths } from "../core/paths-resolve.js";
 import { resolveBranchConfig, detectRemoteBranches, ensureDevelopBranch } from "../core/branches.js";
 import { askAllOptionalWorkflows } from "../core/options-ask.js";
 import { promptEnvPlan } from "../ui/env-plan.js";
-import { listWorkflowConflicts } from "../core/copy/workflows.js";
+import { surveyWorkflows } from "../core/copy/workflows.js";
 import { createContext, VALID_TYPES } from "../context.js";
 import { runFull } from "./full.js";
 import { runUninstallFlow } from "./uninstall.js";
@@ -206,17 +206,37 @@ export async function runInteractive(baseCtx, { cwd = process.cwd(), payloadRoot
   });
   ctx.templateVersion = templateVersion;
 
-  // 기존 워크플로우 충돌 3지선 — 타입당 1회 결정을 파일에 캐시 적용 (.sh L3440~3508 UX 등가)
+  // 사용자가 답해야 하는 것만 묻는다 (issue #69). baseline 3-way가 자동으로 안전한 경우를
+  // 걸러내므로, 여기 오는 것은 (a) 양쪽이 다 바뀐 진짜 충돌과 (b) 사용자가 지운 파일뿐이다.
   let hooks = {};
   if (showOptional && io.engineIo?.select) {
-    const conflicts = listWorkflowConflicts(ctx, payload, cwd);
+    const { conflicts, removed } = surveyWorkflows(ctx, payload, cwd);
+
+    // (b) 지운 파일 — 조용히 되살리지 않는다. 되살리는 쪽이 기본이 아니라는 점이 핵심이다.
+    const restoreRemoved = new Set();
+    if (removed.length) {
+      io.note?.(removed.map((r) => `  - ${r.filename}`).join("\n"),
+        `이전 설치에는 있었지만 지금 없는 워크플로우 (${removed.length}개)`);
+      for (const { filename } of removed) {
+        const sel = await io.engineIo.select({
+          message: `${filename} — 직접 지우신 것으로 보입니다. 다시 추가할까요?`,
+          options: [
+            { value: "keep", label: "추가하지 않음 — 지운 상태 유지 (기본)" },
+            { value: "restore", label: "다시 추가 — 최신 버전으로 설치" },
+          ],
+        });
+        if (!isCancel(sel) && sel === "restore") restoreRemoved.add(filename); // ESC = 유지
+      }
+    }
+
+    // (a) 진짜 충돌 3지선 — 타입당 1회 결정을 파일에 캐시 적용 (.sh L3440~3508 UX 등가)
+    const decisions = new Map();
     if (conflicts.length) {
       const perType = new Map();
-      const decisions = new Map();
       for (const { filename, type } of conflicts) {
         if (!perType.has(type)) {
           const sel = await io.engineIo.select({
-            message: `기존 워크플로우와 내용이 다른 파일이 있습니다 (${type}) — 어떻게 할까요?`,
+            message: `내 수정과 업스트림 변경이 겹칩니다 (${type}) — 어떻게 할까요?`,
             options: [
               { value: "skip", label: "건너뛰기 — 기존 파일 유지 (기본)" },
               { value: "backup", label: ".bak 백업 후 새 버전으로 교체" },
@@ -227,8 +247,8 @@ export async function runInteractive(baseCtx, { cwd = process.cwd(), payloadRoot
         }
         decisions.set(filename, perType.get(type));
       }
-      hooks = { decisions };
     }
+    hooks = { decisions, restoreRemoved };
   }
 
   const result = runFull(ctx, payload, cwd, hooks);

package/src/commands/purge.js

@@ -18,6 +18,7 @@ export function planPurge(payloadRoot, targetRoot = ".", keepFlags = {}) {
   const removalPlan = planRemoval(payloadRoot, targetRoot);
   return {
     workflows: keepFlags.workflows ? [] : removalPlan.workflows,
+    baseline: keepFlags.workflows ? [] : removalPlan.baseline,
     scripts: keepFlags.scripts ? [] : removalPlan.scripts,
     versionYml: !keepFlags.versionYml && existsSync(join(targetRoot, PATHS.versionFile)),
     readmeSection: !keepFlags.readme && hasVersionSection(targetRoot),
@@ -55,6 +56,7 @@ export function executePurge(payloadRoot, targetRoot = ".", keepFlags = {}) {
   const wfDir = join(targetRoot, PATHS.workflowsDir);
   for (const name of plan.workflows) remove(join(wfDir, name));
   for (const name of plan.scripts) remove(join(targetRoot, PATHS.scriptsDir, name));
+  for (const p of plan.baseline || []) remove(join(targetRoot, p));
   if (plan.versionYml) remove(join(targetRoot, PATHS.versionFile));
   const readmeSection = plan.readmeSection && removeVersionSectionFromReadme(targetRoot) === "removed";
   for (const f of plan.changelog) remove(join(targetRoot, f));

package/src/commands/status.js

@@ -33,7 +33,17 @@ export function runStatus(payloadRoot, targetRoot = ".") {
     types: existing.types,
     branches: existing.branches,
     options: existing.options,
-    modifiedFiles: plan.changed.map((f) => f.filename),
+    // 사용자가 손댄 파일 = 진짜 충돌(changed) + 업스트림은 그대로인데 내가 고친 것(localOnly).
+    // baseline이 없으면 localOnly는 항상 비어 있어 종전과 동일하게 동작한다 (issue #69).
+    modifiedFiles: [...plan.changed, ...plan.localOnly].map((f) => f.filename),
+    // 업데이트 시 무슨 일이 일어날지 미리 보여주는 버킷들 — 판단 재료가 없어 사용자가
+    // 직접 git diff를 떠야 했던 문제를 없앤다.
+    buckets: {
+      autoUpdatable: plan.upstreamOnly.map((f) => f.filename), // 질문 없이 최신으로 교체됨
+      localKept: plan.localOnly.map((f) => f.filename),        // 질문 없이 내 수정본 유지됨
+      conflicts: plan.changed.map((f) => f.filename),          // 양쪽 변경 — 검토 필요
+      removed: plan.removed.map((f) => f.filename),            // 내가 지웠고 복원하지 않음
+    },
   };
 }
 
@@ -59,6 +69,16 @@ export function printStatus(status) {
   } else {
     lines.push("", "모든 워크플로우 파일이 설치 시점 기본값과 동일합니다 (수정 없음).");
   }
+
+  // 업데이트하면 무슨 일이 일어나는지 (issue #69). baseline이 없는 설치는 전부 0이라 출력하지 않는다.
+  const b = status.buckets || { autoUpdatable: [], localKept: [], conflicts: [], removed: [] };
+  if (b.autoUpdatable.length || b.localKept.length || b.conflicts.length || b.removed.length) {
+    lines.push("", "지금 업데이트하면:");
+    lines.push(`  업스트림 변경 — 자동 적용 가능   ${String(b.autoUpdatable.length).padStart(3)}`);
+    lines.push(`  내가 수정 · 업스트림 그대로      ${String(b.localKept.length).padStart(3)}   (유지)`);
+    lines.push(`  양쪽 변경 — 검토 필요            ${String(b.conflicts.length).padStart(3)}`);
+    lines.push(`  내가 삭제함 — 복원 안 함         ${String(b.removed.length).padStart(3)}`);
+  }
   lines.push("");
   console.log(lines.join("\n"));
 }

package/src/commands/uninstall.js

@@ -16,6 +16,8 @@ export function planUninstall(payloadRoot, targetRoot, selection) {
   const removalPlan = planRemoval(payloadRoot, targetRoot);
   return {
     workflows: selection.workflows ? removalPlan.workflows : [],
+    // baseline은 워크플로우 해시 기록 — 워크플로우를 지우면 함께 사라져야 한다 (issue #69)
+    baseline: selection.workflows ? removalPlan.baseline : [],
     scripts: selection.scripts ? removalPlan.scripts : [],
     readme: selection.readme ? hasVersionSection(targetRoot) : false,
     gitignore: selection.gitignore ? hasAutoAddedEntries(targetRoot) : false,
@@ -29,6 +31,7 @@ export function runUninstall(context, payloadRoot, targetRoot, selection) {
   const wfDir = join(targetRoot, PATHS.workflowsDir);
   for (const name of plan.workflows) remove(join(wfDir, name));
   for (const name of plan.scripts) remove(join(targetRoot, PATHS.scriptsDir, name));
+  for (const p of plan.baseline || []) remove(join(targetRoot, p));
   // removeVersionSectionFromReadme/removeAutoAddedEntriesFromGitignore는 plan이 "제거 대상"으로
   // 판단했더라도 실제로는 안전하게 포기(skip-*)할 수 있다 — 반환 상태를 그대로 신뢰하지 않고
   // 실제 결과로 plan을 덮어써서 호출부(CLI/대화형 요약)가 거짓 성공을 보고하지 않게 한다.

package/src/core/baseline.js

@@ -0,0 +1,76 @@
+// 설치 시점 baseline (issue #69) — 업데이트에서 "누가 바꿨는지"를 가르는 기준점.
+//
+// 왜 필요한가: isUnchanged()는 payload(theirs)와 설치본(ours)을 2-way로 비교한다.
+// base가 없으니 업스트림이 한 글자만 고쳐도 사용자가 손대지 않은 파일이 changed로 떨어지고,
+// 결국 "전부 skip(업데이트 못 받음)" 아니면 "전부 backup(사용자 수정 전멸)" 둘 중 하나만
+// 고를 수 있게 된다.
+//
+// 파일 사본이 아니라 해시만 남긴다 — 분류가 목적이지 자동 병합이 목적이 아니다.
+//
+// 해시를 두 개 두는 이유(이슈 원안은 하나였다): env 치환으로 사용자 값이 들어간 파일은
+// 디스크 내용과 "기본값으로 렌더한 결과"가 애초에 다르다. 하나로는 두 질문에 동시에 답할 수 없다.
+//   - installed : 설치 시점 우리가 디스크에 쓴 내용     → "사용자가 그 뒤에 손댔는가"
+//   - rendered  : 그 시점 payload를 기본값 치환한 결과  → "업스트림이 그 뒤에 바뀌었는가"
+//
+// installed는 우리가 실제로 쓴 파일에만 채운다. 사용자 수정본을 installed로 기록하면
+// "우리가 쓴 것"이라고 거짓말하는 셈이고, 다음 업데이트에서 그 파일이 조용히 덮인다.
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { writeText } from "./fsutil.js";
+
+export const BASELINE_DIR = ".github/.wizard";
+export const BASELINE_PATH = ".github/.wizard/baseline.json";
+
+export function sha256(text) {
+  return "sha256:" + createHash("sha256").update(String(text), "utf8").digest("hex");
+}
+
+// 없거나 깨졌으면 null — 호출부는 "base 미상"으로 폴백한다(조용히 빈 baseline을 쓰지 않는다.
+// 빈 baseline은 "기록이 없다"가 아니라 "전부 삭제됐다"로 오해될 수 있다).
+export function readBaseline(targetRoot = ".") {
+  const p = join(targetRoot, BASELINE_PATH);
+  if (!existsSync(p)) return null;
+  try {
+    const data = JSON.parse(readFileSync(p, "utf8"));
+    if (!data || typeof data !== "object" || typeof data.files !== "object" || data.files === null) return null;
+    return data;
+  } catch {
+    return null; // 손상된 baseline은 없는 것으로 취급 — 업데이트를 막지 않는다
+  }
+}
+
+// entries: Map<filename, {installed?:string|null, rendered:string}>
+// 기존 baseline은 병합 대상이다 — 이번 실행에서 건드리지 않은 파일의 기준점을 잃지 않는다.
+export function writeBaseline(targetRoot, { templateVersion, installedAt, entries, previous = null }) {
+  const files = { ...(previous?.files || {}) };
+  for (const [filename, entry] of entries) {
+    const prev = files[filename] || {};
+    files[filename] = {
+      // installed는 이번에 실제로 쓴 경우에만 갱신. 유지(skip)한 파일은 예전 기준점을 지킨다.
+      installed: entry.installed ?? prev.installed ?? null,
+      rendered: entry.rendered,
+    };
+  }
+  const out = {
+    templateVersion: templateVersion || "unknown",
+    installedAt: installedAt || "",
+    files,
+  };
+  writeText(join(targetRoot, BASELINE_PATH), JSON.stringify(out, null, 2) + "\n");
+  return out;
+}
+
+// baseline에는 있는데 디스크에 없는 파일 = 사용자가 지운 것.
+// 별도의 삭제 이력 파일이 필요 없다는 것이 이 설계의 부산물이다.
+// candidates: payload가 이번에 설치하려는 파일명 목록 (그 밖의 baseline 항목은 관심 없다)
+export function detectRemoved(baseline, candidates, workflowsDir) {
+  if (!baseline) return [];
+  const removed = [];
+  for (const filename of candidates) {
+    if (!baseline.files[filename]) continue;      // 우리가 설치한 적 없는 파일 — 판단 근거 없음
+    if (existsSync(join(workflowsDir, filename))) continue;
+    removed.push(filename);
+  }
+  return removed;
+}

package/src/core/copy/workflows.js

@@ -6,12 +6,13 @@ import { join, basename } from "node:path";
 import { existsSync, readFileSync, writeFileSync, renameSync } from "node:fs";
 import { PATHS, PAYLOAD } from "../paths.js";
 import { exists, writeText, listYamlFiles } from "../fsutil.js";
-import { isUnchanged, substituteEnv } from "../wizard-env.js";
+import { substituteEnv } from "../wizard-env.js";
 import { substitute } from "../branding.js";
+import { sha256, readBaseline } from "../baseline.js";
 
 // 원본 텍스트 로더 — context.branches가 있으면 {{MAIN_BRANCH}}/{{DEVELOP_BRANCH}} 치환 적용.
 // classify(unchanged 판정)와 실제 복사가 같은 치환본을 봐야 재실행 시 가짜 충돌이 없다.
-function makeSrcText(branches) {
+export function makeSrcText(branches) {
   return (p) => {
     const raw = readFileSync(p, "utf8");
     return branches ? substitute(raw, branches) : raw;
@@ -34,34 +35,100 @@ function configureEnv(targetPath, { type, projectPath = ".", repoName = "", reso
   writeFileSync(targetPath, out);
 }
 
-// 3분류 (신규/unchanged/changed) — 대상 워크플로우 디렉토리 기준.
-// srcText: 브랜치 치환이 적용된 원본 로더 (makeSrcText).
-function classify(srcDir, workflowsDir, envOpts, srcText) {
-  const result = { newFiles: [], unchanged: [], changed: [] };
+// payload 원본을 "기본값으로 가상 치환한 최종형" — isUnchanged가 내부에서 쓰는 것과 같은 값이다.
+// baseline.rendered와 비교해 "업스트림이 바뀌었는가"를 판정하는 데 쓴다.
+function renderVirtual(templateContent, envOpts) {
+  return substituteEnv(templateContent, { ...envOpts, useDefaults: true });
+}
+
+// 분류 — 대상 워크플로우 디렉토리 기준. srcText: 브랜치 치환이 적용된 원본 로더 (makeSrcText).
+//
+// baseline이 있으면 3-way로 가른다 (issue #69). base가 없던 시절에는 업스트림이 한 글자만 고쳐도
+// 사용자가 손대지 않은 파일이 changed로 떨어져, "전부 skip" 아니면 "전부 backup" 둘 중 하나만
+// 고를 수 있었다.
+//
+//   ours === theirs                    → unchanged     이미 최신, 할 일 없음
+//   sha(ours) === base.installed       → upstreamOnly  사용자 미수정 → 질문 없이 교체
+//   sha(theirs) === base.rendered      → localOnly     업스트림 그대로 → 질문 없이 유지
+//   그 외                              → changed       진짜 충돌 → 질문
+//   디스크에 없는데 baseline에 있음     → removed       사용자가 지움 → 되살리기 전에 물어봄
+//
+// baseline이 없는 기존 설치는 base 미상이라 upstreamOnly/localOnly 판정을 할 수 없고,
+// 종전대로 unchanged/changed 2분류로 떨어진다(폴백). 그 실행에서 baseline이 심긴다.
+function classify(srcDir, workflowsDir, envOpts, srcText, baseline = null) {
+  const result = { newFiles: [], unchanged: [], changed: [], upstreamOnly: [], localOnly: [], removed: [] };
   for (const filename of listYamlFiles(srcDir)) {
     const src = join(srcDir, filename);
     const dst = join(workflowsDir, filename);
-    if (existsSync(dst)) {
-      const tpl = srcText(src);
-      const inst = readFileSync(dst, "utf8");
-      if (isUnchanged(tpl, inst, envOpts)) result.unchanged.push(filename);
-      else result.changed.push(filename);
-    } else {
-      result.newFiles.push(filename);
+    const base = baseline?.files?.[filename] || null;
+
+    if (!existsSync(dst)) {
+      // baseline에 있는데 디스크에 없다 = 우리가 깔았던 파일을 사용자가 지웠다.
+      // 별도의 삭제 이력 파일이 필요 없다는 것이 baseline 설계의 부산물이다.
+      if (base) result.removed.push(filename);
+      else result.newFiles.push(filename);
+      continue;
     }
+
+    const tpl = srcText(src);
+    const inst = readFileSync(dst, "utf8");
+    const theirs = renderVirtual(tpl, envOpts);
+    if (theirs === inst) { result.unchanged.push(filename); continue; }
+    if (base?.installed && sha256(inst) === base.installed) { result.upstreamOnly.push(filename); continue; }
+    if (base?.rendered && sha256(theirs) === base.rendered) { result.localOnly.push(filename); continue; }
+    result.changed.push(filename);
   }
   return result;
 }
 
+// 한 원본 디렉토리를 분류 결과대로 처리한다. common·타입별·server-deploy가 같은 규칙을 쓴다.
+// filter: trunk-based 제외 같은 파일 단위 필터.
+//
+// 자동 처리되는 두 버킷이 이 함수의 핵심이다 (issue #69):
+//   upstreamOnly — 사용자가 손대지 않았으니 그냥 최신으로 교체한다. 물어볼 이유가 없다.
+//   localOnly    — 업스트림이 그대로니 사용자 수정본을 그대로 둔다. 역시 물어볼 이유가 없다.
+function processDir(srcDir, workflowsDir, envOpts, ctx, counters, filter = () => true) {
+  const { srcText, baseline, decisions, restoreRemoved, baselineTargets } = ctx;
+  const c = classify(srcDir, workflowsDir, envOpts, srcText, baseline);
+  const track = (f, wrote) => baselineTargets.set(f, { srcPath: join(srcDir, f), envOpts, wrote });
+  const write = (f) => { writeText(join(workflowsDir, f), srcText(join(srcDir, f))); counters.copied++; counters.copiedFiles.push(f); track(f, true); };
+
+  for (const f of c.unchanged.filter(filter)) { counters.skipped++; track(f, false); }
+
+  for (const f of c.localOnly.filter(filter)) { counters.skipped++; counters.keptLocal.push(f); track(f, false); }
+
+  for (const f of c.newFiles.filter(filter)) write(f);
+
+  for (const f of c.upstreamOnly.filter(filter)) { write(f); counters.autoUpdated.push(f); }
+
+  // 사용자가 지운 파일은 조용히 되살리지 않는다. 복원 결정이 있을 때만 다시 쓴다.
+  // 되살리지 않은 파일은 baselineTargets에 넣지 않는다 — 디스크에 없어 해시할 것이 없고,
+  // 기존 baseline 항목은 병합으로 남아 다음 실행에서도 "지운 파일"로 인식된다.
+  for (const f of c.removed.filter(filter)) {
+    if (restoreRemoved.has(f)) { write(f); counters.restoredFiles.push(f); }
+    else counters.removedKept.push(f);
+  }
+
+  for (const f of c.changed.filter(filter)) {
+    const decision = decisions.get(f);
+    applyDecision(decision, srcDir, workflowsDir, f, counters, srcText);
+    // 'backup'만 대상 파일 자체를 새로 쓴다. 'template'은 다른 파일명이고 'skip'은 기존 유지.
+    track(f, decision === "backup");
+  }
+  return c;
+}
+
 // copy_workflows 본체 (동기 — 기존 호출부 무변경).
 // context: { types:[], paths:Map, includeNexus, includeSecretBackup, force, repoName, resolvers,
 //            envValues?:Map<key,value>, envUseDefaults?:boolean }  ← env 계획(promptEnvPlan) 결과 주입점
-// hooks: { decisions?: Map<filename, 'skip'|'backup'|'template'> } — 기존 파일(changed) 충돌 결정.
+// hooks: { decisions?: Map<filename, 'skip'|'backup'|'template'>,   — 진짜 충돌(changed) 결정
+//          restoreRemoved?: Set<filename> }                          — 사용자가 지운 파일 중 복원할 것
 //        미지정 파일은 'skip'(현행 force 동작 100% 유지). 대화형 수집은 copyWorkflowsInteractive 참조.
-// 반환: {copied, skipped, templateAdded, optionalCopied, backupAdded}
+// 반환: {copied, skipped, templateAdded, optionalCopied, backupAdded, autoUpdated, keptLocal, removedKept, restoredFiles}
 export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}) {
   const { types = [], paths = new Map(), includeNexus = false, includeSecretBackup = false, repoName = "", resolvers = {}, envValues = new Map(), envUseDefaults = true } = context;
   const decisions = hooks.decisions instanceof Map ? hooks.decisions : new Map();
+  const restoreRemoved = hooks.restoreRemoved instanceof Set ? hooks.restoreRemoved : new Set();
   const workflowsDir = join(targetRoot, PATHS.workflowsDir);
   const projectTypesDir = join(payloadRoot, PAYLOAD.workflowsDir);
   if (!exists(projectTypesDir)) throw new Error("패키지 구조 오류 — payload/workflows 폴더를 찾지 못했습니다.");
@@ -70,31 +137,30 @@ export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}
   const deployValues = new Map(); // Map<type, Map<key,value>> — deploy 블록용 ask 값
   counters.deployValues = deployValues;
   counters.copiedFiles = []; // 이번 실행에서 실제로 새로 쓰여진 파일명 (issue #19 — printSummary 정확성용)
+  counters.autoUpdated = [];    // 질문 없이 최신으로 교체된 파일 (사용자 미수정)
+  counters.keptLocal = [];      // 질문 없이 사용자 수정본을 유지한 파일 (업스트림 무변경)
+  counters.removedKept = [];    // 사용자가 지웠고 되살리지 않은 파일
+  counters.restoredFiles = [];  // 사용자가 지웠지만 복원하기로 한 파일
   const srcText = makeSrcText(context.branches || null);
-  // values/useDefaults는 치환 경로에서만 의미 (isUnchanged는 내부에서 useDefaults:true 강제 — 가상 비교 무손상)
+  const baseline = readBaseline(targetRoot);
+  const baselineTargets = new Map(); // filename -> { srcPath, envOpts, wrote }
+  // values/useDefaults는 치환 경로에서만 의미 (renderVirtual은 useDefaults:true 강제 — 가상 비교 무손상)
   const envOptsFor = (type) => ({ type, projectPath: paths.get(type) || ".", repoName, resolvers, values: envValues, useDefaults: envUseDefaults });
+  const dirCtx = { srcText, baseline, decisions, restoreRemoved, baselineTargets };
 
-  // (1) common — 타입별 워크플로우와 동일한 3지선(README 계약, issue #20 H3): unchanged면 스킵,
-  //     changed면 decisions Map 결정에 따름(미지정 시 skip — 기존 사용자 수정 보존).
+  // (1) common — 타입별과 동일 규칙 (README 계약, issue #20 H3).
   //     trunk-based 모드는 VERSION-CONTROL·AUTO-CHANGELOG 미설치 (RELEASE-PUBLISH 단독).
   const branchMode = context.branches?.mode || "pr-flow";
   const commonDir = join(projectTypesDir, "common");
   if (exists(commonDir)) {
     const notExcluded = (filename) => !(branchMode === "trunk-based" && TRUNK_BASED_EXCLUDED.has(filename));
-    const { newFiles, unchanged, changed } = classify(commonDir, workflowsDir, envOptsFor("common"), srcText);
-    counters.skipped += unchanged.filter(notExcluded).length;
-    for (const f of newFiles.filter(notExcluded)) {
-      writeText(join(workflowsDir, f), srcText(join(commonDir, f)));
-      counters.copied++;
-      counters.copiedFiles.push(f);
-    }
-    for (const f of changed.filter(notExcluded)) applyDecision(decisions.get(f), commonDir, workflowsDir, f, counters, srcText);
+    processDir(commonDir, workflowsDir, envOptsFor("common"), dirCtx, counters, notExcluded);
   }
 
   // (2~4) 타입별
   for (const type of types) {
     const asks = new Map();
-    copyWorkflowsForType(type, projectTypesDir, workflowsDir, { includeNexus, ...context, envOptsFor, collectAsks: asks, decisions, srcText }, counters);
+    copyWorkflowsForType(type, projectTypesDir, workflowsDir, { includeNexus, ...context, envOptsFor, collectAsks: asks, dirCtx }, counters);
     if (asks.size) deployValues.set(type, asks);
   }
 
@@ -108,12 +174,29 @@ export function copyWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}
       counters.optionalCopied++;
       counters.copied++;
       counters.copiedFiles.push(filename);
+      baselineTargets.set(filename, { srcPath: join(secretDir, filename), envOpts: envOptsFor("common"), wrote: true });
     }
   }
 
+  counters.baselineTargets = baselineTargets; // 호출부(runFull)가 env 치환 완료 후 baseline을 기록한다
   return counters;
 }
 
+// copyWorkflows가 끝나고 env 치환까지 마친 뒤에 호출한다 — 그래야 디스크 내용이 최종형이다.
+// entries: Map<filename, {installed:string|null, rendered:string}>
+export function computeBaselineEntries(baselineTargets, workflowsDir, srcText) {
+  const entries = new Map();
+  for (const [filename, info] of baselineTargets) {
+    const dst = join(workflowsDir, filename);
+    if (!existsSync(dst)) continue;
+    const rendered = sha256(renderVirtual(srcText(info.srcPath), info.envOpts));
+    // installed는 이번에 우리가 쓴 파일에만 채운다. 사용자 수정본을 installed로 기록하면
+    // "우리가 쓴 것"이라고 거짓말하는 셈이고, 다음 업데이트에서 그 파일이 조용히 덮인다.
+    entries.set(filename, { installed: info.wrote ? sha256(readFileSync(dst, "utf8")) : null, rendered });
+  }
+  return entries;
+}
+
 // changed(기존에 있고 내용이 바뀐) 파일 1개를 결정에 따라 처리 (.sh 3440~3508 3지선 case 등가).
 // 'skip'(기본): 기존 유지. 'backup': 기존→.bak 후 교체. 'template': 기존 유지 + 새 버전을 .template.yaml로.
 function applyDecision(decision, srcDir, workflowsDir, filename, counters, srcText) {
@@ -139,38 +222,47 @@ function applyDecision(decision, srcDir, workflowsDir, filename, counters, srcTe
   counters.skipped++; // 'skip'/미지정/ESC → 기존 유지 (.sh S)·force 기본)
 }
 
-// 대상 워크플로우 디렉토리에서 changed(충돌) 파일 목록만 뽑는다 — copyWorkflowsInteractive의 사전 조사용.
+// 대화형 사전 조사 — 사람이 답해야 하는 것만 뽑는다 (issue #69).
 // copyWorkflows 본체와 동일한 classify 기준을 써야 결정 Map이 실제 처리 대상과 1:1로 맞는다.
 // common도 타입별과 동일하게 스캔한다 (issue #20 H3 — 이전에는 common 충돌이 질문조차 되지 않았다).
-export function listWorkflowConflicts(context, payloadRoot, targetRoot = ".") {
+// 반환: { conflicts: [{filename,type}], removed: [{filename,type}] }
+//   conflicts — 양쪽이 다 바뀐 진짜 충돌. upstreamOnly/localOnly는 자동 처리되므로 여기 없다.
+//   removed   — 우리가 깔았는데 사용자가 지운 파일. 되살리기 전에 물어봐야 한다.
+export function surveyWorkflows(context, payloadRoot, targetRoot = ".") {
   const { types = [], paths = new Map(), includeNexus = false, repoName = "", resolvers = {} } = context;
   const workflowsDir = join(targetRoot, PATHS.workflowsDir);
   const projectTypesDir = join(payloadRoot, PAYLOAD.workflowsDir);
   const srcText = makeSrcText(context.branches || null);
+  const baseline = readBaseline(targetRoot);
   const branchMode = context.branches?.mode || "pr-flow";
-  const conflicts = []; // [{ filename, type }] — 엔진 처리 순서와 동일 (common → 타입 순회 → 직하위 → server-deploy)
+  const conflicts = []; // 엔진 처리 순서와 동일 (common → 타입 순회 → 직하위 → server-deploy)
+  const removed = [];
+
+  const collect = (srcDir, envOpts, type, skipFile = () => false) => {
+    const c = classify(srcDir, workflowsDir, envOpts, srcText, baseline);
+    for (const f of c.changed) { if (!skipFile(f)) conflicts.push({ filename: f, type }); }
+    for (const f of c.removed) { if (!skipFile(f)) removed.push({ filename: f, type }); }
+  };
 
   const commonDir = join(projectTypesDir, "common");
   if (exists(commonDir)) {
-    const envOpts = { type: "common", projectPath: ".", repoName, resolvers };
-    for (const f of classify(commonDir, workflowsDir, envOpts, srcText).changed) {
-      if (branchMode === "trunk-based" && TRUNK_BASED_EXCLUDED.has(f)) continue;
-      conflicts.push({ filename: f, type: "common" });
-    }
+    collect(commonDir, { type: "common", projectPath: ".", repoName, resolvers }, "common",
+      (f) => branchMode === "trunk-based" && TRUNK_BASED_EXCLUDED.has(f));
   }
 
   for (const type of types) {
     const envOpts = { type, projectPath: paths.get(type) || ".", repoName, resolvers };
     const typeDir = join(projectTypesDir, type);
-    if (exists(typeDir)) {
-      for (const f of classify(typeDir, workflowsDir, envOpts, srcText).changed) conflicts.push({ filename: f, type });
-    }
+    if (exists(typeDir)) collect(typeDir, envOpts, type);
     const serverDeployDir = join(typeDir, "server-deploy");
-    if (exists(serverDeployDir) && !includeNexus) {
-      for (const f of classify(serverDeployDir, workflowsDir, envOpts, srcText).changed) conflicts.push({ filename: f, type });
-    }
+    if (exists(serverDeployDir) && !includeNexus) collect(serverDeployDir, envOpts, type);
   }
-  return conflicts;
+  return { conflicts, removed };
+}
+
+// 진짜 충돌 목록만 필요할 때 (기존 호출부 호환).
+export function listWorkflowConflicts(context, payloadRoot, targetRoot = ".") {
+  return surveyWorkflows(context, payloadRoot, targetRoot).conflicts;
 }
 
 // 대화형 진입점 (async) — 충돌마다 onConflict(filename, type)를 await해 결정 Map을 만든 뒤
@@ -189,23 +281,18 @@ export async function copyWorkflowsInteractive(context, payloadRoot, targetRoot
 }
 
 function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters) {
-  const { includeNexus, envOptsFor, collectAsks = null, decisions = new Map(), srcText } = ctx;
+  const { includeNexus, envOptsFor, collectAsks = null, dirCtx } = ctx;
+  const { srcText, baselineTargets } = dirCtx;
   const typeDir = join(projectTypesDir, type);
   const envOpts = envOptsFor(type);
-  let unchangedNames = [];
+  // env 치환에서 제외할 파일 — 손대지 않기로 한 것들(unchanged/localOnly/유지된 삭제분)에
+  // 치환을 다시 걸면 사용자 수정본을 덮어쓰게 된다.
+  const untouched = [];
 
   // 타입별 워크플로우 (직하위)
   if (exists(typeDir)) {
-    const { newFiles, unchanged, changed } = classify(typeDir, workflowsDir, envOpts, srcText);
-    unchangedNames = unchanged.slice();
-    for (const f of unchanged) counters.skipped++;
-    for (const f of newFiles) {
-      writeText(join(workflowsDir, f), srcText(join(typeDir, f)));
-      counters.copied++;
-      counters.copiedFiles.push(f);
-    }
-    // changed: 결정 Map에 따라 처리 (미지정=skip → 현행 force 동작과 동일)
-    for (const f of changed) applyDecision(decisions.get(f), typeDir, workflowsDir, f, counters, srcText);
+    const c = processDir(typeDir, workflowsDir, envOpts, dirCtx, counters);
+    untouched.push(...c.unchanged, ...c.localOnly);
   }
 
   // server-deploy
@@ -214,14 +301,8 @@ function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters
     if (includeNexus) {
       // Nexus 프로젝트 → 폴더째 제외 (복사 안 함)
     } else {
-      const { newFiles, unchanged, changed } = classify(serverDeployDir, workflowsDir, envOpts, srcText);
-      for (const f of unchanged) counters.skipped++;
-      for (const f of newFiles) {
-        writeText(join(workflowsDir, f), srcText(join(serverDeployDir, f)));
-        counters.copied++;
-        counters.copiedFiles.push(f);
-      }
-      for (const f of changed) applyDecision(decisions.get(f), serverDeployDir, workflowsDir, f, counters, srcText);
+      const c = processDir(serverDeployDir, workflowsDir, envOpts, dirCtx, counters);
+      untouched.push(...c.unchanged, ...c.localOnly);
     }
   }
 
@@ -232,7 +313,7 @@ function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters
       const src = join(nexusDir, filename);
       const dst = join(workflowsDir, filename);
       const body = srcText(src);
-      if (existsSync(dst) && isUnchanged(body, readFileSync(dst, "utf8"), envOpts)) {
+      if (existsSync(dst) && renderVirtual(body, envOpts) === readFileSync(dst, "utf8")) {
         counters.skipped++;
         continue;
       }
@@ -241,16 +322,17 @@ function copyWorkflowsForType(type, projectTypesDir, workflowsDir, ctx, counters
       counters.optionalCopied++;
       counters.copied++;
       counters.copiedFiles.push(filename);
+      baselineTargets.set(filename, { srcPath: src, envOpts, wrote: true });
     }
   }
 
-  // env 치환 — 이 타입의 원본 디렉토리들에서 복사돼 존재하고 unchanged 아닌 파일만
+  // env 치환 — 이 타입의 원본 디렉토리들에서 복사돼 존재하고, 손대지 않기로 한 것이 아닌 파일만
   for (const srcDir of [typeDir, serverDeployDir, nexusDir]) {
     if (!exists(srcDir)) continue;
     for (const filename of listYamlFiles(srcDir)) {
       const target = join(workflowsDir, filename);
-      if (!existsSync(target)) continue;            // 건너뛴 파일 제외
-      if (unchangedNames.includes(filename)) continue; // unchanged 제외
+      if (!existsSync(target)) continue;          // 건너뛴 파일 제외
+      if (untouched.includes(filename)) continue; // unchanged/localOnly 제외
       configureEnv(target, { ...envOpts, collectAsks }); // env 계획 values/useDefaults 포함
     }
   }
@@ -264,11 +346,14 @@ export function planWorkflows(context, payloadRoot, targetRoot = ".") {
   const workflowsDir = join(targetRoot, PATHS.workflowsDir);
   const projectTypesDir = join(payloadRoot, PAYLOAD.workflowsDir);
   const srcText = makeSrcText(context.branches || null);
+  const baseline = readBaseline(targetRoot);
   const branchMode = context.branches?.mode || "pr-flow";
-  const plan = { newFiles: [], unchanged: [], changed: [] };
+  // upstreamOnly/localOnly/removed는 baseline이 있을 때만 채워진다 (issue #69).
+  const plan = { newFiles: [], unchanged: [], changed: [], upstreamOnly: [], localOnly: [], removed: [] };
+  const BUCKETS = ["newFiles", "unchanged", "changed", "upstreamOnly", "localOnly", "removed"];
 
   const merge = (result, type, excluded = null) => {
-    for (const bucket of ["newFiles", "unchanged", "changed"]) {
+    for (const bucket of BUCKETS) {
       for (const filename of result[bucket]) {
         if (excluded && excluded.has(filename)) continue;
         plan[bucket].push({ filename, type });
@@ -279,7 +364,7 @@ export function planWorkflows(context, payloadRoot, targetRoot = ".") {
   const commonDir = join(projectTypesDir, "common");
   if (exists(commonDir)) {
     const envOpts = { type: "common", projectPath: ".", repoName, resolvers };
-    merge(classify(commonDir, workflowsDir, envOpts, srcText), "common",
+    merge(classify(commonDir, workflowsDir, envOpts, srcText, baseline), "common",
       branchMode === "trunk-based" ? TRUNK_BASED_EXCLUDED : null);
   }
 
@@ -296,16 +381,16 @@ export function planWorkflows(context, payloadRoot, targetRoot = ".") {
   for (const type of types) {
     const envOpts = { type, projectPath: paths.get(type) || ".", repoName, resolvers };
     const typeDir = join(projectTypesDir, type);
-    if (exists(typeDir)) merge(classify(typeDir, workflowsDir, envOpts, srcText), type);
+    if (exists(typeDir)) merge(classify(typeDir, workflowsDir, envOpts, srcText, baseline), type);
 
     const serverDeployDir = join(typeDir, "server-deploy");
     if (exists(serverDeployDir) && !includeNexus) {
-      merge(classify(serverDeployDir, workflowsDir, envOpts, srcText), type);
+      merge(classify(serverDeployDir, workflowsDir, envOpts, srcText, baseline), type);
     }
 
     const nexusDir = join(typeDir, "nexus");
     if (exists(nexusDir) && includeNexus) {
-      merge(classify(nexusDir, workflowsDir, envOpts, srcText), type);
+      merge(classify(nexusDir, workflowsDir, envOpts, srcText, baseline), type);
     }
   }
 

package/src/core/removal-plan.js

@@ -16,6 +16,7 @@
 import { join } from "node:path";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { PATHS, PAYLOAD } from "./paths.js";
+import { BASELINE_DIR, BASELINE_PATH } from "./baseline.js";
 
 // payload/workflows/**/*.yaml 첫 줄에 심어둔 고정 마커 — 이 값이 바뀌면 과거 설치분과의 매칭이 끊긴다.
 export const MANAGED_WORKFLOW_MARKER = "# project-auto-wizard:managed-workflow";
@@ -65,5 +66,8 @@ export function planRemoval(payloadRoot, targetRoot = ".") {
   for (const s of ["version_manager.py", "changelog_manager.py"]) {
     if (existsSync(join(targetRoot, PATHS.scriptsDir, s))) removedScripts.push(s);
   }
-  return { workflows: [...removedWf], scripts: removedScripts };
+  // baseline은 마법사가 만든 내부 상태 파일이다 — 설치물을 지우면 함께 사라져야 한다.
+  // 남겨두면 다음 설치가 "예전에 깔았다가 사용자가 지운 파일"로 오인해 전부 removed로 분류한다.
+  const baseline = existsSync(join(targetRoot, BASELINE_PATH)) ? [BASELINE_DIR] : [];
+  return { workflows: [...removedWf], scripts: removedScripts, baseline };
 }