project-auto-wizard 0.13.3 → 0.14.0

package/src/core/flutter-options.js

@@ -1,14 +1,15 @@
-// Flutter 옵션 — 환경변수 방식·스토어 배포 대상·배포 모드의 단일 진실.
-// 스토어 배포 대상은 deploy-style.js(배포 방식)와 같은 구조 — 값 목록, 파일 필터, 선택 해제 정리 — 를 따른다.
+// Flutter options: single source of truth for the env-var mode, store deploy targets and deploy modes.
+// Store deploy targets follow the same structure as deploy-style.js (deploy style): value list, file filter, deselection cleanup.
 import { join } from "node:path";
 import { existsSync, readFileSync, renameSync, rmSync } from "node:fs";
 import { sha256 } from "./baseline.js";
+import { t } from "../i18n/index.js";
 
-// 환경변수 주입 방식. dart-define은 --dart-define-from-file, dotenv는 flutter_dotenv/envied용 .env 생성.
-// 둘을 동시에 쓰는 both는 만들지 않는다 — 환경변수를 두 곳에서 관리하게 되기 때문.
+// Env-var injection mode. dart-define uses --dart-define-from-file; dotenv generates the .env for flutter_dotenv/envied.
+// No "both" option that uses the two at once: it would mean managing env vars in two places.
 export const ENV_MODES = ["dart-define", "dotenv"];
-export const DEFAULT_ENV_MODE = "dart-define"; // 신규 설치 기본
-export const LEGACY_ENV_MODE = "dotenv";       // 기존 설치(version.yml 있음, 저장값 없음)가 조용히 깨지지 않도록 보존
+export const DEFAULT_ENV_MODE = "dart-define"; // default for new installs
+export const LEGACY_ENV_MODE = "dotenv";       // preserved so an existing install (has version.yml, no saved value) does not break silently
 
 export const STORE_PLATFORMS = ["android", "ios"];
 export const DEPLOY_MODES = ["store_only", "store_prepare", "store_submit"];
@@ -18,8 +19,8 @@ export const NO_STORE = "none";
 export const isEnvMode = (v) => ENV_MODES.includes(v);
 export const isDeployMode = (v) => DEPLOY_MODES.includes(v);
 
-// "android,ios" | "android" | "none" | "" → 배열. 항상 STORE_PLATFORMS 순서라 직렬화가 결정적이다.
-// 알 수 없는 토큰이 하나라도 있거나 문자열이 아니면 null — 호출부가 "값 없음/잘못된 값"으로 처리한다.
+// "android,ios" | "android" | "none" | "" to an array. Always in STORE_PLATFORMS order, so serialization is deterministic.
+// null when any token is unknown or the input is not a string; callers treat that as "no value / invalid value".
 export function parseStoreList(csv) {
   if (typeof csv !== "string") return null;
   const tokens = csv.split(",").map((t) => t.trim()).filter((t) => t !== "");
@@ -28,14 +29,14 @@ export function parseStoreList(csv) {
   return STORE_PLATFORMS.filter((p) => tokens.includes(p));
 }
 
-// 저장용 직렬화 — 빈 배열은 빈 문자열이 아니라 "none"으로 적어 "선택 안 함"과 "값 없음"을 구분한다.
+// Serialization for saving: an empty array is written as "none" rather than an empty string, to tell "nothing selected" from "no value".
 export function formatStoreList(stores) {
   const ordered = STORE_PLATFORMS.filter((p) => stores.includes(p));
   return ordered.length ? ordered.join(",") : NO_STORE;
 }
 
-// 플랫폼별 스토어 워크플로우 (payload/workflows/flutter/ 기준 파일명).
-// FIREBASE·SELFHOSTED·TEST-APK·APP-BUILD-TRIGGER·CI는 스토어와 무관해 여기 넣지 않는다 — 항상 설치된다.
+// Store workflows per platform (file names relative to payload/workflows/flutter/).
+// FIREBASE, SELFHOSTED, TEST-APK, APP-BUILD-TRIGGER and CI are unrelated to the stores and are not listed here: they are always installed.
 export const STORE_WORKFLOWS = {
   android: ["PROJECT-FLUTTER-ANDROID-PLAYSTORE-CICD.yaml"],
   ios: ["PROJECT-FLUTTER-IOS-TESTFLIGHT.yaml", "PROJECT-FLUTTER-IOS-TEST-TESTFLIGHT.yaml"],
@@ -43,20 +44,20 @@ export const STORE_WORKFLOWS = {
 
 export const isStoreWorkflow = (filename) => Object.values(STORE_WORKFLOWS).flat().includes(filename);
 
-// 파일 필터 — stores가 null이면 미결정이라 현행 동작(전부 설치)이다.
-// 배열이면 스토어 워크플로우는 선택된 플랫폼 것만 통과하고, 그 외 파일은 항상 통과한다.
+// File filter: null stores means undecided, which keeps current behavior (install everything).
+// With an array, store workflows pass only for the selected platforms and all other files always pass.
 export function storeWorkflowFilter(stores) {
   if (stores === null || stores === undefined) return () => true;
   const allowed = new Set(STORE_PLATFORMS.filter((p) => stores.includes(p)).flatMap((p) => STORE_WORKFLOWS[p]));
   return (filename) => !isStoreWorkflow(filename) || allowed.has(filename);
 }
 
-// 선택 해제한 스토어 워크플로우 정리 — cleanupOtherDeployWorkflows(deploy-style.js)와 같은 규칙이다.
-//   손대지 않은 것(baseline의 installed 해시와 동일) → 삭제
-//   손댄 것                                          → .bak으로 옮긴다 (내용 보존, 트리거만 죽인다)
-// 사용자 소유인 Fastfile·ExportOptions.plist는 여기서 다루지 않는다 (워크플로우 파일만 대상).
-// dryRun이면 판정만 하고 파일은 건드리지 않는다 (--dry-run 미리보기용).
-// 반환: { removed:[], backedUp:[] }
+// Cleanup of deselected store workflows: same rule as cleanupOtherDeployWorkflows (deploy-style.js).
+//   untouched (same as the baseline installed hash) -> deleted
+//   modified                                        -> moved to .bak (content kept, only the trigger is killed)
+// User-owned Fastfile and ExportOptions.plist are not handled here (workflow files only).
+// With dryRun only the decision is made and no files are touched (for the --dry-run preview).
+// Returns: { removed:[], backedUp:[] }
 export function cleanupDeselectedStoreWorkflows(workflowsDir, installedFilenames, stores, baseline, { dryRun = false } = {}) {
   const keep = storeWorkflowFilter(stores);
   const removed = [];
@@ -80,13 +81,13 @@ export function cleanupDeselectedStoreWorkflows(workflowsDir, installedFilenames
   return { removed, backedUp };
 }
 
-// 스토어 앱 파일 (payload/flutter-app/ 기준 상대경로) — 플랫폼별 묶음.
+// Store app files (paths relative to payload/flutter-app/), grouped per platform.
 export const STORE_APP_FILES = {
   android: ["android/fastlane/Fastfile.playstore"],
   ios: ["ios/fastlane/Fastfile", "ios/ExportOptions.plist"],
 };
 
-// 선택된 플랫폼의 앱 파일 목록. stores가 null이면 전부 (현행 동작 = 둘 다 설치).
+// App file list for the selected platforms. All of them when stores is null (current behavior = install both).
 export function storeAppFilesFor(stores) {
   const platforms = stores === null || stores === undefined
     ? STORE_PLATFORMS
@@ -94,24 +95,24 @@ export function storeAppFilesFor(stores) {
   return platforms.flatMap((p) => STORE_APP_FILES[p]);
 }
 
-// store_submit은 main push마다 심사를 제출하므로 고른 직후 한 줄로 알린다. 다른 모드는 알릴 것이 없어 빈 문자열.
+// store_submit submits a review on every main push, so a one-line notice is shown right after it is chosen. Other modes have nothing to announce, hence an empty string.
 export function deployModeWarning(mode) {
-  return mode === "store_submit" ? "store_submit을 고르면 main push마다 심사가 자동 제출됩니다." : "";
+  return mode === "store_submit" ? t("core.flutterOptions.storeSubmitWarning") : "";
 }
 
 const validOr = (isValid, value, fallback) => (isValid(value) ? value : fallback);
 
-// 옵션 최종 결정 — 우선순위: CLI > version.yml 저장값 > 기본값.
-//   cli      { envMode:"", stores:null|string[], androidDeployMode:"", iosDeployMode:"" } (빈값/null = 미지정)
-//   existing parseExisting() 결과 또는 null (version.yml이 없으면 신규 설치)
+// Final option decision. Priority: CLI > value saved in version.yml > default.
+//   cli      { envMode:"", stores:null|string[], androidDeployMode:"", iosDeployMode:"" } (empty/null = not given)
+//   existing parseExisting() result or null (no version.yml means a fresh install)
 //
-// - envMode 기본값: 신규 설치와 "Flutter를 새로 추가하는" 기존 설치는 dart-define, 이미 Flutter가
-//   설치돼 있던 프로젝트는 dotenv. 업데이트 한 번에 flutter_dotenv 프로젝트가 조용히 깨지지 않게
-//   하려는 것이라, 판단 기준은 "이 프로젝트에 Flutter가 이미 있었는가"다(단순 existing 존재 여부가
-//   아니다 — Spring 전용 프로젝트에 flutter 타입을 처음 추가하는 경우까지 dotenv로 묶으면 안 된다).
-// - stores: null은 "미결정" — 비대화형은 현행 동작(둘 다 설치), 대화형은 질문한다.
-// - 저장값은 유효할 때만 쓴다. version.yml은 사람이 고칠 수 있는데, 그 값이 워크플로우 표현식
-//   (`|| 'store_only'` 폴백 자리)에 그대로 들어가므로 목록 밖 문자열은 걸러야 한다.
+// - envMode default: fresh installs and existing installs that are "newly adding Flutter" get dart-define; projects
+//   that already had Flutter installed get dotenv. This keeps a single update from silently breaking a flutter_dotenv
+//   project, so the criterion is "did this project already have Flutter" (not merely whether existing is present:
+//   adding the flutter type for the first time to a Spring-only project must not be lumped into dotenv).
+// - stores: null means "undecided": non-interactive keeps current behavior (install both), interactive asks.
+// - Saved values are used only when valid. version.yml can be hand-edited and the value goes straight into a
+//   workflow expression (the `|| 'store_only'` fallback slot), so strings outside the list must be filtered out.
 export function resolveFlutterOptions({ cli = {}, existing = null } = {}) {
   const saved = existing?.options ?? {};
   const hadFlutterAlready = Array.isArray(existing?.types) && existing.types.includes("flutter");

package/src/core/fsutil.js

@@ -1,4 +1,4 @@
-// 파일시스템 공용 유틸 (LF 보존 바이트 복사). 텍스트는 그대로 복사해 원본 줄바꿈 유지.
+// Shared filesystem utilities (byte-for-byte copy, LF preserved). Text is copied as-is so original line endings survive.
 import {
   cpSync, existsSync, readFileSync, writeFileSync, mkdirSync,
   readdirSync, rmSync, accessSync, constants,
@@ -13,27 +13,27 @@ export function writeText(p, s) {
   writeFileSync(p, s);
 }
 
-// 단일 파일 복사 (부모 디렉토리 자동 생성, 바이트 그대로)
+// Copy a single file (creates parent directories, bytes unchanged)
 export function copyFileSync(src, dst) {
   mkdirSync(dirname(dst), { recursive: true });
   cpSync(src, dst);
 }
 
-// 디렉토리 재귀 복사 (내용을 dst 하위로)
+// Recursively copy a directory (contents go under dst)
 export function copyDirSync(src, dst) {
   mkdirSync(dst, { recursive: true });
   cpSync(src, dst, { recursive: true });
 }
 
-// 파일/폴더 삭제 (없어도 무해)
+// Delete a file/folder (harmless if missing)
 export function remove(p) {
   rmSync(p, { recursive: true, force: true });
 }
 
-// 디렉토리 직하위 .yaml/.yml 파일명 목록. 하위 폴더 제외.
-// 정렬 순서는 고정한다: 확장자로 1차 그룹(.yaml 먼저 → .yml 나중), 각 그룹 안에서 알파벳순.
-// (단순 .sort()는 확장자를 섞어 정렬해 기존 설치와 파일 순회 순서가 갈리고,
-//  그 결과 version.yml deploy 블록의 키 순서까지 달라진다. 확장자 그룹핑으로 재실행 결과를 바이트 단위로 유지.)
+// Names of the .yaml/.yml files directly inside a directory (subfolders excluded).
+// Sort order is fixed: grouped by extension first (.yaml before .yml), alphabetical within each group.
+// (A plain .sort() mixes extensions, so the traversal order diverges from existing installs and
+//  the key order of the version.yml deploy block changes with it. Grouping keeps re-runs byte-identical.)
 export function listYamlFiles(dir) {
   if (!existsSync(dir)) return [];
   const names = readdirSync(dir, { withFileTypes: true })
@@ -44,10 +44,10 @@ export function listYamlFiles(dir) {
   return [...yaml, ...yml];
 }
 
-// 쓰기 전에 권한을 미리 확인한다 — 중간에 EACCES로 멈추면 일부만 설치된 상태가 남고,
-// 다음 실행에서는 기준점(baseline)이 없어 이미 쓴 파일이 전부 충돌로 분류된다.
-// dirs: 파일을 만들 폴더(없으면 만들어질 가장 가까운 상위 폴더를 본다), files: 이미 있으면 덮어쓸 파일.
-// 반환: 쓸 수 없는 경로(root 기준 상대경로) 목록.
+// Check permissions before writing - stopping midway on EACCES leaves a partial install, and the
+// next run has no baseline, so every file already written would be classified as a conflict.
+// dirs: folders to create files in (if missing, the nearest existing ancestor is checked), files: existing files to be overwritten.
+// Returns the list of unwritable paths (relative to root).
 export function findUnwritable(root, dirs = [], files = []) {
   const writable = (p) => { try { accessSync(p, constants.W_OK); return true; } catch { return false; } };
   const blocked = new Set();

package/src/core/installed-stores.js

@@ -1,10 +1,10 @@
-// 이미 설치된 스토어 배포 워크플로우 파일명으로 플랫폼을 추론한다.
-// version.yml에 flutter_store 저장값이 없는 기존 설치가 대상이다 — 저장값이 없다고 "선택 없음"으로 보면
-// 잘 쓰던 스토어 워크플로우가 선택 해제 정리 규칙에 의해 삭제된다.
+// Infers platforms from the file names of already-installed store deploy workflows.
+// Targets existing installs whose version.yml has no flutter_store value: treating a missing value as "nothing
+// selected" would make the deselection cleanup rule delete store workflows that were working fine.
 import { existsSync, readdirSync } from "node:fs";
 import { STORE_PLATFORMS, STORE_WORKFLOWS } from "./flutter-options.js";
 
-// 반환: 스토어 워크플로우가 하나라도 설치된 플랫폼 (STORE_PLATFORMS 순서).
+// Returns the platforms with at least one store workflow installed (in STORE_PLATFORMS order).
 export function inferInstalledStores(workflowsDir) {
   if (!existsSync(workflowsDir)) return [];
   const installed = new Set(readdirSync(workflowsDir));

package/src/core/logger.js

@@ -1,45 +1,46 @@
-// 실행 추적 로그 — "무엇을 어떤 순서로 왜 그렇게 했는지"를 시간순으로 남긴다.
+// Execution trace log - records "what was done, in what order, and why" chronologically.
 //
-// 왜 즉시 append인가: 디버깅에서 가장 알고 싶은 순간은 크래시 직전이다. 끝나고 한 번에
-// 쓰는 구조는 예외가 나면 아무것도 남기지 못한다(구 install-log.js가 그랬다).
+// Why append immediately: the moment you most want to see when debugging is right before a crash.
+// A structure that writes everything at the end leaves nothing if an exception is thrown (the old install-log.js did).
 //
-// 왜 로컬 전용인가: 상세도를 제약하지 않기 위해서다. 로그 디렉토리에 .gitignore를 직접
-// 두어 그 폴더만 추적에서 뺀다 — 루트 .gitignore는 건드리지 않는다.
+// Why local-only: so the level of detail is not constrained. A .gitignore placed inside the log
+// directory takes only that folder out of tracking - the root .gitignore is left alone.
 import { appendFileSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { t } from "../i18n/index.js";
 
 export const LOG_DIR = ".github/.wizard/logs";
-const KEEP = 20;              // 유지할 로그 파일 수
+const KEEP = 20;              // number of log files to keep
 const GITIGNORE_BODY = "*\n!.gitignore\n";
 
-// 값에 비밀이 들어갈 수 있는 키 — 현재 질문 항목에는 없지만(도메인·경로·포트·인증 '방식'),
-// 앞으로 추가될 때 그냥 평문으로 남지 않도록 처음부터 걸어둔다.
+// Keys whose values may hold secrets - none of the current prompts do (domain, path, port, auth 'method'),
+// but this is in place from the start so future additions are not logged in plain text.
 const SECRET_KEY_RE = /(PASSWORD|SECRET|TOKEN|KEY|CREDENTIAL)/i;
 const MASK = "***";
 
 let state = null; // { targetRoot, name, header, file, rel, clock, startedAt, disabled }
 
 export function maskValue(key, value) {
-  // SSH_AUTH_METHOD처럼 "방식"만 담는 키는 비밀이 아니다 — 이름에 KEY가 들어가도 마스킹하지 않는다.
+  // Keys like SSH_AUTH_METHOD hold only a "method", not a secret - not masked even though the name contains KEY.
   if (key === "SSH_AUTH_METHOD") return value;
   return SECRET_KEY_RE.test(key) ? MASK : value;
 }
 
-// "2026-08-26 12:03:41" → "20260826-120341". 파일명이 곧 정렬 키가 되도록.
+// "2026-08-26 12:03:41" -> "20260826-120341", so the filename doubles as the sort key.
 export function stampFrom(now = "") {
   const m = String(now).match(/(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})/);
   if (!m) return "unknown";
   return `${m[1]}${m[2]}${m[3]}-${m[4]}${m[5]}${m[6]}`;
 }
 
-// 초 단위 이름만 쓰면 같은 초에 연달아 실행할 때 앞 실행의 로그를 덮어쓴다 — 밀리초를 붙인다.
-// 밀리초도 시각 순서라 이름 정렬이 곧 실행 순서라는 전제(rotate)는 그대로 유지된다.
+// A seconds-only name would overwrite the previous run's log when runs follow within the same second - milliseconds are appended.
+// Milliseconds are also in time order, so the premise that name order equals run order (rotate) still holds.
 export function logFilename(now, action = "install", ms = 0) {
   return `${stampFrom(now)}-${String(ms).padStart(3, "0")}-${action}.log`;
 }
 
-// 같은 이름이 이미 있으면(다른 프로세스가 같은 밀리초에 연 경우) -2, -3을 붙여 새로 만든다.
-// wx 플래그로 "없을 때만 생성"을 원자적으로 판정해 동시 실행끼리도 서로 덮어쓰지 않는다.
+// If the name already exists (another process opened one in the same millisecond), -2, -3 is appended for a new file.
+// The wx flag decides "create only if absent" atomically, so concurrent runs never overwrite each other.
 function createUnique(dir, base, header) {
   const stem = base.replace(/\.log$/, "");
   for (let n = 1; n < 100; n++) {
@@ -51,11 +52,11 @@ function createUnique(dir, base, header) {
       if (e.code !== "EEXIST") throw e;
     }
   }
-  throw new Error(`로그 파일 이름이 모두 사용 중입니다: ${base}`);
+  throw new Error(t("core.logger.error.nameExhausted", { base }));
 }
 
-// 최근 KEEP개만 남기고 오래된 것부터 지운다. 파일명이 시각 오름차순이라 이름 정렬로 충분하다.
-// 새 파일이 곧 하나 추가되므로 KEEP-1개까지 줄인다.
+// Keep only the latest KEEP files, deleting the oldest first. Filenames ascend by time, so name sorting is enough.
+// A new file is about to be added, so trim down to KEEP-1.
 function rotate(dir) {
   const logs = readdirSync(dir).filter((f) => f.endsWith(".log")).sort();
   for (const f of logs.slice(0, Math.max(0, logs.length - (KEEP - 1)))) {
@@ -63,12 +64,12 @@ function rotate(dir) {
   }
 }
 
-// 파일은 첫 기록 때 만든다 — 읽기 전용 모드(status/doctor)나 인자 검증에서 거부된 실행처럼
-// 아무것도 바꾸지 않은 실행이 대상 레포에 로그 폴더와 헤더만 있는 파일을 남기지 않도록.
+// The file is created on the first record - so runs that change nothing (read-only modes like status/doctor,
+// or runs rejected during argument validation) do not leave a log folder and a header-only file in the target repo.
 export function initLogger(targetRoot, opts = {}) {
   const { action = "install", now = "", argv = [], templateVersion = "unknown", clock = () => new Date(),
     ms = new Date().getUTCMilliseconds() } = opts;
-  // 시각은 UTC다 — 로컬 시간대로 읽으면 몇 시간 어긋나 보이므로 헤더에 밝혀 둔다.
+  // Times are UTC - reading them as local time looks off by hours, so the header says so.
   const header =
     `=== project-auto-wizard v${templateVersion} | ${action} | ${now} UTC ===\n` +
     `argv    : ${["project-auto-wizard", ...argv].join(" ")}\n` +
@@ -79,12 +80,12 @@ export function initLogger(targetRoot, opts = {}) {
   return { get path() { return st.rel; } };
 }
 
-// 첫 기록 직전에 로그 파일을 연다. 실패하면 이후 기록을 끈다.
+// Opens the log file just before the first record. On failure, later records are turned off.
 function open(st) {
   try {
     const dir = join(st.targetRoot, LOG_DIR);
     mkdirSync(dir, { recursive: true });
-    // 사용자가 직접 둔 .gitignore가 있으면 존중한다.
+    // Respect a .gitignore the user placed themselves.
     const gi = join(dir, ".gitignore");
     if (!existsSync(gi)) writeFileSync(gi, GITIGNORE_BODY);
     rotate(dir);
@@ -92,9 +93,9 @@ function open(st) {
     st.file = join(st.targetRoot, st.rel);
     return true;
   } catch (e) {
-    // 로그를 못 남긴 것이 설치를 되돌릴 이유는 아니다 — 다만 조용히 삼키지는 않는다.
+    // Failing to write the log is no reason to roll back the install - but it is not swallowed silently either.
     st.disabled = true;
-    process.stderr.write(`[warn] 실행 로그를 시작하지 못했습니다: ${e.message}\n`);
+    process.stderr.write(`[warn] ${t("core.logger.warn.startFailed", { message: e.message })}\n`);
     return false;
   }
 }
@@ -103,13 +104,13 @@ export function resetLogger() {
   state = null;
 }
 
-// 이번 실행의 로그 경로(레포 상대). 설치 요약 화면이 사용자에게 안내할 때 쓴다.
+// Log path of this run (repo-relative). Used by the install summary screen to tell the user.
 export function currentLogPath() {
   return state && !state.disabled ? state.rel : "";
 }
 
-// 구버전(.md) 설치 기록이 남아 있는지 — .gitignore는 이미 git이 추적 중인 파일에는
-// 영향이 없으므로, 있으면 사용자가 직접 추적을 끊도록 안내해야 한다.
+// Whether old-format (.md) install records remain - .gitignore has no effect on files git already
+// tracks, so if any exist the user must be told to untrack them manually.
 export function hasLegacyMdLogs(targetRoot) {
   try {
     const dir = join(targetRoot, LOG_DIR);
@@ -117,16 +118,16 @@ export function hasLegacyMdLogs(targetRoot) {
   } catch { return false; }
 }
 
-// 열 너비 — 사람이 훑을 때 컬럼이 맞고, 에이전트가 컬럼 단위로 끊어 읽을 수 있게 고정한다.
-const SCOPE_W = 8;  // 가장 긴 scope('baseline')에 맞춘다 — 컬럼이 밀리면 훑기가 나빠진다
+// Column widths - fixed so columns line up when skimmed and can be split by column when parsed.
+const SCOPE_W = 8;  // fits the longest scope ('baseline') - misaligned columns make skimming worse
 const ACTION_W = 10;
 
-// 동아시아 전각 문자는 폭 2로 센다 (요약 블록 정렬용).
+// East Asian full-width characters count as width 2 (for aligning the summary block).
 const WIDE_RE = /[\u1100-\u115F\u2E80-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE6F\uFF00-\uFF60\uFFE0-\uFFE6]/;
 const dispWidth = (s) => [...String(s)].reduce((n, c) => n + (WIDE_RE.test(c) ? 2 : 1), 0);
 
-// 헤더의 실행 시각과 파일명이 UTC 기준(utcNow)이므로 라인 시각도 UTC로 맞춘다 —
-// 로컬 시간을 쓰면 같은 파일 안에서 헤더와 라인이 시간대만큼 어긋난다.
+// The header's run time and the filename are UTC (utcNow), so line times are UTC too -
+// local time would put the header and lines off by the timezone offset within the same file.
 function hhmmss(date) {
   const p = (n, w = 2) => String(n).padStart(w, "0");
   return `${p(date.getUTCHours())}:${p(date.getUTCMinutes())}:${p(date.getUTCSeconds())}.${p(date.getUTCMilliseconds(), 3)}`;
@@ -139,9 +140,9 @@ function write(level, scope, action, detail = "") {
     const line = `${hhmmss(state.clock())} ${level}  ${String(scope).padEnd(SCOPE_W)}  ${String(action).padEnd(ACTION_W)}  ${detail}`.trimEnd();
     appendFileSync(state.file, line + "\n");
   } catch (e) {
-    // 첫 실패에서 한 번만 알리고 이후는 조용히 끈다 — 매 줄 경고를 뱉으면 설치 화면이 무너진다.
+    // Report only on the first failure, then quietly turn off - a warning on every line would wreck the install screen.
     state.disabled = true;
-    process.stderr.write(`[warn] 실행 로그 기록을 중단합니다: ${e.message}\n`);
+    process.stderr.write(`[warn] ${t("core.logger.warn.writeStopped", { message: e.message })}\n`);
   }
 }
 
@@ -149,24 +150,25 @@ export const log = {
   info: (scope, action, detail) => write("INFO", scope, action, detail),
   warn: (scope, action, detail) => write("WARN", scope, action, detail),
   fail: (scope, action, detail) => write("FAIL", scope, action, detail),
-  // rows: Array<[label, value]> — 라벨 폭을 맞춰 정렬한다.
+  // rows: Array<[label, value]> - labels are padded to align.
   summary(rows = []) {
     if (!state || state.disabled || !rows.length) return;
     if (!state.file && !open(state)) return;
-    // 한글은 터미널에서 2칸을 차지한다 — 문자 수로 맞추면 눈으로 볼 때 어긋난다.
+    // Hangul takes 2 cells in a terminal - padding by character count looks misaligned.
     const w = Math.max(...rows.map(([k]) => dispWidth(k)));
     const body = rows.map(([k, v]) => `${k}${" ".repeat(w - dispWidth(k))} : ${v}`).join("\n");
     try {
-      appendFileSync(state.file, `\n=== 요약 ===\n${body}\n`);
+      appendFileSync(state.file, `\n${t("core.logger.summary.title")}\n${body}\n`);
     } catch {
       state.disabled = true;
     }
   },
 };
 
-// 로그 폴더(.github/.wizard)째 지울 수 있는 삭제 실행용. 지우기 전에 쓰면 기록이 함께 사라지며
-// ENOENT 경고가 나고, 지운 뒤에 쓰면 폴더를 되살려 완전 삭제 뒤에도 흔적이 남는다.
-// 그래서 기록을 모았다가 폴더가 남아 있을 때만 쓴다(지워졌다면 결과는 화면 출력으로 대신한다).
+// For removal runs that may delete the log folder (.github/.wizard) itself. Writing before the delete
+// loses the records along with it and raises an ENOENT warning, and writing after would resurrect the folder,
+// leaving a trace even after a full removal. So records are collected and written only if the folder survives
+// (if it is gone, the result is shown on screen instead).
 export function logRemovals(targetRoot, entries = []) {
   if (!existsSync(dirname(join(targetRoot, LOG_DIR)))) return;
   for (const [scope, action, detail] of entries) write("INFO", scope, action, detail);