project-auto-wizard 0.16.0 → 0.16.2

package/src/commands/status.js

@@ -1,7 +1,7 @@
 // status command: read-only install state check. No network access (local file comparison only).
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { parseExisting, droppedPathLines } from "../core/version-yml.js";
+import { parseExisting, droppedPathLines, invalidOptionLines } from "../core/version-yml.js";
 import { OPTIONS } from "../core/options.js";
 import { planWorkflows } from "../core/copy/workflows.js";
 import { makeResolvers, detectRepoName, detectDefaultBranch } from "../core/detect-fs.js";
@@ -47,6 +47,7 @@ export function runStatus(payloadRoot, targetRoot = ".") {
     types: existing.types,
     branches: existing.branches,
     options: existing.options,
+    invalidOptions: existing.invalidOptions,
     // Files the user touched = real conflicts (changed) + upstream unchanged but locally edited (localOnly).
     // Without a baseline localOnly is always empty, so behavior is the same as before.
     modifiedFiles: [...plan.changed, ...plan.localOnly].map((f) => f.filename),
@@ -79,7 +80,13 @@ export function printStatus(status) {
   }
   // An unset option is shown with the value it resolves to on this (existing) install, i.e. its legacyDefault.
   const unsetLabel = (o) => t(o.legacyDefault ? "cmd.status.unsetDefaultTrue" : "cmd.status.unsetDefaultFalse");
-  const optionLabels = OPTIONS.map((o) => `${o.key}=${status.options[o.name] ?? unsetLabel(o)}`).join(" ");
+  // A key written with an unrecognized value reads as false; show that instead of pretending the file is fine.
+  const invalidByKey = new Map((status.invalidOptions || []).map((i) => [i.key, i.value]));
+  const optionLabel = (o) => {
+    if (invalidByKey.has(o.key)) return `${o.key}=${status.options[o.name]} (${t("cmd.status.invalidValue", { value: invalidByKey.get(o.key) })})`;
+    return `${o.key}=${status.options[o.name] ?? unsetLabel(o)}`;
+  };
+  const optionLabels = OPTIONS.map(optionLabel).join(" ");
   const typeLabels = hooksFor(status.types, "statusLabels").map(({ hook }) => hook(status.options)).join("");
   const deployLabel = status.options.deployStyle ? ` deploy_style=${status.options.deployStyle}` : "";
   lines.push(t("cmd.status.options", { value: `${optionLabels}${deployLabel}${typeLabels}` }));

package/src/core/copy/gitignore.js

@@ -43,7 +43,7 @@ const newFileContent = (lang) =>
   "*.template.yaml\n";
 // The header comment depends on the language it was written in, so a file created in one language must
 // still be recognized under another: check every supported language's variant.
-const NEW_FILE_CONTENT = () => newFileContent(undefined);
+const NEW_FILE_CONTENT = (lang) => newFileContent(lang);
 const matchingNewFileContent = (content) =>
   [NEW_FILE_CONTENT(), ...SUPPORTED_LANGUAGES.map(newFileContent)].find((c) => content.startsWith(c)) ?? null;
 
@@ -57,11 +57,11 @@ export function planGitignore(targetRoot = ".") {
 }
 
 // Returns: {created, added:[...]}
-export function ensureGitignore(targetRoot = ".") {
+export function ensureGitignore(targetRoot = ".", lang) {
   const p = join(targetRoot, ".gitignore");
   const plan = planGitignore(targetRoot);
   if (plan.created) {
-    writeFileSync(p, NEW_FILE_CONTENT());
+    writeFileSync(p, NEW_FILE_CONTENT(lang));
     return plan;
   }
   const toAdd = plan.added;

package/src/core/copy/readme.js

@@ -30,9 +30,9 @@ const historyLink = (lang) => t("copy.readme.historyLink", {}, lang);
 // default is replaced: a heading or link the user edited is left alone, and so is anything not directly
 // under the marker (code-block examples, a README without the marker).
 // Returns the new content, or null when nothing needs to change.
-function refreshBlockLanguage(content) {
-  const currentHeading = defaultHeading();
-  const currentLink = historyLink();
+function refreshBlockLanguage(content, lang) {
+  const currentHeading = defaultHeading(lang);
+  const currentLink = historyLink(lang);
   const markerRe = new RegExp("^" + escapeRe(MARKER_LINE.trimEnd()) + "[ \\t]*\\r?\\n", "gm");
   let out = "";
   let last = 0;
@@ -70,22 +70,23 @@ function refreshBlockLanguage(content) {
 // Skip when README.md is missing, or when a marker or version line exists. Otherwise append to the end.
 // Returns: 'skip-no-readme' | 'heading-updated' | 'skip-marker' | 'skip-version-line' | 'added'
 // Only decides without writing, so the real append and the --dry-run preview share one decision.
-export function planVersionSection(targetRoot = ".") {
+// lang: the language recorded in version.yml for this install (not necessarily the language of this run's output)
+export function planVersionSection(targetRoot = ".", lang) {
   const p = join(targetRoot, "README.md");
   if (!existsSync(p)) return "skip-no-readme";
   const content = readFileSync(p, "utf8");
-  if (refreshBlockLanguage(content) !== null) return "heading-updated";
+  if (refreshBlockLanguage(content, lang) !== null) return "heading-updated";
   if (content.includes(MARKER)) return "skip-marker";
   if (VERSION_LINE_RE.test(content)) return "skip-version-line";
   return "added";
 }
 
-export function addVersionSectionToReadme(version, targetRoot = ".") {
-  const status = planVersionSection(targetRoot);
+export function addVersionSectionToReadme(version, targetRoot = ".", lang) {
+  const status = planVersionSection(targetRoot, lang);
   const p = join(targetRoot, "README.md");
   if (status === "heading-updated") {
     // Swap only the bundled default wording; version text after the colon stays as the workflow wrote it.
-    writeFileSync(p, refreshBlockLanguage(readFileSync(p, "utf8")));
+    writeFileSync(p, refreshBlockLanguage(readFileSync(p, "utf8"), lang));
     return status;
   }
   if (status !== "added") return status;
@@ -97,9 +98,9 @@ export function addVersionSectionToReadme(version, targetRoot = ".") {
     "---\n" +
     "\n" +
     "<!-- AUTO-VERSION-SECTION: DO NOT EDIT MANUALLY -->\n" +
-    t("copy.readme.versionHeading", { version }) + "\n" +
+    t("copy.readme.versionHeading", { version }, lang) + "\n" +
     "\n" +
-    t("copy.readme.historyLink") + "\n";
+    t("copy.readme.historyLink", {}, lang) + "\n";
   // Appending directly to a README without a trailing newline puts "---" right after the last line,
   // and Markdown turns that line into a heading (Setext h2), so terminate the line first.
   const lead = content.length > 0 && !content.endsWith("\n") ? "\n" : "";

package/src/core/detect-fs.js

@@ -39,11 +39,16 @@ export function detectTypes(root, { paths = new Map(), warn } = {}) {
   if (fromRoot.length === 1 && fromRoot[0] === "basic" && warn) {
     const found = findSubdirProjects(root);
     if (found.length) {
-      const firstDir = new Map();
-      for (const { dir, types } of found) for (const t of types) if (!firstDir.has(t)) firstDir.set(t, dir);
+      // Only one folder per type is managed and the hint names the first one, so say which folders of the same type are left out
+      const dirsByType = new Map();
+      for (const { dir, types } of found) for (const t of types) dirsByType.set(t, [...(dirsByType.get(t) || []), dir]);
       const list = found.map(({ dir, types }) => `${dir}(${types.join(", ")})`).join(", ");
-      const hint = [...firstDir].map(([t, d]) => `${t}=${d}`).join(",");
-      warn(tr("core.detectFs.monorepoWarn", { list, hint }));
+      const hint = [...dirsByType].map(([t, dirs]) => `${t}=${dirs[0]}`).join(",");
+      const dropped = [...dirsByType].filter(([, dirs]) => dirs.length > 1).flatMap(([type, [kept, ...rest]]) => [
+        tr("core.detectFs.monorepoDropped", { type, kept, lost: rest.join(", ") }),
+        ...rest.map((path) => tr("core.versionYml.pathMergedHint", { type, path })),
+      ]);
+      warn([tr("core.detectFs.monorepoWarn", { list, hint }), ...dropped.map((l) => `   ${l}`)].join("\n"));
     }
   }
   return fromRoot;

package/src/core/options.js

@@ -11,6 +11,10 @@
 // logLabel      : label used by the install log line ("option <logLabel> on|off")
 // ask           : present only for options the interactive wizard asks about / lists in the edit menu
 //   { questionKey, initial, menuLabelKey, summaryKey, cardIcon, cardLabelKey } (all i18n keys except initial/cardIcon)
+// doctor       : present only for options that get an info item in `doctor`
+//   { prefix, always, notes } - `<prefix>.name` / `<prefix>.purpose` label the item; `always` shows it even without an install
+//   (otherwise it is left out, since there is no saved value to report); `notes` maps the saved value ("true" | "false" | "null")
+//   to the `<prefix>.<key>` messages to print, plus an optional `invalid` list (its messages get {value}) that turns the item into a warning
 // Keys only - this module never imports the i18n layer, so core stays free of UI dependencies.
 export const OPTIONS = Object.freeze([
   {
@@ -27,6 +31,14 @@ export const OPTIONS = Object.freeze([
     key: "copilot_ai", name: "copilotAi", ctxField: "includeCopilotAi",
     flag: "copilot", default: false, legacyDefault: false,
     conflictKey: "cli.args.copilotConflict", logLabel: "copilot",
+    doctor: {
+      prefix: "cmd.doctor.copilot", always: true,
+      notes: {
+        true: ["on", "creditsOn", "fallback"],
+        false: ["off", "creditsOff", "fallback"],
+        null: ["default", "creditsOff", "fallback"],
+      },
+    },
     ask: {
       questionKey: "interactive.question.copilotAi", initial: false,
       menuLabelKey: "ui.prompts.edit.copilotAi", summaryKey: "interactive.summary.copilotAi",
@@ -38,11 +50,35 @@ export const OPTIONS = Object.freeze([
     key: "release_automerge", name: "releaseAutomerge", ctxField: "includeReleaseAutomerge",
     flag: "release-automerge", default: true, legacyDefault: true,
     conflictKey: "cli.args.releaseAutomergeConflict", logLabel: "release-automerge",
+    doctor: {
+      prefix: "cmd.doctor.automerge", always: false,
+      notes: {
+        // A missing key also means on (installs from before the option existed already automerge)
+        true: ["on", "onHow"], false: ["off", "offHow"], null: ["on", "onHow"],
+        invalid: ["invalid", "invalidHow"],
+      },
+    },
   },
 ]);
 
 export const optionByKey = (key) => OPTIONS.find((o) => o.key === key);
 
+// The one rule for reading a boolean option value written in version.yml. The installed workflows read the same
+// value through version_manager.py (`option` command); tests/fixtures/option-value-cases.json runs both readers.
+//   - an inline comment (whitespace + #) is dropped, then one pair of matching quotes, then case is ignored
+//   - only true / false are recognized; anything else (yes, off, 0, maybe, empty, null) returns null
+// A key that is present with an unrecognized value is NOT the same as a missing key: callers treat it as false (the
+// conservative side - nothing is switched on or merged by itself) and report it, instead of guessing the intent.
+export function parseOptionValue(raw) {
+  let v = String(raw ?? "").replace(/(^|\s)#.*$/, "").trim();
+  const quoted = v.match(/^(["'])(.*)\1$/);
+  if (quoted) v = quoted[2].trim();
+  v = v.toLowerCase();
+  if (v === "true") return true;
+  if (v === "false") return false;
+  return null;
+}
+
 // version.yml template variable name, e.g. semver_auto -> OPT_SEMVER_AUTO
 export const optionVar = (o) => `OPT_${o.key.toUpperCase()}`;
 

package/src/core/version-yml.js

@@ -1,5 +1,5 @@
 import { DEFAULT_DEPLOY_STYLE } from "./deploy-style.js";
-import { OPTIONS, optionVar, renderValues } from "./options.js";
+import { OPTIONS, optionVar, renderValues, parseOptionValue } from "./options.js";
 import { escapeYamlDoubleQuoted } from "./wizard-env.js";
 import { hooksFor, mergeHookResults, allHookValues, canonicalTypeId, canonicalTypeIds } from "./types.js";
 import { normalizePath } from "./paths.js";
@@ -43,14 +43,17 @@ export function parseExtraTopLevel(content) {
 // Type-specific option key -> returned field (type hook savedOptionKeys). The value is returned as the raw string; validity is up to the type hook's resolveOptions.
 const TYPE_OPTION_KEYS = allHookValues("savedOptionKeys");
 const OPTION_BY_KEY = new Map(OPTIONS.map((o) => [o.key, o]));
-const OPTION_LINE = new RegExp(`^\\s+(${OPTIONS.map((o) => o.key).join("|")}):\\s*(.+)`);
+// (.*) on purpose: a key with an empty value is still a written value (an unrecognized one), not a missing key.
+const OPTION_LINE = new RegExp(`^\\s+(${OPTIONS.map((o) => o.key).join("|")}):\\s*(.*)`);
 const TYPE_OPTION_LINE = new RegExp(`^\\s+(${Object.keys(TYPE_OPTION_KEYS).join("|")}):\\s*(.+)`);
 
 // State-machine parse of metadata.template.options.
 // Returns: { <one bool|null per registry option, e.g. semverAuto/copilotAi>, deployStyle: string|null,
 //         type-specific option fields (e.g. envMode/flutterStore/androidDeployMode/iosDeployMode): string|null } - null = not written.
 // Other keys such as the old synology/coderabbit ones hit no branch and are naturally ignored (no parse error).
-export function parseTemplateOptions(content) {
+// invalid (optional out array): receives { key, value } for every option key whose written value was not recognized.
+export function parseTemplateOptions(content, invalid = []) {
+  const seen = new Set();
   const out = {
     ...Object.fromEntries(OPTIONS.map((o) => [o.name, null])), deployStyle: null,
     ...Object.fromEntries(Object.values(TYPE_OPTION_KEYS).map((field) => [field, null])),
@@ -69,12 +72,18 @@ export function parseTemplateOptions(content) {
       if (m) { const v = strip(m[1]); if (v) out.deployStyle = v; continue; }
       m = line.match(TYPE_OPTION_LINE);
       if (m) { const v = strip(m[2]); if (v) out[TYPE_OPTION_KEYS[m[1]]] = v; continue; }
-      // Boolean options come from the registry; a value other than true/false is left null (= not written).
+      // Boolean options come from the registry and are read with parseOptionValue (same rule as the workflows).
+      // The first occurrence wins, like the workflow reader. An unrecognized value reads as false and is reported
+      // through `invalid`, so it can never turn an option on (or release_automerge back on) without a word.
       const optionLine = line.match(OPTION_LINE);
       if (optionLine) {
-        const v = strip(optionLine[2]);
-        if (v === "true") out[OPTION_BY_KEY.get(optionLine[1]).name] = true;
-        if (v === "false") out[OPTION_BY_KEY.get(optionLine[1]).name] = false;
+        const name = OPTION_BY_KEY.get(optionLine[1]).name;
+        if (!seen.has(name)) {
+          seen.add(name);
+          const parsed = parseOptionValue(optionLine[2]);
+          out[name] = parsed ?? false;
+          if (parsed === null) invalid.push({ key: optionLine[1], value: optionLine[2].replace(/\r$/, "").trim() });
+        }
         continue;
       }
       // another key indented 0-4 spaces -> end of the options section
@@ -101,6 +110,11 @@ export function droppedPathLines(droppedPaths = [], finalPaths = null) {
   });
 }
 
+// Warning lines for option values that were written but not recognized (they read as false); empty when all are fine.
+export function invalidOptionLines(invalidOptions = []) {
+  return invalidOptions.map((o) => tr("core.versionYml.optionInvalid", { key: o.key, value: o.value }));
+}
+
 // Extract values from an existing version.yml (line-based, avoids false hits on comment lines).
 export function parseExisting(content) {
   const text = String(content || "");
@@ -125,6 +139,12 @@ export function parseExisting(content) {
   // language: "en" - only supported values count; a hand-edited unknown value is treated as unset
   const langRaw = normalizeLanguage((line(/^language:\s*(.+)/) || "").replace(/\s+#.*$/, "").replace(/["']/g, ""));
   const language = isSupportedLanguage(langRaw) ? langRaw : null;
+  // The unsupported value that was written (null when the key is absent or valid), so callers can tell "no key" from "unknown value"
+  const languageUnsupported = langRaw && !language ? langRaw : null;
+  // metadata.last_updated_by: the release scripts write the acting user here, so a re-install keeps it instead of resetting it
+  // (quoted values are unescaped; an unquoted one ends at whitespace or a comment)
+  const byMatch = /^[ \t]+last_updated_by:[ \t]*(?:"((?:[^"\\]|\\.)*)"|([^\s#"']+))/m.exec(text);
+  const lastUpdatedBy = byMatch ? (byMatch[1] !== undefined ? byMatch[1].replace(/\\(.)/g, "$1") : byMatch[2]) : null;
   // project_paths block: `  type: "path"`
   const paths = new Map();
   // Entries folded into another entry of the same canonical type with a different folder (react: client + next: web).
@@ -171,11 +191,12 @@ export function parseExisting(content) {
     }
   }
   // Optional workflow options (metadata.template.options)
-  const options = parseTemplateOptions(text);
+  const invalidOptions = [];
+  const options = parseTemplateOptions(text, invalidOptions);
   // metadata.template.branches - main/develop/mode (to skip re-asking in update mode)
   const branches = parseTemplateBranches(text);
   return {
-    version, versionCode, types, language, paths, droppedPaths, templateVersion, options, branches,
+    version, versionCode, types, language, languageUnsupported, lastUpdatedBy, paths, droppedPaths, templateVersion, options, invalidOptions, branches,
     deploy: parseDeployBlock(text), extraTopLevel: parseExtraTopLevel(text),
   };
 }
@@ -247,6 +268,7 @@ export function buildVersionYml({
   templateText, version, types = [], paths = new Map(), pathMarkers = new Map(),
   branch = "main", branches = null, versionCode = 1, now, today,
   templateOptions = null, deployValues = new Map(), extraTopLevel = [], typeOptions = {}, language = DEFAULT_LANGUAGE,
+  lastUpdatedBy = "",
 }) {
   if (!templateText) throw new Error(tr("core.versionYml.error.templateRequired"));
   const typesJson = types.length ? `[${types.map((t) => `"${t}"`).join(", ")}]` : `["basic"]`;
@@ -260,7 +282,7 @@ export function buildVersionYml({
   // project_paths block (full-line token {{PROJECT_PATHS}} - line removed when absent)
   let pathsBlock = "";
   if (paths.size) {
-    const rows = [`project_paths: # ${tr("core.versionYml.pathsComment")}`];
+    const rows = [`project_paths: # ${tr("core.versionYml.pathsComment", {}, language)}`];
     for (const [t, p] of paths) {
       const marker = pathMarkers.get(t) || "";
       const pf = p === "." ? marker : (marker ? `${p}/${marker}` : p);
@@ -273,7 +295,7 @@ export function buildVersionYml({
   let deployBlock = "";
   const deployTypes = [...deployValues.keys()].filter((t) => deployValues.get(t) && deployValues.get(t).size > 0);
   if (deployTypes.length) {
-    const rows = ["", `deploy: # ${tr("core.versionYml.deployComment")}`];
+    const rows = ["", `deploy: # ${tr("core.versionYml.deployComment", {}, language)}`];
     for (const t of deployTypes) {
       rows.push(`  ${t}:`);
       // Reuse the same escape - deploy values arrive by the same path as @wizard ask values, so
@@ -291,6 +313,8 @@ export function buildVersionYml({
     PROJECT_TYPES: typesJson,
     LANGUAGE: isSupportedLanguage(language) ? language : DEFAULT_LANGUAGE,
     NOW: now, TODAY: today || optionsDate, DEFAULT_BRANCH: branch,
+    // A previously recorded value (e.g. the user who last bumped the version) wins over the installer's own name
+    LAST_UPDATED_BY: escapeYamlDoubleQuoted(lastUpdatedBy || "project-auto-wizard"),
     TEMPLATE_VERSION: templateVersion,
     MAIN_BRANCH: b.main, DEVELOP_BRANCH: b.develop, BRANCH_MODE: b.mode,
     ...Object.fromEntries(OPTIONS.map((o) => [optionVar(o), String(optionValues[o.ctxField])])),
@@ -329,13 +353,13 @@ export function sameIgnoringTimestamps(a, b) {
 // Builds the final version.yml from a single context - the real install (full) and the preview (dry-run)
 // use the same function, structurally preventing "the preview differs from the result".
 // deployValues exist only in a real install (the preview performs no substitution, so it is an empty Map).
-export function renderVersionYml(context, templateText, { pathMarkers, deployValues = new Map(), extraTopLevel = [] }) {
+export function renderVersionYml(context, templateText, { pathMarkers, deployValues = new Map(), extraTopLevel = [], lastUpdatedBy = "" }) {
   const { version, types = [], paths = new Map(), branch = "main", versionCode = 1,
     now, today, templateVersion = "unknown", branches = null, language,
     deployStyle } = context;
   return buildVersionYml({
     templateText, version, types, paths, pathMarkers, branch, branches, versionCode, now, today,
-    deployValues, extraTopLevel, language,
+    deployValues, extraTopLevel, language, lastUpdatedBy,
     typeOptions: mergeHookResults(types, "optionsFromContext", context),
     templateOptions: {
       templateVersion,

package/src/i18n/catalog/en/cli.js

@@ -2,6 +2,7 @@
 export default {
   "cli.lang.invalid": "Unsupported language '{value}' ({source}). Supported: {supported}",
   "cli.lang.defaultNotice": "Workflow messages now default to English. Use --lang ko to keep Korean.",
+  "cli.lang.unsupportedSavedNotice": "version.yml has language '{value}', which is not supported ({supported}); workflow messages use English. Use --lang to choose one.",
   "cli.lang.missing": "--lang requires a value. Supported: {supported}",
   "cli.lang.help": "Message language: {supported} (default: en)",
   "cli.bin.nodeVersion": "Node.js 20.12 or later is required (current: {current})",

package/src/i18n/catalog/en/commands.js

@@ -9,6 +9,7 @@ export default {
   "cmd.status.branchMode": "Branch mode     : {mode} ({main} / {develop})",
   "cmd.status.unsetDefaultFalse": "unset (default false)",
   "cmd.status.unsetDefaultTrue": "unset (default true)",
+  "cmd.status.invalidValue": "invalid value \"{value}\", read as false",
   "cmd.status.options": "Options         : {value}",
   "cmd.status.modified": "Workflow files modified by the user ({n}):",
   "cmd.status.unmodified": "All workflow files match their install-time defaults (no modifications).",
@@ -84,7 +85,9 @@ export default {
   "cmd.doctor.automerge.on": "It is on (release_automerge: true in version.yml, or the key is absent).",
   "cmd.doctor.automerge.onHow": "To merge the release PR yourself, reinstall with --no-release-automerge or set release_automerge: false in version.yml.",
   "cmd.doctor.automerge.off": "It is off (release_automerge: false in version.yml); the workflow prepares the release PR but does not merge it.",
-  "cmd.doctor.automerge.offHow": "Merge the release PR yourself with a merge commit (not squash or rebase) so the release still publishes; --release-automerge turns it back on.",
+  "cmd.doctor.automerge.offHow": "Merge the release PR yourself with a merge commit (recommended): squash and rebase merges skip the release workflow because of [skip ci], so run PROJECT-RELEASE-PUBLISH manually if you used one. --release-automerge turns automerge back on.",
+  "cmd.doctor.automerge.invalid": "version.yml has release_automerge: \"{value}\", which is not true or false. It is read as false, so the workflow does not merge the release PR.",
+  "cmd.doctor.automerge.invalidHow": "Set release_automerge to true or false in version.yml (or reinstall with --release-automerge / --no-release-automerge).",
   "cmd.doctor.copilot.fallback": "When it is off or unavailable, it switches to the rule-based summary automatically, so you can leave it as is.",
   "cmd.doctor.heading": "Environment check",
   "cmd.doctor.details": "Details: ",

package/src/i18n/catalog/en/core.js

@@ -5,6 +5,7 @@ export default {
   "core.detect.buildNumber.pubspecMissing": "⚠️  pubspec.yaml has no build number (+N), so version_code could not be detected — using the default 1. Check your actual build number.",
   "core.detect.buildNumber.gradleMissing": "⚠️  android/app/build.gradle has no versionCode, so version_code could not be detected — using the default 1. Check your actual build number.",
   "core.detect.buildNumber.expoMissing": "⚠️  expo.android.versionCode is missing in app.json, so version_code could not be detected — using the default 1. Check your actual build number.",
+  "core.detectFs.monorepoDropped": "Only one folder per type is managed: {type}={kept} would be used, and {lost} would stay out of CI and version sync.",
   "core.detectFs.monorepoWarn": "⚠️  No project files found at the root, installing as basic. Found in subfolders: {list}\n   For a monorepo, run again with --paths \"{hint}\".",
   "core.detectFs.defaultBranchWarn": "⚠️  Could not determine the remote default branch (e.g. an empty remote repo), assuming '{fallback}' as the release branch.{hint}",
   "core.branches.developMissing": "The remote has no '{develop}' branch — commit the installed files, push '{main}', then create it: git push origin {main}:{develop}",

package/src/i18n/catalog/en/core2.js

@@ -4,6 +4,8 @@ export default {
   "core.versionYml.pathMergedTitle": "One folder per type",
   "core.versionYml.pathMerged": "version.yml lists '{keptName}' (folder {kept}) and '{name}' (folder {path}) separately, but they are now the same type and only one folder per type is managed. Keeping {type}={final}; {lost} drops out of CI and version sync.",
   "core.versionYml.pathMergedHint": "To manage {path} instead, rerun with --paths {type}={path}; to keep both, add a hand-written CI workflow for the dropped folder.",
+  "core.versionYml.optionInvalid": "version.yml option {key} has an unrecognized value \"{value}\"; it is read as false. Use true or false.",
+  "core.versionYml.optionInvalidTitle": "Unrecognized option value",
   "core.breakingCheck.nonInteractive": "⚠️  There are CRITICAL breaking changes - continuing because this is a non-interactive run. Be sure to review the notes above.",
   "core.logger.error.nameExhausted": "All log file names are in use: {base}",
   "core.logger.warn.startFailed": "Could not start the run log: {message}",

package/src/i18n/catalog/en/ui.js

@@ -34,6 +34,7 @@ export default {
   "ui.summary.branches.title": "Branch layout:",
   "ui.summary.branches.trunk": "  🌿 Single branch {main} (trunk-based) — one RELEASE-PUBLISH workflow handles version confirm → changelog → tag → Release in sequence",
   "ui.summary.branches.prFlow": "  🌿 Development {develop} → release {main} (pr-flow) — version confirm, changelog and automerge happen on the release PR",
+  "ui.summary.branches.prFlowManual": "  🌿 Development {develop} → release {main} (pr-flow) — version confirm and changelog happen on the release PR; you merge it yourself (automerge is off)",
   "ui.summary.branches.developMissing": "     ⚠️  Branch '{develop}' does not exist on the remote yet — development-branch workflows will not run until it is created",
   "ui.summary.branches.developHint": "        → After committing the installed files and pushing {main}: git push origin {main}:{develop}",
   "ui.summary.engine.title": "Release-note summary engine:",
@@ -77,6 +78,8 @@ export default {
   "ui.summary.todo.commitExample": "       e.g. git checkout {develop} && git merge {main} && git push",
   "ui.summary.todo.changelogLink": "     → The README's 'View full version history' (CHANGELOG.md) link works once the first release generates the CHANGELOG",
   "ui.summary.todo.pat": "PAT for release automerge (optional — falls back to GITHUB_TOKEN automatically if missing)",
+  "ui.summary.todo.manualMerge": "Merge the release PR yourself (release_automerge is off — no PAT needed for it)",
+  "ui.summary.todo.manualMergeHow": "     → Once the workflow run on the release PR has finished, merge it with a merge commit (recommended)",
   "ui.summary.todo.patAccount": "     → Issue it from an organization bot/machine account rather than a personal account",
   "ui.summary.todo.patOptional": "     → Without it, tag/Release publishing and deploy workflow runs still proceed automatically; with it, it is slightly faster",
   "ui.summary.todo.permissions": "GitHub Actions permissions (no change needed)",

package/src/i18n/catalog/ko/cli.js

@@ -2,6 +2,7 @@
 export default {
   "cli.lang.invalid": "지원하지 않는 언어: '{value}' ({source}). 지원 언어: {supported}",
   "cli.lang.defaultNotice": "워크플로우 메시지의 기본 언어가 영어로 바뀌었습니다. 한국어를 유지하려면 --lang ko를 사용하세요.",
+  "cli.lang.unsupportedSavedNotice": "version.yml의 language '{value}'는 지원하지 않는 값이라({supported}) 워크플로우 메시지는 영어로 나옵니다. --lang으로 언어를 고르세요.",
   "cli.lang.missing": "--lang 값이 필요합니다. 지원 언어: {supported}",
   "cli.lang.help": "메시지 언어: {supported} (기본: en)",
   "cli.bin.nodeVersion": "Node.js 20.12 이상이 필요합니다 (현재: {current})",

package/src/i18n/catalog/ko/commands.js

@@ -9,6 +9,7 @@ export default {
   "cmd.status.branchMode": "브랜치 모드      : {mode} ({main} / {develop})",
   "cmd.status.unsetDefaultFalse": "미설정(기본 false)",
   "cmd.status.unsetDefaultTrue": "미설정(기본 true)",
+  "cmd.status.invalidValue": "잘못된 값 \"{value}\", false로 읽음",
   "cmd.status.options": "옵션            : {value}",
   "cmd.status.modified": "사용자가 수정한 워크플로우 파일 ({n}개):",
   "cmd.status.unmodified": "모든 워크플로우 파일이 설치 시점 기본값과 동일합니다 (수정 없음).",
@@ -84,7 +85,9 @@ export default {
   "cmd.doctor.automerge.on": "켜져 있습니다 (version.yml의 release_automerge: true, 또는 키가 없음).",
   "cmd.doctor.automerge.onHow": "릴리스 PR을 직접 머지하려면 --no-release-automerge로 다시 설치하거나 version.yml의 release_automerge를 false로 바꾸세요.",
   "cmd.doctor.automerge.off": "꺼져 있습니다 (version.yml의 release_automerge: false) — 워크플로우가 릴리스 PR을 준비만 하고 머지하지 않습니다.",
-  "cmd.doctor.automerge.offHow": "릴리스가 정상 배포되도록 머지 커밋으로 직접 머지하세요(squash·rebase 금지). 다시 켜려면 --release-automerge를 쓰세요.",
+  "cmd.doctor.automerge.offHow": "머지 커밋으로 직접 머지하는 것을 권장합니다. squash·rebase 머지는 [skip ci] 때문에 릴리스 워크플로우가 건너뛰어지므로, 그렇게 머지했다면 PROJECT-RELEASE-PUBLISH를 수동 실행하세요. 다시 켜려면 --release-automerge를 쓰세요.",
+  "cmd.doctor.automerge.invalid": "version.yml의 release_automerge 값 \"{value}\"이(가) true도 false도 아닙니다. false로 읽으므로 워크플로우가 릴리스 PR을 머지하지 않습니다.",
+  "cmd.doctor.automerge.invalidHow": "version.yml의 release_automerge를 true 또는 false로 고치세요(또는 --release-automerge / --no-release-automerge로 다시 설치).",
   "cmd.doctor.copilot.fallback": "꺼져 있거나 사용할 수 없으면 규칙 기반 요약으로 자동 전환되므로 그대로 두셔도 됩니다.",
   "cmd.doctor.heading": "환경 진단",
   "cmd.doctor.details": "자세히: ",

package/src/i18n/catalog/ko/core.js

@@ -5,6 +5,7 @@ export default {
   "core.detect.buildNumber.pubspecMissing": "⚠️  pubspec.yaml에 빌드 번호(+N)가 없어 version_code를 감지하지 못했습니다 — 기본값 1을 사용합니다. 실제 빌드 번호를 확인하세요.",
   "core.detect.buildNumber.gradleMissing": "⚠️  android/app/build.gradle에 versionCode가 없어 version_code를 감지하지 못했습니다 — 기본값 1을 사용합니다. 실제 빌드 번호를 확인하세요.",
   "core.detect.buildNumber.expoMissing": "⚠️  app.json의 expo.android.versionCode가 없어 version_code를 감지하지 못했습니다 — 기본값 1을 사용합니다. 실제 빌드 번호를 확인하세요.",
+  "core.detectFs.monorepoDropped": "타입당 폴더 하나만 관리합니다: {type}={kept} 를 쓰고, {lost} 는 CI·버전 동기화에서 빠집니다.",
   "core.detectFs.monorepoWarn": "⚠️  루트에서 프로젝트 파일을 찾지 못해 basic으로 설치합니다. 하위 폴더에서 발견: {list}\n   모노레포라면 --paths \"{hint}\"로 다시 실행하세요.",
   "core.detectFs.defaultBranchWarn": "⚠️  원격 기본 브랜치를 확인할 수 없어(빈 원격 레포 등) 릴리스 브랜치를 '{fallback}'(으)로 가정합니다.{hint}",
   "core.branches.developMissing": "원격에 '{develop}' 브랜치가 없습니다 — 설치 파일을 커밋해 '{main}'을 push한 뒤 만들어 주세요: git push origin {main}:{develop}",

package/src/i18n/catalog/ko/core2.js

@@ -4,6 +4,8 @@ export default {
   "core.versionYml.pathMergedTitle": "타입당 폴더 하나",
   "core.versionYml.pathMerged": "version.yml 에 '{keptName}'(폴더 {kept})과 '{name}'(폴더 {path})이 따로 적혀 있지만 이제 같은 타입이라 타입당 폴더 하나만 관리합니다. {type}={final} 를 유지하고, {lost} 는 CI·버전 동기화에서 빠집니다.",
   "core.versionYml.pathMergedHint": "{path} 를 대신 관리하려면 --paths {type}={path} 로 다시 실행하세요. 둘 다 유지하려면 빠진 폴더용 CI 워크플로우를 직접 추가하세요.",
+  "core.versionYml.optionInvalid": "version.yml의 옵션 {key} 값 \"{value}\"을(를) 인식하지 못해 false로 읽습니다. true 또는 false를 쓰세요.",
+  "core.versionYml.optionInvalidTitle": "인식하지 못한 옵션 값",
   "core.breakingCheck.nonInteractive": "⚠️  CRITICAL 호환성 변경이 있습니다 — 비대화형 실행이라 계속 진행합니다. 위 내용을 꼭 확인하세요.",
   "core.logger.error.nameExhausted": "로그 파일 이름이 모두 사용 중입니다: {base}",
   "core.logger.warn.startFailed": "실행 로그를 시작하지 못했습니다: {message}",

package/src/i18n/catalog/ko/ui.js

@@ -34,6 +34,7 @@ export default {
   "ui.summary.branches.title": "브랜치 구성:",
   "ui.summary.branches.trunk": "  🌿 {main} 단일 브랜치 (trunk-based) — RELEASE-PUBLISH 하나가 버전확정→체인지로그→tag→Release를 순차 처리",
   "ui.summary.branches.prFlow": "  🌿 개발 {develop} → 릴리스 {main} (pr-flow) — 릴리스 PR에서 버전확정·체인지로그·automerge",
+  "ui.summary.branches.prFlowManual": "  🌿 개발 {develop} → 릴리스 {main} (pr-flow) — 릴리스 PR에서 버전확정·체인지로그까지 진행하고, 머지는 직접 합니다 (automerge 꺼짐)",
   "ui.summary.branches.developMissing": "     ⚠️  '{develop}' 브랜치가 아직 원격에 없습니다 — 만들기 전에는 개발 브랜치 워크플로우가 동작하지 않습니다",
   "ui.summary.branches.developHint": "        → 설치 파일을 커밋해 {main}을 push한 뒤: git push origin {main}:{develop}",
   "ui.summary.engine.title": "릴리스 노트 요약 엔진:",
@@ -77,6 +78,8 @@ export default {
   "ui.summary.todo.commitExample": "       예) git checkout {develop} && git merge {main} && git push",
   "ui.summary.todo.changelogLink": "     → README의 '전체 버전 기록 보기'(CHANGELOG.md) 링크는 첫 릴리스에서 CHANGELOG가 생성된 뒤부터 열립니다",
   "ui.summary.todo.pat": "릴리스 automerge용 PAT (선택 — 없으면 GITHUB_TOKEN 폴백으로 자동 진행)",
+  "ui.summary.todo.manualMerge": "릴리스 PR은 직접 머지하세요 (release_automerge 꺼짐 — 이를 위한 PAT는 필요 없습니다)",
+  "ui.summary.todo.manualMergeHow": "     → 릴리스 PR의 워크플로우 실행이 끝나면 머지 커밋(Create a merge commit)으로 머지하는 것을 권장합니다",
   "ui.summary.todo.patAccount": "     → 등록 시 개인 계정이 아닌 조직 bot/machine 계정으로 발급하세요",
   "ui.summary.todo.patOptional": "     → 없어도 태그·Release 발행과 배포 워크플로우 실행까지 자동으로 이어지며, 있으면 조금 더 빠릅니다",
   "ui.summary.todo.permissions": "GitHub Actions 권한 (변경 불필요)",

package/src/index.js

@@ -8,13 +8,13 @@ import { readFileSync, existsSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { parseArgs, parsePathsCsv, CliError, TYPE_CLI_FLAGS } from "./cli/args.js";
 import { helpText } from "./cli/help.js";
-import { resolveLanguage, setLanguage, t, DEFAULT_LANGUAGE, LANG_ENV_VAR, normalizeLanguage } from "./i18n/index.js";
+import { resolveLanguage, setLanguage, t, DEFAULT_LANGUAGE, LANG_ENV_VAR, SUPPORTED_LANGUAGES, normalizeLanguage } from "./i18n/index.js";
 import { fallbackStyleTypes } from "./core/deploy-style.js";
 import { hooksFor, mergeHookResults } from "./core/types.js";
 import { PATHS } from "./core/paths.js";
 import { resolvePayloadRoot, assertPayload, readTemplateVersion } from "./core/assets.js";
 import { detectTypes, detectDefaultBranch, detectRepoName, makeResolvers, detectMarkers } from "./core/detect-fs.js";
-import { parseExisting, droppedPathLines } from "./core/version-yml.js";
+import { parseExisting, droppedPathLines, invalidOptionLines } from "./core/version-yml.js";
 import { resolveReleaseOptions } from "./core/release-options.js";
 import { explicitFromContext, optionContextFields } from "./core/options.js";
 import { runBreakingCheck } from "./core/breaking-check.js";
@@ -100,16 +100,25 @@ async function runInner(argv, {
   // Language: --lang -> env var -> saved version.yml value -> en. Resolved after --help/--version
   // so an invalid env var cannot block the help output.
   let language;
+  // Language written to version.yml: the environment variable only decides this run's output, so it must not
+  // overwrite a saved choice. Only --lang (or a first install / an unusable saved value) sets the stored language.
+  let storedLanguage;
   try {
     const savedVy = join(cwd, "version.yml");
-    const saved = existsSync(savedVy) ? parseExisting(readFileSync(savedVy, "utf8")).language : null;
+    const savedParsed = existsSync(savedVy) ? parseExisting(readFileSync(savedVy, "utf8")) : null;
+    const saved = savedParsed?.language ?? null;
     language = resolveLanguage({ flag: opts.lang, env: process.env[LANG_ENV_VAR], saved });
+    storedLanguage = normalizeLanguage(opts.lang) ? language : (saved ?? language);
     // An existing install without a saved language now falls back to English: say so once, since
-    // its workflow messages switch from Korean on the next update.
+    // its workflow messages switch from Korean on the next update. A hand-edited unknown value also
+    // falls back to English, but it was never the old default, so it gets its own wording.
     const existingWithoutLanguage = existsSync(savedVy) && !saved;
     const unspecified = !normalizeLanguage(opts.lang) && !normalizeLanguage(process.env[LANG_ENV_VAR]);
     if (existingWithoutLanguage && unspecified && ["full", "interactive"].includes(opts.mode)) {
-      console.error(t("cli.lang.defaultNotice", {}, DEFAULT_LANGUAGE));
+      const unknown = savedParsed?.languageUnsupported;
+      console.error(unknown
+        ? t("cli.lang.unsupportedSavedNotice", { value: unknown, supported: SUPPORTED_LANGUAGES.join(", ") }, DEFAULT_LANGUAGE)
+        : t("cli.lang.defaultNotice", {}, DEFAULT_LANGUAGE));
     }
   } catch (e) {
     if (e instanceof CliError) { console.error(e.message); return 1; }
@@ -150,7 +159,7 @@ async function runInner(argv, {
     // The log file is created on the first write, so viewing only status/doctor from the menu leaves nothing behind.
     startLog("install");
     return await runInteractive(
-      { ...optionContextFields(opts), language },
+      { ...optionContextFields(opts), language: storedLanguage },
       { cwd, payloadRoot: payload, clock },
     );
   }
@@ -319,6 +328,8 @@ async function runInner(argv, {
 
   // Warn against the final folders (an explicit --paths may keep the other one). The dry-run preview prints its own notice.
   if (!opts.dryRun) for (const line of droppedPathLines(existing?.droppedPaths, paths)) console.error(`⚠️  ${line}`);
+  // An option value that could not be read is rewritten as false by this run - say so instead of doing it silently.
+  for (const line of invalidOptionLines(existing?.invalidOptions)) console.error(`⚠️  ${line}`);
 
   // version: existing version.yml first (SSoT; prevents overwriting on re-run) -> CLI value -> file detection.
   // Non-interactive, so the fallback notice uses the CLI wording (--project-version) as is.
@@ -374,7 +385,7 @@ async function runInner(argv, {
     repoName,
     // resolvers that compute @wizard ask/auto token values
     resolvers: makeResolvers(cwd, repoName, paths, typeOptions),
-    now, today, language,
+    now, today, language: storedLanguage,
     // Extra context for the install log; does not change the install itself.
     markers: detectMarkers(cwd, types), detectWarnings,
   });
@@ -406,6 +417,7 @@ async function runInner(argv, {
   // Completion summary (also printed in CLI mode)
   printSummary({
     mode: opts.mode, types, version, versionCode, branches, developMissing,
+    releaseAutomerge: context.includeReleaseAutomerge !== false,
     copiedFiles: result?.workflows?.copiedFiles ?? [],
     autoUpdated: result?.workflows?.autoUpdated ?? [],
     gitignoreUpdated: result?.gitignoreUpdated === true,

package/src/ui/summary.js

@@ -13,6 +13,8 @@ export function printSummary(ctx) {
   const { mode, types = [], version = "", versionCode = null, copiedFiles = [], autoUpdated = [], branches = null, gitignoreUpdated = false,
     // pr-flow but the develop branch could not be created on the remote - the layout line alone looks ready, so warn separately.
     developMissing = false,
+    // false when version.yml turns the release PR automerge off: the summary must not describe automerge or its PAT then.
+    releaseAutomerge = true,
     // Post-install verification and record
     answers = [], unresolved = [], secrets = new Map(), optionalSecrets = new Map(), logPath = "", legacyMdLogs = false, cleanup = null,
     // Flutter store deployment - app files created/kept and cleanup of deselected stores
@@ -49,7 +51,7 @@ export function printSummary(ctx) {
     if (branches.mode === "trunk-based") {
       err(t("ui.summary.branches.trunk", { main: branches.main }));
     } else {
-      err(t("ui.summary.branches.prFlow", { develop: branches.develop, main: branches.main }));
+      err(t(releaseAutomerge ? "ui.summary.branches.prFlow" : "ui.summary.branches.prFlowManual", { develop: branches.develop, main: branches.main }));
       if (developMissing) {
         err(t("ui.summary.branches.developMissing", { develop: branches.develop }));
         err(t("ui.summary.branches.developHint", { main: branches.main, develop: branches.develop }));
@@ -208,11 +210,18 @@ export function printSummary(ctx) {
     err("");
   }
 
-  err(`  ${num()} ${t("ui.summary.todo.pat")}`);
-  err(t("ui.summary.todo.patPath"));
-  err(t("ui.summary.todo.patName"));
-  err(t("ui.summary.todo.patAccount"));
-  err(t("ui.summary.todo.patOptional"));
+  // With automerge off (pr-flow) nothing merges the release PR on the workflow's behalf, so the PAT guidance does not apply.
+  // In trunk-based mode there is no release PR, and the PAT block is kept as before.
+  if (releaseAutomerge || !branches || branches.mode === "trunk-based") {
+    err(`  ${num()} ${t("ui.summary.todo.pat")}`);
+    err(t("ui.summary.todo.patPath"));
+    err(t("ui.summary.todo.patName"));
+    err(t("ui.summary.todo.patAccount"));
+    err(t("ui.summary.todo.patOptional"));
+  } else {
+    err(`  ${num()} ${t("ui.summary.todo.manualMerge")}`);
+    err(t("ui.summary.todo.manualMergeHow"));
+  }
   err("");
   // Installed workflows declare the permissions they need themselves - report it by the same rule as the doctor guidance.
   err(`  ${num()} ${t("ui.summary.todo.permissions")}`);