project-auto-wizard 0.1.33 → 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.32 (2026-08-10)
+## 최신 버전 : v0.1.34 (2026-08-10)
 
 [전체 버전 기록 보기](CHANGELOG.md)
 
@@ -72,13 +72,11 @@ flutter.APP_ARTIFACT_NAME:
 - **react/next**: CI와 CI+CD 분리 구성
 - **python**: CI / PR 프리뷰 / SimpleCICD
 
-### 되돌리기(`--mode revert`)
-
-`npx project-auto-wizard --mode revert --force`는 payload가 설치한 파일명과 **정확히 일치하는 것만** 제거합니다. 사용자가 직접 만든 워크플로우, `version.yml`, `README.md`, `.gitignore`는 건드리지 않습니다. 설치 시 충돌 처리로 생성된 `.bak`/`.template.yaml` 파생 파일도 함께 정리됩니다.
-
 ### 완전 삭제(`--mode uninstall`)
 
-`npx project-auto-wizard --mode uninstall`은 `revert`보다 넓게 제거합니다 — 워크플로우·스크립트는 물론, README.md의 `AUTO-VERSION-SECTION` 버전 섹션과 `.gitignore`에 자동 추가된 항목, `version.yml`까지 선택적으로 제거할 수 있습니다.
+`npx project-auto-wizard --mode uninstall`은 마법사가 설치한 것을 제거합니다 — 워크플로우·스크립트는 물론, README.md의 `AUTO-VERSION-SECTION` 버전 섹션과 `.gitignore`에 자동 추가된 항목, `version.yml`까지 선택적으로 제거할 수 있습니다.
+
+제거 대상은 payload가 설치한 파일명과 정확히 일치하는 것, 그리고 마법사 관리 마커를 가진 파일뿐입니다. 사용자가 직접 만든 워크플로우는 건드리지 않습니다. 설치 시 충돌 처리로 생성된 `.bak`/`.template.yaml` 파생 파일도 함께 정리됩니다.
 
 - **대화형(TTY)**: 실제로 설치된 항목만 체크리스트로 보여줍니다. 워크플로우·스크립트는 기본 체크, README·`.gitignore`·`version.yml`은 opt-in입니다. 선택 후 최종 확인(기본 "아니오")을 거쳐야 실제로 삭제됩니다.
 - **비대화형(`--force`)**: 워크플로우·스크립트만 기본 삭제합니다. README·`.gitignore`·`version.yml`까지 지우려면 `--purge-readme`/`--purge-gitignore`/`--purge-version`을 함께 지정하세요.
@@ -129,7 +127,7 @@ flowchart LR
 ```
 npx project-auto-wizard [옵션]
 
-  -m, --mode MODE          full | version | workflows | revert | uninstall | status | doctor  (기본: 대화형)
+  -m, --mode MODE          full | uninstall | status | doctor  (기본: 대화형)
   -t, --type CSV           spring,react,... (미지정 시 자동 감지)
       --project-version V  초기 버전 (미지정 시 자동 감지)
       --paths "t=p,..."    모노레포 타입별 경로

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-auto-wizard",
-  "version": "0.1.33",
+  "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/cli/args.js

@@ -17,7 +17,7 @@ export function parseArgs(argv) {
     force: false,
     help: false,
     showVersion: false,      // -v/--version → 패키지 버전 출력 (npm 관례)
-    dryRun: false,        // --dry-run: 실제 변경 없이 미리보기만 (full/version/workflows/revert 공통)
+    dryRun: false,        // --dry-run: 실제 변경 없이 미리보기만 (full/uninstall)
     purgeReadme: false,       // --purge-readme: uninstall --force 시 README 버전 섹션도 제거
     purgeGitignore: false,    // --purge-gitignore: uninstall --force 시 .gitignore 자동 추가 항목도 제거
     purgeVersion: false,      // --purge-version: uninstall --force 시 version.yml도 제거
@@ -111,7 +111,7 @@ export function parseArgs(argv) {
   }
   if (!VALID_MODES.includes(result.mode)) {
     throw new CliError(
-      `지원하지 않는 모드: '${result.mode}'\n지원 모드: interactive full version workflows revert uninstall status doctor`
+      `지원하지 않는 모드: '${result.mode}'\n지원 모드: interactive full uninstall status doctor`
     );
   }
   return result;

package/src/cli/help.js

@@ -5,8 +5,8 @@ export const HELP_TEXT = `project-auto-wizard — One command DevOps: GitHub-nat
   npx project-auto-wizard [옵션]
 
 옵션:
-  -m, --mode MODE          통합 모드 (full | version | workflows | revert | uninstall | status | doctor)
-                           기본: interactive (대화형). revert = 설치물 제거(되돌리기)
+  -m, --mode MODE          통합 모드 (full | uninstall | status | doctor)
+                           기본: interactive (대화형). full = 설치 및 업데이트
                            uninstall = 완전 삭제(대화형 체크리스트, --force 시 --purge-*로 opt-in)
                            status = 설치 상태·드리프트 확인(읽기 전용). doctor = 환경 진단(읽기 전용)
   -t, --type CSV           프로젝트 타입 csv (예: spring,react,python)
@@ -19,8 +19,8 @@ export const HELP_TEXT = `project-auto-wizard — One command DevOps: GitHub-nat
       --nexus / --no-nexus            Nexus 라이브러리 publish 워크플로우 포함/제외
       --secret-backup / --no-secret-backup   Secret 백업 워크플로우 포함/제외
       --semver-auto / --no-semver-auto  커밋 타입 기반 자동 major/minor/patch 승격 (기본: 사용함)
-      --force              full/version/workflows/revert 실행에 필수 (모든 확인 생략, 비대화형 기본값 사용)
-      --dry-run            실제 파일 변경 없이 무엇이 바뀔지만 미리 보여줌 (full/version/workflows/revert/uninstall 전체 지원)
+      --force              full 실행에 필수 (모든 확인 생략, 비대화형 기본값 사용)
+      --dry-run            실제 파일 변경 없이 무엇이 바뀔지만 미리 보여줌 (full/uninstall 지원)
       --purge-readme        --mode uninstall --force 시 README.md 버전 섹션도 제거
       --purge-gitignore     --mode uninstall --force 시 .gitignore 자동 추가 항목도 제거
       --purge-version       --mode uninstall --force 시 version.yml도 제거

package/src/commands/dry-run.js

@@ -1,10 +1,9 @@
 // --dry-run 미리보기 — 실제 파일을 쓰지 않고 무엇이 바뀔지 계산한다.
-// full/version/workflows/revert/uninstall 5개 모드 전체 지원.
+// full/uninstall 두 모드 지원 (issue #70 — 부분 설치·되돌리기 모드 제거).
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { PATHS } from "../core/paths.js";
 import { planWorkflows } from "../core/copy/workflows.js";
-import { planRevert } from "./revert.js";
 import { planUninstall } from "./uninstall.js";
 import { buildVersionYml, parseExisting } from "../core/version-yml.js";
 import { readVersionYmlTemplate } from "../core/assets.js";
@@ -35,32 +34,21 @@ function versionYmlPreview(context, payloadRoot, targetRoot) {
   return { existed: existingRaw !== null, changed: existingRaw !== wouldBe };
 }
 
-// mode: "full" | "version" | "workflows" | "revert" | "uninstall". 읽기 전용 — 아무 파일도 쓰지 않는다.
+// mode: "full" | "uninstall". 읽기 전용 — 아무 파일도 쓰지 않는다.
 export function planDryRun(mode, context, payloadRoot, targetRoot = ".") {
-  if (mode === "revert") return { mode, revert: planRevert(payloadRoot, targetRoot) };
   if (mode === "uninstall") {
     return { mode, uninstall: planUninstall(payloadRoot, targetRoot, context.uninstallSelection) };
   }
-
-  const result = { mode };
-  if (mode === "full" || mode === "workflows") {
-    result.workflows = planWorkflows(context, payloadRoot, targetRoot);
-  }
-  if (mode === "full" || mode === "version") {
-    result.versionYml = versionYmlPreview(context, payloadRoot, targetRoot);
-  }
-  return result;
+  return {
+    mode,
+    workflows: planWorkflows(context, payloadRoot, targetRoot),
+    versionYml: versionYmlPreview(context, payloadRoot, targetRoot),
+  };
 }
 
 export function printDryRun(plan) {
   const lines = ["", `project-auto-wizard --dry-run (mode: ${plan.mode}) — 미리보기, 실제 파일은 바뀌지 않았습니다`, ""];
-  if (plan.mode === "revert") {
-    const r = plan.revert;
-    lines.push(`제거될 워크플로우 (${r.workflows.length}개):`);
-    for (const f of r.workflows) lines.push(`  - ${f}`);
-    lines.push(`제거될 스크립트 (${r.scripts.length}개):`);
-    for (const f of r.scripts) lines.push(`  - ${f}`);
-  } else if (plan.mode === "uninstall") {
+  if (plan.mode === "uninstall") {
     const u = plan.uninstall;
     lines.push(`제거될 워크플로우 (${u.workflows.length}개):`);
     for (const f of u.workflows) lines.push(`  - ${f}`);

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,12 +12,9 @@ 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 { runVersion } from "./version.js";
-import { runWorkflows } from "./workflows.js";
-import { runRevert } from "./revert.js";
 import { runUninstallFlow } from "./uninstall.js";
 import * as prompts from "../ui/prompts.js";
 import { runStatus, printStatus } from "./status.js";
@@ -55,16 +52,6 @@ export async function runInteractive(baseCtx, { cwd = process.cwd(), payloadRoot
     break;
   }
 
-  // revert 모드 — 확인 질문(기본 아니오) 후 payload 유래 파일 제거. 감지·breaking 게이트 불필요.
-  if (mode === "revert") {
-    const ok = await io.askYesNo("마법사가 설치한 워크플로우·스크립트를 제거할까요? (version.yml·README는 보존)", false);
-    if (ok !== true) { io.cancelMessage?.("되돌리기를 취소했습니다."); return 0; }
-    const r = runRevert({}, payload, cwd);
-    io.note?.(`워크플로우 ${r.workflows.length}개, 스크립트 ${r.scripts.length}개 제거`, "되돌리기 완료");
-    io.outro?.("되돌리기를 마쳤습니다.");
-    return 0;
-  }
-
   // uninstall 모드 — 대화형 체크리스트로 항목별 opt-in 후 삭제. 감지·breaking 게이트 불필요.
   // runUninstallFlow는 취소/항목없음 시 null을 반환한다 — 그때는 완료 outro를 찍지 않는다.
   if (mode === "uninstall") {
@@ -89,7 +76,7 @@ export async function runInteractive(baseCtx, { cwd = process.cwd(), payloadRoot
   let includeNexus = existing?.options?.nexus ?? false;
   let includeSecretBackup = existing?.options?.secretBackup ?? false;
   let includeSemverAuto = existing?.options?.semverAuto ?? null;
-  const showOptional = mode === "full" || mode === "workflows";
+  const showOptional = mode === "full";
   const realTty = process.stdout.isTTY === true;
 
   // 층2 — 감지 로그 (#446)
@@ -188,8 +175,8 @@ export async function runInteractive(baseCtx, { cwd = process.cwd(), payloadRoot
     }
   }
 
-  // 경로 확정 (.sh resolve_project_paths L1362~1589 — full/version만. 저장값·후보 스캔·질문)
-  if (mode === "full" || mode === "version") {
+  // 경로 확정 (.sh resolve_project_paths L1362~1589 — 저장값·후보 스캔·질문)
+  if (mode === "full") {
     paths = await resolveProjectPaths({
       root: cwd, types, paths, existingPaths: existing?.paths ?? new Map(),
       force: false, tty: realTty, io: io.engineIo ?? {},
@@ -219,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 백업 후 새 버전으로 교체" },
@@ -240,14 +247,11 @@ export async function runInteractive(baseCtx, { cwd = process.cwd(), payloadRoot
         }
         decisions.set(filename, perType.get(type));
       }
-      hooks = { decisions };
     }
+    hooks = { decisions, restoreRemoved };
   }
 
-  let result = null;
-  if (mode === "full") result = runFull(ctx, payload, cwd, hooks);
-  else if (mode === "version") result = runVersion(ctx, payload, cwd);
-  else if (mode === "workflows") result = runWorkflows(ctx, payload, cwd, hooks);
+  const result = runFull(ctx, payload, cwd, hooks);
 
   // 완료 요약 (.sh print_summary L5438)
   io.summary?.({

package/src/commands/purge.js

@@ -1,4 +1,4 @@
-// purge 모드 — revert가 지우는 전부(워크플로우·스크립트) + version.yml·README
+// purge 모드 — planRemoval이 판별하는 전부(워크플로우·스크립트) + version.yml·README
 // AUTO-VERSION-SECTION 블록·CHANGELOG를 추가로 제거해 설치 이전 상태로 완전히 되돌린다.
 // 개발·테스트 전용 숨김 모드 — DESIGN-SPEC purge #6.
 // develop 브랜치 삭제는 파일 삭제와 성격이 달라(실행 시점 git 상태 판단 필요) 여기 plan에는
@@ -7,7 +7,7 @@ import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { PATHS } from "../core/paths.js";
 import { remove } from "../core/fsutil.js";
-import { planRevert } from "./revert.js";
+import { planRemoval } from "../core/removal-plan.js";
 import { removeVersionSectionFromReadme, hasVersionSection } from "../core/copy/readme.js";
 
 const CHANGELOG_FILES = ["CHANGELOG.json", "CHANGELOG.md"];
@@ -15,10 +15,11 @@ const CHANGELOG_FILES = ["CHANGELOG.json", "CHANGELOG.md"];
 // keepFlags: { versionYml, readme, changelog, workflows, scripts } — true인 카테고리는 후보에서 제외.
 // 반환: { workflows, scripts, versionYml, readmeSection, changelog } — 아무것도 지우지 않는 순수 함수.
 export function planPurge(payloadRoot, targetRoot = ".", keepFlags = {}) {
-  const revertPlan = planRevert(payloadRoot, targetRoot);
+  const removalPlan = planRemoval(payloadRoot, targetRoot);
   return {
-    workflows: keepFlags.workflows ? [] : revertPlan.workflows,
-    scripts: keepFlags.scripts ? [] : revertPlan.scripts,
+    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),
     changelog: keepFlags.changelog ? [] : CHANGELOG_FILES.filter((f) => existsSync(join(targetRoot, f))),
@@ -44,7 +45,7 @@ export function printPurgePlan(plan, { dryRun = false } = {}) {
 }
 
 // 실제 삭제 수행 — planPurge()와 동일 shape을 반환하되 실제로 제거된 항목을 반영한다.
-// runRevert()를 통째로 호출하지 않는 이유: runRevert는 항상 전체를 지우므로
+// planRemoval 결과를 그대로 지우지 않는 이유: 그 목록은 항상 전체라서
 // --keep-* 로 선택적 카테고리만 보존하는 요구사항과 맞지 않는다.
 // H3 (Fable 검토): readmeSection은 plan의 판정을 그대로 되돌려주지 않고
 // removeVersionSectionFromReadme()의 실제 반환값("removed"인지)을 반영한다 — 스펙 §6이
@@ -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

@@ -1,10 +1,11 @@
-// uninstall 모드 — revert(payload 파일명 일치분)보다 넓게, README/.gitignore/version.yml까지 선택적으로 제거.
-// 대화형 체크리스트 또는 --force + --purge-* 로 항목별 opt-in. revert.js는 건드리지 않고 읽기 전용으로만 재사용한다.
+// uninstall 모드 — 마법사가 설치한 파일(planRemoval 판별분)에 더해 README/.gitignore/version.yml까지
+// 선택적으로 제거한다. 대화형 체크리스트 또는 --force + --purge-* 로 항목별 opt-in.
+// core/removal-plan.js는 읽기 전용으로만 재사용한다(아무것도 지우지 않는 순수 함수).
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { PATHS } from "../core/paths.js";
 import { remove } from "../core/fsutil.js";
-import { planRevert } from "./revert.js";
+import { planRemoval } from "../core/removal-plan.js";
 import { removeVersionSectionFromReadme, hasVersionSection } from "../core/copy/readme.js";
 import { removeAutoAddedEntriesFromGitignore, hasAutoAddedEntries } from "../core/copy/gitignore.js";
 import { CANCEL } from "../ui/prompts.js";
@@ -12,10 +13,12 @@ import { CANCEL } from "../ui/prompts.js";
 // selection: { workflows, scripts, readme, gitignore, versionYml } (모두 boolean).
 // 반환: 위와 동일한 키의 boolean/배열 — 실제로 제거 "대상"인지 여부(순수 함수, 아무것도 지우지 않음).
 export function planUninstall(payloadRoot, targetRoot, selection) {
-  const revertPlan = planRevert(payloadRoot, targetRoot);
+  const removalPlan = planRemoval(payloadRoot, targetRoot);
   return {
-    workflows: selection.workflows ? revertPlan.workflows : [],
-    scripts: selection.scripts ? revertPlan.scripts : [],
+    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,
     versionYml: selection.versionYml ? existsSync(join(targetRoot, PATHS.versionFile)) : false,
@@ -28,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/대화형 요약)가 거짓 성공을 보고하지 않게 한다.
@@ -52,10 +56,10 @@ const ITEM_DEFS = [
 export const SAFE_ITEMS = ["workflows", "scripts"];
 
 function detectAvailableItems(payloadRoot, targetRoot) {
-  const revertPlan = planRevert(payloadRoot, targetRoot);
+  const removalPlan = planRemoval(payloadRoot, targetRoot);
   const presence = {
-    workflows: revertPlan.workflows.length > 0,
-    scripts: revertPlan.scripts.length > 0,
+    workflows: removalPlan.workflows.length > 0,
+    scripts: removalPlan.scripts.length > 0,
     readme: hasVersionSection(targetRoot),
     gitignore: hasAutoAddedEntries(targetRoot),
     versionYml: existsSync(join(targetRoot, PATHS.versionFile)),

package/src/context.js

@@ -6,9 +6,11 @@ export const VALID_TYPES = [
 
 // --mode 화이트리스트 (issue #19) — 알 수 없는 값은 부수효과(브랜치 조회 등) 이전에 즉시 거부해야 한다.
 // purge는 --help/대화형 메뉴에 노출하지 않는 숨김 모드(issue #6)이지만 검증 대상에는 포함한다.
+// version/workflows(부분 설치)와 revert는 제거됐다 (issue #70) — 부분 설치는 설치 시점 baseline을
+// 반쪽만 갱신해 업데이트 판정을 흐리고, revert는 uninstall의 부분집합이었다.
 export const VALID_MODES = [
-  "interactive", "full", "version", "workflows",
-  "revert", "uninstall", "status", "doctor", "purge",
+  "interactive", "full",
+  "uninstall", "status", "doctor", "purge",
 ];
 
 export const DEFAULT_VERSION = "0.0.0"; // 패키지 버전 읽기 실패 시 폴백 (배너용 — breaking 비교엔 안 씀)

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,43 +222,52 @@ 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을 만든 뒤
 // 동기 엔진에 위임한다. WHY 분리: copyWorkflows를 async로 바꾸면 await 없이 호출하는
-// 기존 호출부(runFull/runWorkflows)가 깨진다 — 시그니처 무변경 원칙.
+// 기존 호출부(runFull)가 깨진다 — 시그니처 무변경 원칙.
 // onConflict 반환값: 'template' | 'skip' | 'backup' (그 외/미지정 → 'skip').
 export async function copyWorkflowsInteractive(context, payloadRoot, targetRoot = ".", { onConflict } = {}) {
   const decisions = new 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/{commands/revert.js → core/removal-plan.js}

@@ -1,4 +1,6 @@
-// revert 모드 — payload 유래 파일 + 마커로 식별되는 파일을 제거 (DESIGN-SPEC §4 되돌리기).
+// 제거 대상 판별기 — 마법사가 설치한 파일이 무엇인지 가려낸다.
+// uninstall(항목 체크리스트)과 purge(숨김 개발 모드)의 공통 기반이며, 아무것도 지우지 않는다.
+//
 // 원칙: (a) 현재 payload에 존재하는 파일명과 정확히 일치하는 것, (b) 설치된 워크플로우 파일 중
 // 마법사 관리 마커(MANAGED_WORKFLOW_MARKER)로 시작하는 것 — 이 둘의 합집합을 제거 대상으로 삼는다.
 // (a)만으로는 과거 버전에서 설치된 뒤 이후 릴리스에서 payload 파일명이 바뀌거나 삭제된 파일을
@@ -6,12 +8,15 @@
 // 없는(그러나 파일명은 여전히 현재 payload와 일치하는) 기존 설치 전체를 인식하지 못하는 회귀가
 // 생긴다 — 그래서 두 방식을 합집합으로 병행한다. 마커는 이 수정 이후 배포되는 payload 템플릿부터
 // 포함되므로, (b) 경로가 실제로 새로 잡아내는 것은 "이름이 바뀌거나 삭제된, 마커가 있는" 파일뿐이다.
-// 사용자가 직접 만든 워크플로우·version.yml·README·.gitignore는 건드리지 않는다
+// 사용자가 직접 만든 워크플로우·version.yml·README·.gitignore는 대상이 아니다
 // (version.yml은 사용자 버전 데이터 — 제거 대상이 아니라 산출물이다).
+//
+// 이 파일은 원래 src/commands/revert.js였다. revert 모드는 uninstall의 부분집합이라 제거됐고
+// (issue #70), 판별 로직만 남아 commands가 아닌 core로 옮겨졌다.
 import { join } from "node:path";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { PATHS, PAYLOAD } from "../core/paths.js";
-import { remove } from "../core/fsutil.js";
+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";
@@ -41,13 +46,13 @@ function markedWorkflowNames(wfDir) {
   return names;
 }
 
-// 아무것도 지우지 않는 순수 함수 — --dry-run과 status류 기능에서 재사용.
-export function planRevert(payloadRoot, targetRoot = ".") {
+// 아무것도 지우지 않는 순수 함수 — uninstall/purge/--dry-run이 공유한다.
+export function planRemoval(payloadRoot, targetRoot = ".") {
   const removedWf = new Set();
   const removedScripts = [];
   const wfDir = join(targetRoot, PATHS.workflowsDir);
   if (existsSync(wfDir)) {
-    // (a) 현재 payload와 파일명이 일치하는 것 — 기존 동작 그대로(마커 유무 무관, 기존 설치 회귀 방지).
+    // (a) 현재 payload와 파일명이 일치하는 것 — 마커 유무 무관(기존 설치 회귀 방지).
     for (const name of payloadWorkflowNames(payloadRoot)) {
       const p = join(wfDir, name);
       if (existsSync(p)) removedWf.add(name);
@@ -61,14 +66,8 @@ export function planRevert(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 };
-}
-
-// 반환: { workflows: [...제거된 파일명], scripts: [...] } — planRevert와 동일한 형태.
-export function runRevert(context, payloadRoot, targetRoot = ".") {
-  const plan = planRevert(payloadRoot, targetRoot);
-  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));
-  return plan;
+  // baseline은 마법사가 만든 내부 상태 파일이다 — 설치물을 지우면 함께 사라져야 한다.
+  // 남겨두면 다음 설치가 "예전에 깔았다가 사용자가 지운 파일"로 오인해 전부 removed로 분류한다.
+  const baseline = existsSync(join(targetRoot, BASELINE_PATH)) ? [BASELINE_DIR] : [];
+  return { workflows: [...removedWf], scripts: removedScripts, baseline };
 }

package/src/index.js

@@ -17,9 +17,6 @@ import { resolveBranchConfig, detectRemoteBranches, ensureDevelopBranch, default
 import { printBannerCompact } from "./ui/banner.js";
 import { printSummary } from "./ui/summary.js";
 import { runFull } from "./commands/full.js";
-import { runVersion } from "./commands/version.js";
-import { runWorkflows } from "./commands/workflows.js";
-import { runRevert } from "./commands/revert.js";
 import { runUninstall, runUninstallFlow } from "./commands/uninstall.js";
 import * as prompts from "./ui/prompts.js";
 import { runInteractive } from "./commands/interactive.js";
@@ -81,33 +78,16 @@ export async function run(argv, {
   if (opts.mode === "interactive") {
     // --dry-run은 대화형 모드에서 조용히 무시되면 안 됨(실제 설치가 진행돼버림) — 명시 에러로 차단.
     if (opts.dryRun) {
-      console.error("--dry-run은 --mode <full|version|workflows|revert|uninstall>와 함께 사용하세요 (대화형 모드에서는 지원하지 않습니다).");
+      console.error("--dry-run은 --mode <full|uninstall>와 함께 사용하세요 (대화형 모드에서는 지원하지 않습니다).");
       return 1;
     }
     if (!process.stdout.isTTY) {
-      console.error("대화형 입력이 불가능한 환경입니다. --mode <full|version|workflows|revert|uninstall> 와 --force 를 지정하세요.");
+      console.error("대화형 입력이 불가능한 환경입니다. --mode <full|uninstall> 와 --force 를 지정하세요.");
       return 1;
     }
     return await runInteractive({}, { cwd, payloadRoot: payload, clock });
   }
 
-  // revert 모드 — payload 유래 파일 제거 (감지·질문 불필요, --force 게이트만)
-  if (opts.mode === "revert") {
-    // TTY 여부와 무관하게 --force가 없으면 거부한다 (issue #19 — TTY에서 확인 없이 즉시 실행되던 결함 수정).
-    // --dry-run은 파일을 쓰지 않으므로 --force 게이트를 우회한다 (status/doctor와 동일한 안전성).
-    if (!opts.force && !opts.dryRun) {
-      console.error("revert 모드는 --force 없이 실행할 수 없습니다 (확인 절차가 없습니다).");
-      return 1;
-    }
-    if (opts.dryRun) {
-      printDryRun(planDryRun("revert", {}, payload, cwd));
-      return 0;
-    }
-    const r = runRevert({}, payload, cwd);
-    console.error(`제거됨 — 워크플로우 ${r.workflows.length}개, 스크립트 ${r.scripts.length}개`);
-    console.error("version.yml·README·.gitignore는 보존됩니다 (사용자 데이터).");
-    return 0;
-  }
   // purge 모드 — 마법사가 만든 모든 산출물을 지워 설치 이전 상태로 완전히 되돌린다.
   // 개발·테스트 전용 숨김 모드 — --help/대화형 메뉴에 노출하지 않는다 (issue #6).
   if (opts.mode === "purge") {
@@ -183,7 +163,7 @@ export async function run(argv, {
     return 0;
   }
 
-  // uninstall 모드 — revert보다 넓게 README·gitignore·version.yml까지 선택적으로 제거.
+  // uninstall 모드 — 설치물에 더해 README·gitignore·version.yml까지 선택적으로 제거.
   if (opts.mode === "uninstall") {
     const safeSelection = {
       workflows: true, scripts: true,
@@ -303,14 +283,10 @@ export async function run(argv, {
     return 0;
   }
 
-  // opts.mode는 parseArgs()에서 화이트리스트 검증을 통과했고, interactive/revert/purge/uninstall/status/doctor는
-  // 전부 위에서 조기 반환했으므로 이 시점엔 full/version/workflows 중 하나로 보장된다(issue #19 — default 분기 제거).
-  let result = null;
-  switch (opts.mode) {
-    case "full": result = runFull(context, payload, cwd); break;
-    case "version": result = runVersion(context, payload, cwd); break;
-    case "workflows": result = runWorkflows(context, payload, cwd); break;
-  }
+  // opts.mode는 parseArgs()에서 화이트리스트 검증을 통과했고, interactive/purge/uninstall/status/doctor는
+  // 전부 위에서 조기 반환했으므로 이 시점엔 full 하나로 보장된다 (issue #19 — default 분기 제거,
+  // issue #70 — 부분 설치 모드 제거로 분기 자체가 사라졌다).
+  const result = runFull(context, payload, cwd);
 
   // 완료 요약 (.sh print_summary — CLI 모드에서도 출력)
   printSummary({

package/src/ui/prompts.js

@@ -12,10 +12,7 @@ export async function selectMode({ again = false } = {}) {
   return engine.select({
     message: again ? "다음으로 무엇을 할까요?" : "무엇을 설치할까요?",
     options: [
-      { value: "full", label: "전체 설치 — 버전관리 + 자동화 워크플로우 (처음이라면 추천)" },
-      { value: "version", label: "버전 관리만 — 버전 자동 증가·동기화 시스템만 설치" },
-      { value: "workflows", label: "워크플로우만 — 빌드·배포 GitHub Actions만 설치" },
-      { value: "revert", label: "되돌리기 — 마법사가 설치한 워크플로우·스크립트 제거" },
+      { value: "full", label: "설치 / 업데이트 — 버전관리 + 자동화 워크플로우 (처음이라면 추천)" },
       { value: "uninstall", label: "완전 삭제 — 마법사가 설치·수정한 모든 항목 제거(확인 후, README·gitignore·version.yml 포함)" },
       { value: "status", label: "설치 상태 확인 — 읽기 전용, 버전·타입·드리프트 확인" },
       { value: "doctor", label: "환경 진단 — 읽기 전용, gh CLI·권한·secret 설정 점검" },

package/src/commands/version.js

@@ -1,37 +0,0 @@
-// version 모드 (.sh execute_integration version case 등가).
-// 순서: version.yml → readme → scripts.
-// (워크플로우를 복사하지 않으므로 충돌 백업 부산물이 생길 수 없다 — gitignore 갱신 대상 없음, issue #7.
-//  util·issue·setup-guide는 스코프 제외.)
-import { join } from "node:path";
-import { existsSync, readFileSync } from "node:fs";
-import { writeText } from "../core/fsutil.js";
-import { PATHS } from "../core/paths.js";
-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 { copyScripts } from "../core/copy/simple.js";
-
-export function runVersion(context, payloadRoot, targetRoot = ".") {
-  const { version, types = [], paths = new Map(), branch = "main", versionCode = 1,
-    now, today, templateVersion = "unknown",
-    includeNexus = false, includeSecretBackup = false,
-    includeSemverAuto } = context;
-
-  const pathMarkers = new Map();
-  for (const [t] of paths) pathMarkers.set(t, markerForType(t));
-
-  // 기존 version.yml의 알려지지 않은 최상위 필드를 재생성 시 보존한다 (issue #20 M8).
-  const vyPath = join(targetRoot, PATHS.versionFile);
-  const extraTopLevel = existsSync(vyPath) ? parseExisting(readFileSync(vyPath, "utf8")).extraTopLevel : [];
-
-  writeText(join(targetRoot, PATHS.versionFile),
-    buildVersionYml({
-      templateText: readVersionYmlTemplate(payloadRoot),
-      version, types, paths, pathMarkers, branch, branches: context.branches, versionCode, now, today,
-      extraTopLevel,
-      templateOptions: { templateVersion, includeNexus, includeSecretBackup, includeSemverAuto: includeSemverAuto !== false, optionsDate: today },
-    }));
-  addVersionSectionToReadme(version, targetRoot);
-  copyScripts(payloadRoot, targetRoot);
-}

package/src/commands/workflows.js

@@ -1,52 +0,0 @@
-// workflows 모드 (.sh execute_integration workflows case 등가).
-// 순서: copy_workflows → update_version_yml_deploy(version.yml 있을 때만) → scripts.
-// (version.yml 생성 안 함 — 기존 version.yml이 있을 때만 deploy 블록 추가.
-//  util/config/setup-guide 설치는 project-auto-wizard 스코프에서 제외 — DESIGN-SPEC §2)
-import { join } from "node:path";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { PATHS } from "../core/paths.js";
-import { copyWorkflows } from "../core/copy/workflows.js";
-import { copyScripts } from "../core/copy/simple.js";
-import { escapeYamlDoubleQuoted } from "../core/wizard-env.js";
-
-export function runWorkflows(context, payloadRoot, targetRoot = ".", hooks = {}) {
-  const wf = copyWorkflows(context, payloadRoot, targetRoot, hooks);
-
-  // update_version_yml_deploy: 기존 version.yml이 있고 ask 값이 있을 때만 deploy 블록 갱신
-  const vy = join(targetRoot, PATHS.versionFile);
-  if (existsSync(vy) && wf.deployValues && wf.deployValues.size) {
-    writeFileSync(vy, upsertDeployBlock(readFileSync(vy, "utf8"), wf.deployValues));
-  }
-
-  copyScripts(payloadRoot, targetRoot);
-  return { workflows: wf };
-}
-
-// 기존 version.yml에서 deploy: 블록을 제거하고 새로 append (.sh update_version_yml_deploy 멱등).
-export function upsertDeployBlock(content, deployValues) {
-  // 기존 deploy: 블록 제거 (deploy: 라인 ~ 다음 최상위 키 전까지)
-  const lines = content.split(/\r?\n/);
-  const out = [];
-  let inDeploy = false;
-  for (const line of lines) {
-    if (/^deploy:/.test(line)) { inDeploy = true; continue; }
-    if (inDeploy) {
-      if (/^\s/.test(line) || line === "") continue; // 들여쓰기/빈줄 = deploy 내부
-      inDeploy = false;
-    }
-    out.push(line);
-  }
-  let text = out.join("\n").replace(/\n+$/, "\n");
-  // 새 deploy 블록 append
-  const deployTypes = [...deployValues.keys()].filter((t) => deployValues.get(t)?.size);
-  if (deployTypes.length) {
-    text += `\ndeploy:                          # 마법사가 기억하는 배포 설정 (비민감 / 직접 수정 가능)\n`;
-    for (const t of deployTypes) {
-      text += `  ${t}:\n`;
-      // 동일한 이스케이프를 재사용 — deploy 값도 @wizard ask 값과 같은 경로로 들어오므로
-      // 큰따옴표가 섞이면 YAML이 깨진다 (issue #20 L9, 세 번째 지점).
-      for (const [k, v] of deployValues.get(t)) text += `    ${k}: "${escapeYamlDoubleQuoted(v)}"\n`;
-    }
-  }
-  return text;
-}