wdi-method 0.4.3 → 0.4.6

package/kit/.constitution/document/delivery-flow-guide.md

@@ -159,7 +159,7 @@ MUST NOT be negotiated.
 
 ## Gate checklists
 
-Each question is answered **ya / tidak / ubah**. One "tidak" on a ★ question holds the gate.
+Each question is answered **yes / no / change**. One "no" on a ★ question holds the gate.
 
 **On `mode: catalog`, only the ★ questions are asked** — fourteen across all five gates. The rest stay here
 as material, and asking them is never wrong; requiring them is.

package/kit/.constitution/document/templates/cross-cutting.md

@@ -53,17 +53,17 @@ updated: '{YYYY-MM-DD}'
      one component depends on it. corpus-guide.md owns that test, and it refuses the one use people
      reach for: "the owner is hard to decide".
 
-     `Jenis` is data · endpoint · job · screen, and the list is open. What is not open is the test.
+     `Kind` is data · endpoint · job · screen, and the list is open. What is not open is the test.
 
      `_platform` has no `FR`, so there is no owner-FR for another component to point at. What replaces
      "one writer" is ONE DOCUMENTED SHAPE — stated here, once. A component that wants it different is
      proposing a change to this file, not making a local choice. -->
 
-| Apa | Jenis | Kenapa tidak ada komponen yang menjelaskannya | Siapa yang menyentuhnya | Bentuk yang setiap penyentuh patuhi |
+| What | Kind | Why no component explains it | Who touches it | The shape every toucher obeys |
 | --- | --- | --- | --- | --- |
 
-<!-- `Siapa yang menyentuhnya` menyebut komponen, dan menyebut lebih dari satu adalah keadaan NORMAL —
-     itu separuh alasan barisnya ada di sini. Satu penyentuh adalah sinyal ia milik komponen itu. -->
+<!-- `Who touches it` names components, and naming more than one is a NORMAL state — that is half the
+     reason the row is here. A single toucher is a signal it belongs to that component instead. -->
 
 ## Other product-level agreements
 

package/kit/.constitution/document/templates/model.md

@@ -32,8 +32,8 @@ updated: '{YYYY-MM-DD}'
 
 ## Relationships
 
-<!-- Direction and cardinality. State them as sentences a person would say: "satu member punya nol
-     atau satu sponsor". -->
+<!-- Direction and cardinality. State them as sentences a person would say: "one member has zero
+     or one sponsor". -->
 
 ## State Lifecycle
 

package/kit/.constitution/document/templates/questions.md

@@ -6,7 +6,7 @@ created: '{YYYY-MM-DD}'
 updated: '{YYYY-MM-DD}'
 ---
 
-# {Pertanyaan yang Memblokir | Asumsi | Menunggu Pihak Luar | Terjawab}
+# {Blocking Questions | Assumptions | Waiting on an Outside Party | Answered}
 
 <!-- TEMPLATE GUIDE — act on these comments, then delete them.
 
@@ -30,8 +30,9 @@ updated: '{YYYY-MM-DD}'
      A ROW MOVES BETWEEN FILES WHEN ITS CLASS CHANGES, and it MUST NOT be copied into a second one.
 
      Ids stay OQ-, allocated from the highest ever used including closed ones. An id MUST NOT be
-     reused. The literal values inside the tables stay Bahasa Indonesia — [BELUM DITETAPKAN] and the
-     rest — wherever they appear, including inside an English template. -->
+     reused. The prose inside the tables follows the product's `doc_language`; a machine-facing
+     marker such as `[NEEDS CONFIRMATION]` stays English wherever it appears — `language-guide.md`
+     owns that split. -->
 
 ## The class test
 
@@ -47,26 +48,26 @@ updated: '{YYYY-MM-DD}'
 
      A question MUST NOT be filed as blocking "to be safe". That habit is what produced 146 ids. -->
 
-## Terbuka
+## Open
 
 <!-- list: blocking · external -->
 
-| id | Pertanyaan | Memblokir | Owner | Sebelum |
+| id | Question | Blocks | Owner | Before |
 |---|---|---|---|---|
 
 <!-- list: assumptions — keep this shape instead
-| id | Asumsi | Akibat kalau salah | Diambil | Oleh |
-|---|---|---|---|---|
+| id | Assumption | Cost if wrong | Taken | By |
+|---|---|---|---|---|---|
 -->
 
 <!-- An empty list is a legitimate state and MUST be written as one, with the date and one line
      saying why. An empty table with no sentence reads as an unfinished file. -->
 
-## Terjawab
+## Answered
 
 <!-- list: answered only.
 
-     | id | Pertanyaan | Jawaban | Tanggal | Oleh |
+     | id | Question | Answer | Date | By |
 
      The answer is written beside the question, not in place of it. The record of what was once
      uncertain is what stops the same question being asked again in three months.

package/kit/.constitution/document/templates/srs.md

@@ -66,7 +66,7 @@ reviewed:                # V13. Diisi hanya setelah bmad-review benar-benar dija
 
 | id | Use case | Actor | Satisfies | critical |
 | --- | --- | --- | --- | --- |
-| UC-{n} | {a sentence a user would say} | {from the Actor Register} | {FR-n} | tidak |
+| UC-{n} | {a sentence a user would say} | {from the Actor Register} | {FR-n} | no |
 
 ## Constraints · [G3]
 
@@ -106,7 +106,7 @@ reviewed:                # V13. Diisi hanya setelah bmad-review benar-benar dija
 
 ## Gate Checklist · [G3]
 
-<!-- The gate questions as they apply to THIS component, answered ya / tidak / ubah. The full list
+<!-- The gate questions as they apply to THIS component, answered yes / no / change. The full list
      lives in delivery-flow-guide.md and MUST NOT be copied here. At mode: catalog only the starred
      questions are asked. -->
 

package/kit/.constitution/scripts/inventory.py

@@ -3,32 +3,33 @@
 # requires-python = ">=3.11"
 # dependencies = ["pyyaml>=6"]
 # ///
-"""inventory — menurunkan tiga inventaris dari kode, lalu mengadunya dengan rencananya.
+"""inventory — derives the three inventories from code, then compares them against the plan.
 
-Tiga inventaris — tabel, endpoint, layar — adalah keluaran G3 Blueprint dan ADA pada setiap `mode`,
-termasuk `catalog`. Mereka lahir dua cara, dan `derived_from` di frontmatter menyatakan yang mana:
+The three inventories — tables, endpoints, screens — are a G3 Blueprint output and EXIST at every
+`mode`, including `catalog`. They are born two ways, and `derived_from` in the frontmatter states
+which one:
 
-    plan   belum ada kode. Ditulis sebagai RENCANA oleh wdi-blueprint. Tidak ada yang bisa
-           diturunkan, karena belum ada sumbernya.
-    code   kodenya sudah ada. Diturunkan LEBIH DULU oleh script ini, lalu diadu dengan rencananya.
+    plan   no code yet. Written as a PLAN by wdi-blueprint. Nothing can be derived,
+           because there is no source yet.
+    code   the code already exists. Derived FIRST by this script, then compared against the plan.
 
-Selisih rencana-versus-kenyataan adalah TEMUAN, dan ia dilaporkan. Ia MUST NOT ditambal dengan
-menyunting sisi yang lain — itu mengubah pekerjaan yang bisa terlupa jadi pekerjaan yang pasti
-terlupa. Script ini karena itu punya dua mode dan yang pertama adalah defaultnya:
+A plan-versus-reality gap is a FINDING, and it is reported. It MUST NOT be patched over by
+editing the other side — that turns work that could be forgotten into work that definitely
+will be. This script therefore has two modes, and the first is the default:
 
-    inventory --check    turunkan, adu, laporkan. TIDAK menulis satu berkas pun
-    inventory --write    tulis ulang bagian ## Rows dari apa yang diturunkan, lalu laporkan selisihnya
+    inventory --check    derive, compare, report. Writes NOT ONE file
+    inventory --write    rewrite the ## Rows section from what was derived, then report the gap
 
-Determinisme adalah kontraknya, sama seperti validate.py: dua run atas kode yang sama MUST memberi
-hasil yang sama. Karena itu semua iterasi terurut dan tidak ada yang bergantung pada jam dinding.
+Determinism is the contract, same as validate.py: two runs over the same code MUST produce the
+same result. That is why every iteration is ordered and none depends on the wall clock.
 
-BATAS YANG DINYATAKAN DI MUKA. Ini pembaca pola, bukan compiler. Ia membaca:
-    tabel     pernyataan CREATE TABLE di src/internal/platform/migrate/migrations/*.sql
-    endpoint  registrasi route pada router Gin di src/**/*.go
-    layar     komponen route pada SPA React di web/*/src/**/*.tsx
-Apa yang tidak terbaca pola itu dilaporkan sebagai yang tidak terbaca — TIDAK ditebak, dan TIDAK
-dihilangkan diam-diam. Sebuah inventaris MUST NOT dirakit dari README atau dari nama route yang
-tampak masuk akal.
+THE STATED-UP-FRONT LIMIT. This is a pattern reader, not a compiler. It reads:
+    table     CREATE TABLE statements in src/internal/platform/migrate/migrations/*.sql
+    endpoint  route registrations on the Gin router in src/**/*.go
+    screen    route components in the React SPA in web/*/src/**/*.tsx
+Whatever the pattern cannot read is reported as unread — NOT guessed, and NOT silently
+dropped. An inventory MUST NOT be assembled from a README or from a route name that merely
+looks plausible.
 """
 
 from __future__ import annotations
@@ -41,15 +42,15 @@ from pathlib import Path
 
 KINDS = ("db", "api", "screen")
 
-# ------------------------------------------------------------------ pola baca
+# ------------------------------------------------------------------ read patterns
 
-# CREATE TABLE [IF NOT EXISTS] `nama` | nama
+# CREATE TABLE [IF NOT EXISTS] `name` | name
 RE_TABLE = re.compile(
     r"CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`\"]?([A-Za-z_][A-Za-z0-9_]*)[`\"]?",
     re.I)
 RE_DROP_TABLE = re.compile(
     r"DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?[`\"]?([A-Za-z_][A-Za-z0-9_]*)[`\"]?", re.I)
-# PRIMARY KEY / UNIQUE / FOREIGN KEY — kolom kunci, bukan seluruh kolom
+# PRIMARY KEY / UNIQUE / FOREIGN KEY — key columns, not every column
 RE_KEYCOL = re.compile(
     r"(?:PRIMARY\s+KEY|UNIQUE(?:\s+KEY)?|FOREIGN\s+KEY)[^(\n]*\(([^)]*)\)", re.I)
 
@@ -58,11 +59,11 @@ RE_ROUTE = re.compile(
     r"\.\s*(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*\(\s*[`\"]([^`\"]+)[`\"]", re.I)
 RE_GROUP = re.compile(r"\.\s*Group\s*\(\s*[`\"]([^`\"]+)[`\"]", re.I)
 
-# Sebuah route group DIBUAT di satu berkas dan DIPAKAI di berkas lain:
+# A route group is CREATED in one file and USED in another:
 #     portal.go:26   mountMemberAPI(engine.Group("/api"), ...)
 #     member_api.go  api.GET("/me", ...)
-# Karena itu prefiks TIDAK dapat disimpulkan per berkas. Ia harus mengikuti mount-nya, dan host-nya
-# ikut dari titik pasang di app.go. Pola di bawah yang membuat penelusuran itu mungkin.
+# Because of that, a prefix CANNOT be inferred per file. It must follow its mount, and the host
+# comes along from the mount point in app.go. The patterns below are what make that trace possible.
 RE_FUNC_DEF = re.compile(r"^func\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)", re.M)
 # mux.Handle(cfg.HostPublic, routing.NewPublicWithStore(...)) -> host `public`, entry NewPublicWithStore
 RE_HOST_MOUNT = re.compile(
@@ -89,9 +90,9 @@ RE_ROUTE_TSX = re.compile(
 
 @dataclass
 class Row:
-    key: str                      # identitas stabil baris, dipakai membandingkan
+    key: str                      # the row's stable identity, used for comparison
     cells: list[str]
-    source: str                   # berkas tempat ia terbaca
+    source: str                   # the file where it was read
 
 
 @dataclass
@@ -111,11 +112,11 @@ RE_DOWN = re.compile(r"^\s*--\s*\+(?:goose|migrate)\s+Down\b", re.I | re.M)
 
 
 def up_section(text: str) -> str:
-    """Hanya bagian Up sebuah migrasi.
+    """Only a migration's Up section.
 
-    Bagian Down memuat DROP TABLE untuk setiap tabel yang Up-nya membuat, jadi membaca seluruh berkas
-    membuat setiap tabel terbaca sebagai dibuang. Pemisahannya MUST terjadi SEBELUM komentar
-    dibuang, karena penanda goose sendiri adalah komentar.
+    The Down section holds a DROP TABLE for every table its Up creates, so reading the whole
+    file makes every table read as dropped. This split MUST happen BEFORE comments are
+    stripped, because the goose marker itself is a comment.
     """
     match = RE_DOWN.search(text)
     return text[:match.start()] if match else text
@@ -126,15 +127,15 @@ def strip_sql_comments(text: str) -> str:
     return "\n".join(re.sub(r"(--|#).*$", "", line) for line in text.splitlines())
 
 
-# --------------------------------------------------------------------- tabel
+# --------------------------------------------------------------------- table
 
 
 def table_owner(root: Path) -> dict[str, str]:
-    """Pemilik tiap tabel, dibaca dari `owns` dan `platform_owns` di components.yaml.
+    """Every table's owner, read from `owns` and `platform_owns` in components.yaml.
 
-    Kolom pemilik BISA diturunkan sejak nilai `owns` disetel, jadi menuliskannya sebagai
-    [NEEDS CONFIRMATION] akan menandai sebagai tidak diketahui sesuatu yang registry sudah nyatakan.
-    Yang tidak diklaim siapa pun tetap [NEEDS CONFIRMATION] — itu temuan, bukan celah.
+    The owner column CAN be derived as soon as an `owns` value is set, so writing it as
+    [NEEDS CONFIRMATION] would flag as unknown something the registry has already stated.
+    Whatever no one claims stays [NEEDS CONFIRMATION] — that is a finding, not a gap in the rule.
     """
     import yaml as _yaml
     path = root / ".control/registry/components.yaml"
@@ -155,10 +156,10 @@ def derive_db(root: Path) -> Derived:
     owner = table_owner(root)
     folder = root / "src/internal/platform/migrate/migrations"
     if not folder.is_dir():
-        out.unread.append(f"{folder.as_posix()} tidak ada — tidak ada migrasi yang bisa dibaca")
+        out.unread.append(f"{folder.as_posix()} does not exist — no migration can be read")
         return out
 
-    created: dict[str, tuple[str, str]] = {}   # tabel -> (kolom kunci, berkas)
+    created: dict[str, tuple[str, str]] = {}   # table -> (key columns, file)
     dropped: set[str] = set()
     for path in sorted(folder.glob("*.sql")):
         body = strip_sql_comments(up_section(read(path)))
@@ -184,10 +185,10 @@ def derive_db(root: Path) -> Derived:
                                    f"`{who}`" if who else "[NEEDS CONFIRMATION]",
                                    "[NEEDS CONFIRMATION]", keys, "published"]))
         if not who:
-            out.unread.append(f"tabel `{name}` tidak diklaim `owns` maupun `platform_owns` — "
-                              f"V21 tidak melihatnya, dan tidak ada yang berwenang menulisnya")
+            out.unread.append(f"table `{name}` is claimed by neither `owns` nor `platform_owns` — "
+                              f"V21 does not see it, and no one is authorized to write it")
     if dropped:
-        out.unread.append("tabel yang di-DROP di bagian Up dan karena itu tidak didaftarkan: "
+        out.unread.append("tables dropped in the Up section and therefore not registered: "
                           + ", ".join(sorted(dropped)))
     return out
 
@@ -196,7 +197,7 @@ def derive_db(root: Path) -> Derived:
 
 
 def _go_funcs(root: Path) -> tuple[dict[str, str], list[str]]:
-    """Tiap fungsi Go di src/ dengan body-nya, plus daftar berkas yang dibaca."""
+    """Every Go function in src/ with its body, plus the list of files read."""
     bodies: dict[str, str] = {}
     files: list[str] = []
     for path in sorted((root / "src").rglob("*.go")):
@@ -215,11 +216,12 @@ def _go_funcs(root: Path) -> tuple[dict[str, str], list[str]]:
 def _walk(fn: str, host: str, prefix: str, router_vars: dict[str, str],
           bodies: dict[str, str], out: dict[tuple[str, str, str], str],
           seen_calls: set[tuple[str, str, str]], depth: int = 0) -> None:
-    """Telusuri satu fungsi: catat route-nya, lalu ikuti mount yang ia pasang.
+    """Walk one function: record its routes, then follow the mounts it sets up.
 
-    Sebuah fungsi MAY dipasang dari lebih dari satu host — `mountSharedPublicReads` dipanggil dari
-    `member_api.go` DAN `public_api.go` — jadi rekursi ini sengaja tidak memoisasi per fungsi,
-    hanya per (fungsi, host, prefiks). Tanpa itu, endpoint pada host kedua hilang tanpa jejak.
+    A function MAY be mounted from more than one host — `mountSharedPublicReads` is called from
+    `member_api.go` AND `public_api.go` — so this recursion deliberately does not memoize per
+    function, only per (function, host, prefix). Without that, the endpoints on the second host
+    disappear without a trace.
     """
     if depth > 8 or (fn, host, prefix) in seen_calls:
         return
@@ -258,7 +260,7 @@ def _walk(fn: str, host: str, prefix: str, router_vars: dict[str, str],
 def derive_api(root: Path) -> Derived:
     out = Derived()
     if not (root / "src").is_dir():
-        out.unread.append("src/ tidak ada — tidak ada registrasi route yang bisa dibaca")
+        out.unread.append("src/ does not exist — no route registration can be read")
         return out
 
     bodies, files = _go_funcs(root)
@@ -268,9 +270,9 @@ def derive_api(root: Path) -> Derived:
             entries.append((host.lower(), fn))
     if not entries:
         out.unread.append(
-            "tidak satu pun titik pasang host terbaca (pola `Handle(cfg.Host<X>, <Fn>(`) — "
-            "seluruh path di bawah ini MUST diperiksa tangan, sebab prefiks group tidak dapat "
-            "ditelusuri tanpa titik pasangnya")
+            "not one host mount point was read (pattern `Handle(cfg.Host<X>, <Fn>(`) — "
+            "every path below MUST be checked by hand, since a group's prefix cannot be "
+            "traced without its mount point")
 
     found: dict[tuple[str, str, str], str] = {}
     for host, fn in sorted(set(entries)):
@@ -285,8 +287,8 @@ def derive_api(root: Path) -> Derived:
                             cells=[host, method, f"`{path_str}`", owner,
                                    "[NEEDS CONFIRMATION]", "published"]))
     if not found:
-        out.unread.append("tidak satu pun registrasi route terbaca di src/**/*.go — "
-                          "bila API-nya memang belum ada, `derived_from: plan` yang benar")
+        out.unread.append("not one route registration was read in src/**/*.go — "
+                          "if the API genuinely does not exist yet, `derived_from: plan` is correct")
     return out
 
 
@@ -294,13 +296,13 @@ def derive_screen(root: Path) -> Derived:
     out = Derived()
     folder = root / "web"
     if not folder.is_dir():
-        out.unread.append("web/ tidak ada — tidak ada halaman yang bisa dibaca")
+        out.unread.append("web/ does not exist — no page can be read")
         return out
 
-    # KUNCINYA (spa, rute), BUKAN rute saja. Produk ini punya dua SPA yang dibangun terpisah, dan
-    # keduanya mendeklarasikan `/`, `/login`, dan `*`. Mengunci pada rute saja menghilangkan yang
-    # kembar tanpa suara: 26 layar terbaca sebagai 23. Sebuah rute bukan identitas sebuah layar di
-    # produk ber-SPA jamak — hostnya bagian dari identitas itu.
+    # THE KEY IS (spa, route), NOT the route alone. This product has two SPAs built separately,
+    # and both declare `/`, `/login`, and `*`. Keying on the route alone silently collapses the
+    # duplicates: 26 screens read as 23. A route is not a screen's identity in a product with
+    # multiple SPAs — the host is part of that identity.
     seen: dict[tuple[str, str], tuple[str, str]] = {}
     for path in sorted(folder.rglob("*.tsx")):
         if "node_modules" in path.parts or path.name.endswith(".test.tsx"):
@@ -320,7 +322,7 @@ def derive_screen(root: Path) -> Derived:
 
     for spa, route in sorted(seen):
         if route in states:
-            continue  # ia keadaan dari layar lain, bukan baris tersendiri
+            continue  # it is a state of another screen, not a row of its own
         component, rel = seen[(spa, route)]
         extra = folded.get(f"{spa}:{route}") or []
         state_cell = ", ".join(f"`{r}`" for r in sorted(extra)) if extra else "—"
@@ -331,16 +333,16 @@ def derive_screen(root: Path) -> Derived:
     orphan = sorted(r for r in states
                     if not any(states[r] == route for _, route in seen))
     if orphan:
-        out.unread.append("rute-keadaan yang induknya tidak terbaca di kode: " + ", ".join(orphan))
+        out.unread.append("state-routes whose parent was not read in the code: " + ", ".join(orphan))
     if not seen:
-        out.unread.append("tidak satu pun <Route path=... element={<X />}> terbaca di web/**/*.tsx")
+        out.unread.append("not one <Route path=... element={<X />}> was read in web/**/*.tsx")
     else:
         shared = sorted({r for _, r in seen} & {r for s, r in seen if s != sorted({x for x, _ in seen})[0]})
         dupes = sorted({r for s, r in seen} )
         collide = sorted({r for r in dupes if sum(1 for s2, r2 in seen if r2 == r) > 1})
         if collide:
-            out.unread.append("rute yang dideklarasikan LEBIH DARI SATU SPA, dan karena itu bukan "
-                              "identitas layar dengan sendirinya: " + ", ".join(collide))
+            out.unread.append("routes declared by MORE THAN ONE SPA, and therefore not a "
+                              "screen's identity on their own: " + ", ".join(collide))
     return out
 
 
@@ -352,7 +354,7 @@ HEADERS = {
 }
 
 
-# ------------------------------------------------------- rencana yang tercatat
+# ------------------------------------------------------- the recorded plan
 
 
 ROW_RE = re.compile(r"^\|\s*(\d+)\s*\|(.*)\|\s*$")
@@ -360,14 +362,14 @@ FM_RE = re.compile(r"\A---\n(.*?)\n---", re.S)
 
 
 def decisions(path: Path) -> tuple[dict[str, str], set[str]]:
-    """(`states`, `platform_rows`) dari frontmatter — keputusan pemilik, bukan hasil pola.
+    """(`states`, `platform_rows`) from frontmatter — the owner's decision, not a pattern result.
 
-    `states` memetakan rute-keadaan ke rute layar induknya. Sebuah keadaan BUKAN layar: ux-guide
-    sudah menuntut tiap layar punya keadaan kosong dan error, jadi keadaan adalah kolom pada baris
-    induknya, bukan baris kedua.
+    `states` maps a state-route to its parent screen's route. A state is NOT a screen: ux-guide
+    already demands every screen have an empty and an error state, so a state is a column on its
+    parent's row, not a second row.
 
-    `platform_rows` menyebut baris yang dimiliki `_platform`. Tidak ada janji Product Component di
-    belakangnya, dan corpus-guide memiliki tes dua-bagiannya.
+    `platform_rows` names rows owned by `_platform`. There is no Product Component promise
+    behind them, and corpus-guide owns their two-part test.
     """
     if not path.exists():
         return {}, set()
@@ -385,7 +387,7 @@ def decisions(path: Path) -> tuple[dict[str, str], set[str]]:
 
 
 def plan_rows(path: Path) -> tuple[dict[int, list[str]], str | None]:
-    """Baca bagian ## Rows dari inventaris yang tercatat. None bila berkasnya belum ada."""
+    """Read the ## Rows section from the recorded inventory. None if the file does not exist yet."""
     if not path.exists():
         return {}, None
     text = read(path)
@@ -408,17 +410,17 @@ def plan_rows(path: Path) -> tuple[dict[int, list[str]], str | None]:
 
 
 def plan_keys(kind: str, rows: dict[int, list[str]]) -> dict[str, int]:
-    """Identitas stabil baris rencana, disusun sama dengan Row.key hasil derivasi."""
+    """Stable identity of a plan row, built the same way as the derived Row.key."""
     out: dict[str, int] = {}
     for number, cells in sorted(rows.items()):
         if kind == "db" and cells:
             out[cells[0].strip("`")] = number
         elif kind == "api" and len(cells) >= 3:
-            # Host bagian identitas: satu fungsi mount MAY dipasang di lebih dari satu host, dan
-            # tanpa host di kunci kedua endpoint itu melebur jadi satu baris.
+            # The host is part of the identity: one mount function MAY be mounted on more than
+            # one host, and without the host in the key the two endpoints collapse into one row.
             out[f"{cells[0]} {cells[1].upper()} {cells[2].strip('`')}"] = number
         elif kind == "screen" and len(cells) >= 2:
-            # Screen ditulis `<spa>/<Component>`; spa-nya bagian identitas, sama seperti di derivasi.
+            # A screen is written `<spa>/<Component>`; the spa is part of the identity, same as in derivation.
             screen = cells[0].strip("`")
             spa = screen.split("/", 1)[0] if "/" in screen else "?"
             out[f"{spa}:{cells[1].strip('`')}"] = number
@@ -426,10 +428,10 @@ def plan_keys(kind: str, rows: dict[int, list[str]]) -> dict[str, int]:
 
 
 def render_rows(kind: str, derived: Derived, keys: dict[str, int]) -> str:
-    """Nomor STABIL: baris yang sudah punya nomor mempertahankannya, yang baru mengambil berikutnya.
+    """STABLE numbering: a row that already has a number keeps it; a new one takes the next.
 
-    Menomori ulang berarti mengganti nama setiap berkas sesudahnya dan mematahkan setiap tautan yang
-    menunjuk ke arahnya, jadi ia MUST NOT dilakukan — juga ketika baris di tengah menghilang.
+    Renumbering means renaming every reference to it afterward and breaking every link that
+    points to it, so it MUST NOT be done — even when a row in the middle disappears.
     """
     next_no = max(keys.values(), default=0) + 1
     lines = ["| " + " | ".join(HEADERS[kind]) + " |",
@@ -446,8 +448,8 @@ def render_rows(kind: str, derived: Derived, keys: dict[str, int]) -> str:
 def write_rows(path: Path, block: str) -> None:
     text = read(path)
     if "## Rows" not in text:
-        raise SystemExit(f"inventory: {path.as_posix()} tidak punya bagian `## Rows` — "
-                         f"lahirkan dulu dari templates/inventory.md")
+        raise SystemExit(f"inventory: {path.as_posix()} has no `## Rows` section — "
+                         f"give it birth first from templates/inventory.md")
     head, _, rest = text.partition("## Rows")
     tail = ""
     for marker in ("\n## ",):
@@ -464,19 +466,19 @@ def write_rows(path: Path, block: str) -> None:
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
         prog="inventory",
-        description="Turunkan tiga inventaris dari kode, lalu adu dengan rencananya")
+        description="Derive the three inventories from code, then compare against the plan")
     parser.add_argument("--check", action="store_true",
-                        help="turunkan dan laporkan; tidak menulis apa pun (default)")
+                        help="derive and report; write nothing (default)")
     parser.add_argument("--write", action="store_true",
-                        help="tulis ulang bagian ## Rows dari hasil derivasi")
+                        help="rewrite the ## Rows section from the derived result")
     parser.add_argument("--kind", choices=KINDS, action="append",
-                        help="batasi ke satu jenis; boleh diulang")
-    parser.add_argument("--root", default=".", help="akar repo (default: direktori sekarang)")
+                        help="restrict to one kind; may be repeated")
+    parser.add_argument("--root", default=".", help="repo root (default: current directory)")
     args = parser.parse_args(argv)
 
     root = Path(args.root).resolve()
     if not (root / ".control" / "registry").is_dir():
-        print(f"inventory: {root} tidak punya .control/registry/ — salah akar repo?", file=sys.stderr)
+        print(f"inventory: {root} has no .control/registry/ — wrong repo root?", file=sys.stderr)
         return 2
 
     kinds = args.kind or list(KINDS)
@@ -491,35 +493,35 @@ def main(argv: list[str] | None = None) -> int:
 
         print(f"\n=== {kind} — {rel}")
         if mode is None:
-            print("  berkasnya belum ada. Lahirkan dari templates/inventory.md; sampai itu terjadi "
-                  "tidak ada rencana yang bisa diadu")
+            print("  the file does not exist yet. Give it birth from templates/inventory.md; "
+                  "until that happens there is no plan to compare against")
         else:
-            print(f"  derived_from: {mode} · {len(recorded)} baris tercatat")
-        print(f"  {len(derived.rows)} baris terbaca dari kode")
+            print(f"  derived_from: {mode} · {len(recorded)} rows recorded")
+        print(f"  {len(derived.rows)} rows read from code")
 
         derived_keys = {row.key for row in derived.rows}
-        missing = sorted(set(keys) - derived_keys)      # direncanakan, tidak ada di kode
-        extra = sorted(derived_keys - set(keys))        # ada di kode, tidak direncanakan
+        missing = sorted(set(keys) - derived_keys)      # planned, not present in code
+        extra = sorted(derived_keys - set(keys))        # present in code, not planned
 
         for item in missing:
-            print(f"  TEMUAN  direncanakan tetapi tidak terbaca di kode: {item}")
+            print(f"  FINDING  planned but not read in code: {item}")
         for item in extra:
-            print(f"  TEMUAN  ada di kode tetapi tidak tercatat di rencana: {item}")
+            print(f"  FINDING  present in code but not recorded in the plan: {item}")
         for note in derived.unread:
-            print(f"  TIDAK TERBACA  {note}")
+            print(f"  UNREAD  {note}")
         findings += len(missing) + len(extra)
 
         if args.write:
             if not path.exists():
-                print("  --write dilewati: berkasnya belum ada")
+                print("  --write skipped: the file does not exist yet")
                 continue
             write_rows(path, render_rows(kind, derived, keys))
-            print(f"  tulis {rel} — bagian ## Rows saja")
+            print(f"  wrote {rel} — the ## Rows section only")
 
-    print(f"\n{findings} selisih rencana-versus-kode.")
+    print(f"\n{findings} plan-versus-code gaps.")
     if findings:
-        print("Selisih ini TEMUAN, bukan pekerjaan tangan. Ia dirutekan ke skill yang memiliki "
-              "sisinya, dan MUST NOT ditambal dengan menyunting sisi yang lain.")
+        print("This gap is a FINDING, not hand work. It is routed to the skill that owns "
+              "its side, and MUST NOT be patched over by editing the other side.")
     return 1 if findings else 0