wdi-method 0.4.5 → 0.5.0

package/README.md

@@ -1,13 +1,11 @@
 # WDI Method
 
-A software delivery method for agent-driven work. It **wraps [BMad](https://github.com/bmad-code-org/BMAD-METHOD); it does not replace it.**
+**The review layer BMad leaves thin — documents a human reads to check a decision before code gets written, sized to what the change actually deserves.**
 
-BMad decides *what to build* and *how to build it* well. What it leaves thin is the middle: the
-documents a **human** reads to check that the decision is right before anybody writes code. WDI Method
-adds that middle, and a way to choose how much of it you want.
+[BMad](https://github.com/bmad-code-org/BMAD-METHOD) decides *what* to build and *how* to build it well. WDI Method wraps it — it does not replace it — and adds the part between those two decisions and the code: inventories, a use case catalogue, a component design record, and a way to choose how much of that a given change actually needs.
 
-This repository is **public** and generic. It MUST NOT contain a client name, a product name, or a link
-to a private repository. Product identity lives in the consuming repo.
+> This repository is **public and generic**. It MUST NOT carry a client name, a product name, or a
+> link to a private repository — product identity lives entirely in the repo that installs it.
 
 ---
 
@@ -50,6 +48,25 @@ answers with the gate you are at, not with a menu.
 
 ---
 
+## Why WDI Method?
+
+- **Depth separate from scrutiny.** `mode` sets how much gets written; `risk_accepted` sets how hard it
+  gets reviewed. Neither is derived from the other, so a component MAY be thin on purpose and reviewed the
+  hardest.
+- **Ground truth over plan.** Once code exists, the tables, endpoints, and screens are **derived from it**
+  — the gap between plan and reality is a finding to resolve, not an argument to have.
+- **Containers that match what actually ships.** C4's containers follow deployability, not folders, and a
+  component view is drawn for every container that carries more than one Product Component.
+- **A gate that can be skipped honestly.** `mode: catalog` skips the component gate entirely — a fast
+  default is fast because the work is genuinely gone, not nominally trimmed.
+- **Decisions that don't rot.** A `DEC-` is recorded only when the reason would not survive reading the
+  code, and it freezes the moment it is applied — a change of mind writes a new one rather than editing
+  the old.
+- **Wraps BMad, never forks it.** Every `wdi-*` skill is a wrapper around a BMad skill. Upgrading BMad
+  does not strand you, and no BMad skill is meant to be invoked directly.
+
+---
+
 ## The gap this fills
 
 A gate is only as good as the artifact it reads. Between *"the architecture is decided"* and *"the code
@@ -148,15 +165,27 @@ reads guards nothing.
 
 ## What is generic, and where your own rules live
 
-`.constitution/` belongs to the method and is **overwritten** on every update. Four rooms are yours:
+`.constitution/` holds **exactly two folders**, and the folder is the whole answer to who owns a file:
+
+| Folder | Owner | `update` | `promote` |
+|---|---|---|---|
+| `.constitution/method/` | the method | **overwritten** in full | carries it into the package |
+| **`.constitution/project/`** | you | **never touched** — seeded once when absent | never carries it, so your rules cannot be published |
+
+Everything in the room is yours: `project/constitution.md` (Articles 1, 2, 5 — scope, repo checklist,
+method ownership), `project/codebase-*-guide.md` (stack, conventions, brownfield, protected at **any**
+`status:` — `Draft` is when they actually get written), and any rule file you add.
+
+**The seam is a folder, never a marked region inside a generic file.** Prose has no merge algebra: you
+cannot "merge" your paragraph with the method's, so only a path can say unambiguously whose a file is.
+`AGENTS.md` is the one exception, and only because it is a single file with nowhere else to go.
 
-| Room | Yours because |
+Two more things are yours, outside `.constitution/`:
+
+| Yours | Because |
 |---|---|
 | `.control/registry/index.yaml` → `product:` | The product and client name live in exactly one place |
-| `constitution.md` Articles 1, 2, 5 | Scope, repo checklist, method ownership |
-| `.constitution/codebase/*-guide.md` | Your stack and conventions, protected once `Accepted` |
-| **`.constitution/project/`** | Any rule that binds **only this product** |
-| `_bmad/custom/*.user.toml` | Your BMad overrides |
+| `_bmad/custom/*.user.toml` | Your BMad overrides — TOML, so these genuinely merge: a string replaces, a list appends, a table merges per key |
 
 `.control/` `.what/` `.how/` are never touched by an update at all — they are your state, your promises,
 and your design.
@@ -181,7 +210,8 @@ Write whatever names the language — `English`, `Bahasa Indonesia`, `id`. What
 and a model does not need a lookup table.
 
 Always English, and never asked: method terminology, document code prefixes (`UC-`, `DEC-`), machine
-markers (`[NEEDS CONFIRMATION]`, `[MISSING]`), and code identifiers.
+markers (`[NEEDS CONFIRMATION]`, `[MISSING]`), and code identifiers. `.constitution/` itself is always
+English, whatever the settings say — it travels to every repo through this package.
 
 ---
 
@@ -189,9 +219,9 @@ markers (`[NEEDS CONFIRMATION]`, `[MISSING]`), and code identifiers.
 
 | | |
 |---|---|
-| Overwrites | `.constitution/` guides, templates and scripts · the fifteen wrappers · `_bmad/custom/*.toml` · the marked block in `AGENTS.md` |
+| Overwrites | everything in `.constitution/method/` · the fifteen wrappers · `_bmad/custom/*.toml` · the marked block in `AGENTS.md` |
 | Removes | Wrappers the method has retired — a `wdi-*` folder with a `SKILL.md` that is no longer one of the fifteen. Each removal is printed |
-| Keeps | Everything in the table above, plus your initiative slug and your language choice. A setting somebody already chose is not the installer's to change behind their back |
+| Keeps | All of `.constitution/project/`, plus your initiative slug and your language choice. A setting somebody already chose is not the installer's to change behind their back |
 | Never resurrects | A folder you retired. On update, absence is treated as a decision |
 
 It prints the version it replaced, what it wrote, what it kept, and what to do next.
@@ -219,4 +249,16 @@ carefully to read the diff. [`CONTRIBUTING.md`](CONTRIBUTING.md) has the detail,
 
 ---
 
-MIT. Requires Node 20+ and [uv](https://docs.astral.sh/uv/) for the Python scripts.
+## Support and Contributing
+
+Open an [issue](https://github.com/wiradigitalid/wdi-method/issues) for a bug or a proposal. Read
+[`CONTRIBUTING.md`](CONTRIBUTING.md) before sending a pull request — it explains where a change belongs,
+how versioning works here, and what to check before publishing.
+
+## License
+
+MIT — see [LICENSE](LICENSE). Requires Node 20+ and [uv](https://docs.astral.sh/uv/) for the Python
+scripts.
+
+[![Version](https://img.shields.io/npm/v/wdi-method?color=blue&label=version)](https://www.npmjs.com/package/wdi-method)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

package/bin/wdi-method.js

@@ -42,8 +42,7 @@ const WDI_SKILLS = [
   "wdi-systematic-debugging",
 ];
 
-const PRODUCT_CONSTITUTION = "constitution.md";
-const PRD_SLUG_PLACEHOLDER = "ISI-slug-inisiatif";
+const PRD_SLUG_PLACEHOLDER = "FILL-initiative-slug";
 const GENERIC_FOLDER_PATTERNS = new Set([
   "_product-brief",
   "ux",
@@ -205,15 +204,6 @@ function posixRel(from, to) {
   return path.relative(from, to).split(path.sep).join("/");
 }
 
-function acceptedCodebase(file) {
-  try {
-    const head = fs.readFileSync(file, "utf8").slice(0, 400);
-    return /status:\s*Accepted/i.test(head);
-  } catch {
-    return false;
-  }
-}
-
 function bmadPresent(target) {
   const markers = [
     path.join(target, ".claude", "skills", "bmad-help", "SKILL.md"),
@@ -308,13 +298,102 @@ function bmadMissingMessage() {
   ].join("\n");
 }
 
-// Kamar custom milik produk. Tiga sifatnya, dan ketiganya harus dipegang bersama:
-//   install/update  menyemai isinya HANYA bila belum ada — sesudah itu ia tak pernah ditulis lagi
-//   promote         MELEWATINYA seluruhnya, jadi aturan khusus produk tidak mungkin terbit ke repo publik
-//   agent           memuatnya seperti guide lain, jadi ia MENGIKAT
-// Konsekuensi yang disengaja: README kamar ini diarang di paket dan tidak pernah pulang lewat promote.
+// The product's custom room. Three properties, and all three MUST hold together:
+//   install/update  seeds its content ONLY when absent — never written again after that
+//   promote         SKIPS it entirely, so a product's own rules can never reach the public repo
+//   agent           loads it like any other guide, so it BINDS
+// The deliberate consequence: this room's README is authored in the package and never comes home
+// through promote.
 const PROJECT_ROOM = "project/";
 
+// 0.5.0 moved `.constitution/` to exactly two folders: `method/` is the method's and is overwritten,
+// `project/` is the product's and is never touched. Before it, generic and product-owned files sat
+// side by side at the root, `codebase/` was a third product-owned room nobody had written down, and
+// `constitution.md` was ONE file holding both — which is why `update` had to keep the whole thing and
+// the product never received a fixed generic Article.
+//
+// Without this migration an installed repo would end up carrying BOTH layouts: the kit writes the new
+// paths while the old files stay behind, and an agent reading `AGENTS.md` routing would find two
+// copies of most guides and no way to tell which binds.
+const OLD_ROOT_GUIDES = ["README", "language-guide", "method-glossary", "repo-guide", "structure-guide"];
+const OLD_WHY = ["README", "artifact-map", "portability", "rationale"];
+const OLD_CODEBASE = ["stack", "conventions", "brownfield"];
+
+function mv(from, to) {
+  fs.mkdirSync(path.dirname(to), { recursive: true });
+  fs.renameSync(from, to);
+}
+
+function migrateToTwoFolders(target) {
+  const c = path.join(target, ".constitution");
+  if (!fs.existsSync(c)) return false;          // a first install has nothing to migrate
+  const at = (...p) => path.join(c, ...p);
+  // The old layout is identified by `document/` at the ROOT — in the new layout that folder only ever
+  // exists under `method/`. Checking a loose guide instead would misfire on a repo that added one.
+  if (!fs.existsSync(at("document")) && !fs.existsSync(at("codebase"))
+      && !fs.existsSync(at("constitution.md")) && !fs.existsSync(at("scripts"))) {
+    return false;
+  }
+  note("pre-0.5.0 .constitution/ found — migrating to method/ + project/");
+
+  // 1. The four Reference files go one level deeper. This MUST run before the kit is written, or the
+  //    kit's own why/ files land while the old copies still sit at method/ root.
+  for (const name of OLD_WHY) {
+    const from = at("method", `${name}.md`);
+    if (fs.existsSync(from)) {
+      mv(from, at("method", "why", `${name}.md`));
+      note(`  moved method/${name}.md → method/why/${name}.md`);
+    }
+  }
+  // 2. and 3. whole folders
+  for (const dir of ["document", "scripts"]) {
+    if (fs.existsSync(at(dir)) && !fs.existsSync(at("method", dir))) {
+      mv(at(dir), at("method", dir));
+      note(`  moved ${dir}/ → method/${dir}/`);
+    }
+  }
+  // 4. the loose generic guides
+  for (const name of OLD_ROOT_GUIDES) {
+    const from = at(`${name}.md`);
+    if (fs.existsSync(from)) {
+      mv(from, at("method", `${name}.md`));
+      note(`  moved ${name}.md → method/${name}.md`);
+    }
+  }
+  // 5. codebase/ was a product-owned room all along — it becomes flat files in the room that says so
+  for (const name of OLD_CODEBASE) {
+    const from = at("codebase", `${name}-guide.md`);
+    if (fs.existsSync(from)) {
+      mv(from, at("project", `codebase-${name}-guide.md`));
+      note(`  moved codebase/${name}-guide.md → project/codebase-${name}-guide.md`);
+    }
+  }
+  if (fs.existsSync(at("codebase"))) {
+    const left = fs.readdirSync(at("codebase"));
+    if (!left.length) fs.rmdirSync(at("codebase"));
+    else note(`  codebase/ still holds ${left.join(", ")} — left in place, move them yourself`);
+  }
+  // 6. The product's constitution.md moves WHOLE into the room, so its Articles 1, 2, and 5 survive
+  //    exactly as written. The generic half then arrives fresh at method/constitution.md.
+  let split = false;
+  if (fs.existsSync(at("constitution.md")) && !fs.existsSync(at("project", "constitution.md"))) {
+    mv(at("constitution.md"), at("project", "constitution.md"));
+    note("  moved constitution.md → project/constitution.md (your Articles 1, 2, 5)");
+    split = true;
+  }
+  // Anything else loose at the root is a file this product ADDED. It is NOT moved: it may be routed
+  // from AGENTS.md by its current path, and guessing a destination would break that silently.
+  const stray = fs.existsSync(c)
+    ? fs.readdirSync(c, { withFileTypes: true })
+        .filter((e) => e.isFile() && e.name.endsWith(".md"))
+        .map((e) => e.name)
+    : [];
+  if (stray.length) {
+    note(`  left at .constitution/ root, yours to place: ${stray.join(", ")}`);
+  }
+  return split;
+}
+
 function syncConstitution(target) {
   const kitConst = path.join(KIT, ".constitution");
   const destConst = path.join(target, ".constitution");
@@ -324,19 +403,14 @@ function syncConstitution(target) {
   for (const file of walkFiles(kitConst)) {
     const rel = posixRel(kitConst, file);
     const dest = path.join(destConst, rel);
-    if (rel === PRODUCT_CONSTITUTION && fs.existsSync(dest)) {
-      skipped += 1;
-      note(`keep ${rel} (product articles)`);
-      continue;
-    }
-    if (rel.startsWith("codebase/") && fs.existsSync(dest) && acceptedCodebase(dest)) {
-      skipped += 1;
-      note(`keep ${rel} (Accepted codebase guide)`);
-      continue;
-    }
+    // ONE rule for everything the product owns, because 0.5.0 put all of it in one folder. Before
+    // that this loop had three branches — the mixed constitution.md kept whole, `codebase/` gated on
+    // `status: Accepted` (which is what silently destroyed a half-written guide), and the room — and
+    // the three disagreed about when a file was the product's. Seeded when absent, never written
+    // again: the same rule as the language policy.
     if (rel.startsWith(PROJECT_ROOM) && fs.existsSync(dest)) {
       skipped += 1;
-      note(`keep ${rel} (product custom room)`);
+      note(`keep ${rel} (yours — the project room)`);
       continue;
     }
     copyFile(file, dest);
@@ -394,10 +468,10 @@ function pruneRetiredSkills(dests) {
 
 // `promote` scrubs a product's initiative slug out of bmad-prd.toml before publishing, which is right.
 // Writing the scrubbed PLACEHOLDER back into a product repo is not: the first real install replaced a
-// live `run_folder_pattern = "toko-tanpa-akun"` with `ISI-slug-inisiatif`, and nothing said so. A value
+// live `run_folder_pattern = "some-real-slug"` with `FILL-initiative-slug`, and nothing said so. A value
 // the product already chose is not the installer's to overwrite — same rule as the custom room and the
 // language policy.
-const PLACEHOLDER_SLUG = "ISI-slug-inisiatif";
+const PLACEHOLDER_SLUG = "FILL-initiative-slug";
 const RUN_FOLDER_LINE = /^(\s*run_folder_pattern\s*=\s*)(".*?"|'.*?')/m;
 
 // The slug appears MORE THAN ONCE — bmad-prd.toml carries it in `run_folder_pattern` and again inside a
@@ -503,17 +577,17 @@ function setProductIdentity(target, { name, client }) {
   note(`product.name = ${name}`);
 }
 
-// Bahasa dokumen milik PRODUK, jadi update MUST NOT menimpanya. Ia ditulis hanya ketika belum ada —
-// sama seperti kamar custom, dan dengan alasan yang sama: setelan yang pernah dipilih seseorang bukan
-// milik installer untuk diubah di belakangnya.
+// The document language belongs to the PRODUCT, so update MUST NOT overwrite it. It is written only
+// when absent — same as the custom room, and for the same reason: a setting somebody already chose
+// is not the installer's to change behind their back.
 function setLanguagePolicy(target, { docLanguage, docFilenameLanguage, chosen }) {
   const file = path.join(target, ".control", "registry", "index.yaml");
   if (!fs.existsSync(file)) return;
   const text = fs.readFileSync(file, "utf8");
   const existing = readLanguagePolicy(text);
-  // `chosen` berarti seseorang benar-benar menjawab — di TUI, atau lewat flag eksplisit. Maka
-  // jawabannya berlaku. Tanpa itu nilai yang masuk hanyalah default, dan default MUST NOT menimpa
-  // pilihan yang sudah pernah diambil seseorang.
+  // `chosen` means somebody actually answered — in the TUI, or through an explicit flag. Only then
+  // does the answer take effect. Without it the incoming value is just a default, and a default
+  // MUST NOT overwrite a choice somebody already made.
   if (!chosen && existing.docLanguage && existing.docFilenameLanguage) {
     note(`kept policy.doc_language = ${existing.docLanguage}, ` +
          `doc_filename_language = ${existing.docFilenameLanguage}`);
@@ -530,8 +604,8 @@ function setLanguagePolicy(target, { docLanguage, docFilenameLanguage, chosen })
        `doc_filename_language = ${after.docFilenameLanguage}`);
 }
 
-// Dibaca SEBELUM writeStamp menimpanya. Tanpa ini tidak ada transisi versi yang bisa dicetak, dan
-// "updated" tanpa dari-ke tidak memberi tahu apa pun yang bisa dipakai.
+// Read BEFORE writeStamp overwrites it. Without this there is no version transition to print, and
+// an "updated" with no from-to tells the reader nothing they can use.
 function readStampVersion(target) {
   const file = path.join(target, ".control", "wdi-method.yaml");
   if (!fs.existsSync(file)) return "";
@@ -666,8 +740,16 @@ function apply(target, agents,
                { first, product, client, docLanguage, docFilenameLanguage, languageChosen }) {
   requireKit();
   const was = readStampVersion(target);
+  // MUST run before the kit is written: it moves the product's files out of the way of paths the kit
+  // is about to occupy. Running it after would leave two copies of most guides.
+  const splitConstitution = migrateToTwoFolders(target);
   const { written, skipped } = syncConstitution(target);
   note(`constitution wrote ${written}, kept ${skipped}`);
+  if (splitConstitution) {
+    note("  your constitution.md still carries Articles 3, 4, 6, 7 — now also in method/constitution.md.");
+    note("  Delete them from project/constitution.md; only 1, 2, 5 are yours. Not automated: your");
+    note("  copy may have been edited, and no script can tell an edit from the original.");
+  }
   const skills = syncSkills(target, agents);
   note(`skills ${skills.files} files`);
   const tomls = syncTomls(target);
@@ -742,22 +824,32 @@ function promote(live) {
   if (!fs.existsSync(path.join(live, ".constitution"))) {
     die(`${live} has no .constitution/ — is this a method-carrying repo?`);
   }
-  // README kamar custom dikarang di paket dan MUST bertahan melewati rmSync di bawah. Dibaca di
-  // sini, bukan sesudahnya — versi pertama patch ini membacanya sesudah kit dihapus, sehingga
-  // nilainya selalu null dan README-nya hilang tiap promote. Tes project-room yang menemukannya.
-  const roomKit = path.join(KIT, ".constitution", PROJECT_ROOM, "README.md");
-  const roomKept = fs.existsSync(roomKit) ? fs.readFileSync(roomKit, "utf8") : null;
+  // EVERY file in the room is authored in the package and MUST survive the rmSync below — the room's
+  // README, the generic Articles 1-2-5, and the three empty codebase templates. Read here, not
+  // after: the first version of this preserved only README.md and read it AFTER the kit was deleted,
+  // so it was always null and the file vanished on every promote. Two tests cover it now.
+  const roomKit = path.join(KIT, ".constitution", PROJECT_ROOM);
+  const roomKept = fs.existsSync(roomKit)
+    ? Object.fromEntries(walkFiles(roomKit).map((f) => [posixRel(roomKit, f), fs.readFileSync(f, "utf8")]))
+    : {};
 
   fs.rmSync(KIT, { recursive: true, force: true });
   fs.mkdirSync(KIT, { recursive: true });
 
+  // ONE skip, because 0.5.0 put everything the product owns in one folder. It covers the codebase
+  // guides too, which used to need a rule of their own: promoting a filled-in stack guide would leak
+  // one product's conventions — possibly written in its own `doc_language` — into a public package.
   const nConst = copyTree(path.join(live, ".constitution"), path.join(KIT, ".constitution"),
                           (rel) => rel.startsWith(PROJECT_ROOM));
   note(`constitution ${nConst} files (${PROJECT_ROOM} skipped — it is the product's)`);
-  if (roomKept !== null) {
-    fs.mkdirSync(path.dirname(roomKit), { recursive: true });
-    fs.writeFileSync(roomKit, roomKept, "utf8");
-    note(`${PROJECT_ROOM}README.md restored from the package — promote never carries it home`);
+  for (const [rel, text] of Object.entries(roomKept)) {
+    const dest = path.join(roomKit, rel);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, text, "utf8");
+  }
+  if (Object.keys(roomKept).length) {
+    note(`${PROJECT_ROOM} restored from the package (${Object.keys(roomKept).length} files) — `
+         + "promote never carries the room home");
   }
 
   let copiedSkills = 0;
@@ -785,10 +877,10 @@ function promote(live) {
   note(`bmad custom ${tomls} toml`);
 
   const replacements = {
-    "constitution.md": path.join(KIT, ".constitution", "constitution.md"),
-    "portability.md": path.join(KIT, ".constitution", "method", "portability.md"),
-    "repo-guide.md": path.join(KIT, ".constitution", "repo-guide.md"),
-    "README.md": path.join(KIT, ".constitution", "README.md"),
+    "constitution.md": path.join(KIT, ".constitution", "method", "constitution.md"),
+    "portability.md": path.join(KIT, ".constitution", "method", "why", "portability.md"),
+    "repo-guide.md": path.join(KIT, ".constitution", "method", "repo-guide.md"),
+    "README.md": path.join(KIT, ".constitution", "method", "README.md"),
   };
   for (const [name, dest] of Object.entries(replacements)) {
     const src = path.join(OVERLAY, name);
@@ -847,12 +939,12 @@ async function runWizard(pre) {
 
   const facts = [
     hasBmad
-      ? `BMad Method: terpasang${readBmadVersion(target) ? ` (${readBmadVersion(target)})` : ""}`
-      : "BMad Method: belum terpasang",
-    hasWdi ? "WDI Method: sudah ada — installer akan menawarkan update" : "WDI Method: belum ada",
-    nonempty ? "Folder tidak kosong (repo produk yang sudah jalan itu biasa)" : "Folder masih kosong",
+      ? `BMad Method: installed${readBmadVersion(target) ? ` (${readBmadVersion(target)})` : ""}`
+      : "BMad Method: not installed",
+    hasWdi ? "WDI Method: already present — the installer will offer an update" : "WDI Method: not present",
+    nonempty ? "Folder is not empty (normal for a product repo already under way)" : "Folder is empty",
   ].join("\n");
-  p.note(facts, "Deteksi");
+  p.note(facts, "Detected");
 
   if (!hasBmad && !pre.skipBmad) {
     p.note(bmadMissingMessage(), "BMad first");
@@ -909,11 +1001,11 @@ async function runWizard(pre) {
     }),
   ).trim();
 
-  // Dua pertanyaan, dan hanya dua. Istilah metodologi, kode di depan nama berkas, penanda
-  // machine-facing, dan identifier kode selalu English — MUST NOT ditanyakan.
+  // Two questions, and only two. Method terminology, document code prefixes, machine-facing
+  // markers, and code identifiers are always English — MUST NOT be asked about.
   const policy = readIndexPolicy(target);
-  // Teks bebas, bukan daftar. Tulis apa saja yang dimengerti sebuah model — "English",
-  // "Bahasa Indonesia", "id". Yang ditolak hanya kosong.
+  // Free text, not a list. Write whatever a model understands — "English", "Bahasa Indonesia",
+  // "id". The only value refused is empty.
   const askLanguage = async (message, current) =>
     (cancelIf(
       await p.text({
@@ -1017,7 +1109,7 @@ async function main() {
     return;
   }
   if (args.cmd === "wizard" && !args.yes) {
-    die("bukan TTY. Pakai `install --yes` / `update --yes`, atau jalankan di terminal.");
+    die("not a TTY. Use `install --yes` / `update --yes`, or run this in a terminal.");
   }
   if (args.cmd === "wizard") args.cmd = wdiPresent(requireTarget(args.dir)) ? "update" : "install";
   runNonInteractive(args);