world-of-claudecraft / scripts

<!-- scripts/: standalone Node tooling (gate, build, browser E2E, screenshot tours,
     multiplayer integration, SFX/asset pipelines, PR automation, admin utils).
     Not part of the vite/esbuild build. Root CLAUDE.md covers the repo + sim/server
     model; don't repeat it here. Child docs: scripts/assets/ (GLB pipeline),
     scripts/assets/battleground/ (Thornhollow builder), scripts/asset_pipeline/
     (AI asset generation), scripts/profiler/ (client profiling),
     scripts/sfx_studio/ (SFX Studio). -->

# scripts/

Standalone Node ESM tooling, **not** compiled into the vite/esbuild bundles. Mostly plain
`.mjs` run via `node scripts/<name>.mjs`; a few DB-migration/sim tools are `.ts` run via
`tsx` (e.g. `sim:nythraxis-matrix` runs `nythraxis_matrix.ts`; see `package.json`). A module
imported by a type-checked Vitest suite carries a hand-written `.d.mts` next to the `.mjs`
(e.g. `malware_scan.d.mts`). The table below maps the load-bearing groups, not every script:
`package.json` is the wiring truth, and many scripts run directly with no npm alias.

## What runs where
- **Browser scripts** use `puppeteer-core` + `browser_path.mjs` and need `npm run dev`
  (:5173). They launch headless Chrome/Edge with `--use-angle=swiftshader` and drive
  the real game via the `window.__game` global (`__game.sim`, `.hud`, `.input`, `.renderer`).
- **Multiplayer scripts** use `ws` + `fetch` against a running `npm run server` (:8787).
  Override host with `SERVER_URL=` / `GAME_URL=`.
- **Server bots that teleport/level/grant** (`dev_teleport`, `dev_level`, `dev_give`)
  need the server started with `ALLOW_DEV_COMMANDS=1`, **dev only** (see root invariants).
- **Admin utils** talk straight to Postgres via `DATABASE_URL` (call `process.loadEnvFile()`,
  so a local `.env` works); they do not need the server.
- Screenshot tours write PNGs into `tmp/` (gitignored). They typically god-mode the
  player so camp mobs don't kill the camera.

## Scripts by purpose
| Group | Files | Needs |
|---|---|---|
| Gate / CI | The step and selection CONTRACTS live in `docs/qa-gate.md` ("Selective PR-tier CI", "Generated i18n artifacts", "Known-flake handling"); this row is the script-to-lib-to-test map plus the traps. `gate.mjs` (`npm run gate`, the full merge bar) and `gate_select.mjs` (`node scripts/gate_select.mjs`, the fast pre-merge bar) share one step list (`lib/gate_steps.mjs`, kept in sync with `.github/workflows/ci.yml`; on a `release/**` branch it adds the release-tier i18n step over `I18N_RELEASE_TIER_SUITES`, pinned three ways by `tests/release_i18n_tier_coverage.test.ts`). Both start with two preflights (`lib/gate_preflight.mjs`): the npm-ls lockfile-sync check (pure parse in `lib/npm_install_sync.mjs`) and an ffmpeg/ffprobe execution probe (resolution: `sfx/ffmpeg_paths.mjs`), because a drifted local install otherwise surfaces minutes later as a confusing tsc/build failure and never in CI (pins: `tests/dependency_sync_gate_preflight.test.ts`, `tests/sfx_gate_preflight.test.ts`, `tests/npm_install_sync.test.ts`). Pure generate steps run through the turbo task cache (`lib/gate_task_cache.mjs`: never caches a test result, and the i18n freshness diff always runs after `i18n:gen` so a cache restore cannot hide drift from committed artifacts); the gate generates artifacts once, then sets `WOC_SKIP_PRETEST=1` for its vitest step (`lib/gate_artifact_skip.mjs`; standalone `npm test` still regenerates). Workers: `lib/gate_workers.mjs`, memory sensor `lib/gate_memory.mjs` (darwin sums vm_stat free+inactive+speculative pages because `os.freemem()` sits near zero on a healthy Mac and would serialize the suite). `gate_select.mjs` substitutes ONLY the vitest step: ONE merged `vitest related` leg on POSIX (floor seeds + changed paths; win32 keeps the classic floor-run legs because vitest related cannot match unslashed seeds there). The always-run floor is every suite whose coverage leaves the module graph (disk scans, subprocesses, dynamic imports: `tests/architecture.test.ts` imports no `src/`, so `vitest related` alone would silently skip it), classified by `lib/test_visibility.mjs` and recomputed from source each run so it cannot go stale; discovery and branch-diff collection in `lib/gate_discovery.mjs`. The diff is taken against the BRANCH base via `resolveSelectBase` (env override, then newest `origin/release/*`, then `origin/main`, then `origin/HEAD`; an unresolvable base or a failing `git diff` is a hard stop, never an empty changed set; NEVER `@{upstream}`, which after `git push -u` is the branch's own pushed copy diffed against itself). Planner: `lib/gate_select_plan.mjs` (pinned by `tests/gate_select_plan.test.ts`); its `isFullSuiteTrigger` deliberately does NOT reuse `gate_fast_plan.mjs`'s `isBroadConfigPath`, which means the OPPOSITE thing there (exclude from `--changed`, not force the full suite) and still names the removed `package-lock.json`, never `pnpm-lock.yaml`. Day loop: `gate_fast.mjs` (`npm run gate:fast`; pure plan `lib/gate_fast_plan.mjs`); its biome step and `.githooks/pre-push` both run `ci_changed.mjs` (`npm run ci:changed`; base resolver `lib/ci_changed_base.mjs`, pinned by `tests/ci_changed_base.test.ts`). Validation, not a gate: `gate_shadow.mjs` runs selection AND the full suite over one tree and reports escapes. CI side: `detect_code_changes.mjs` classifies the PR file listing (`lib/ci_change_classify.mjs`) and derives a fail-closed `test_mode` (`lib/ci_test_select.mjs`); each shard runs `ci_shard_test.mjs` (plan: `lib/ci_shard_plan.mjs`; `--plan-only` prints a shard's decision), and legs execute through `lib/ci_leg_runner.mjs`, which applies the ONE sanctioned known-flake retry (the teardown-rpc signature via `lib/teardown_rpc_flake.mjs`, at most once per job, shard/lane legs only; release-gate, the nightly, and the local gate never retry anything). Two selection carve-outs: regenerated i18n artifact slices classify into their own `generatedI18n` bucket, and the three committed build manifests (SFX, guide content, media) into `generatedManifests`; both feed `vitest related` as graph nodes, because their consumer suites hang off the ARTIFACT side of the import graph while the driving sources are type-erased or fs-read build inputs. Deletions, renames, subdirectory paths under the artifact dirs, and every OTHER `.generated` path still widen to the full suite; the freshness proofs (check-job diffs plus the local gate's `i18n freshness` and `manifest freshness` steps) are welded to the classifier lists by `tests/ci_workflow.test.ts`. Pins: `tests/ci_test_select.test.ts`, `tests/ci_shard_plan.test.ts`, `tests/ci_selection_pipeline.test.ts`, `tests/ci_change_classify.test.ts`, `tests/ci_workflow.test.ts`, `tests/teardown_rpc_flake.test.ts`, `tests/ci_leg_runner.test.ts`. Nightly backstop: full gate per ref, never selective; pure plan `lib/nightly_plan.mjs` (thin entries `nightly_targets.mjs`/`nightly_report.mjs`; pinned by `tests/nightly_plan.test.ts`; a red run lands in exactly ONE tracking issue and a green run closes it). Checkout-stall auto-rerun: `.github/workflows/ci-stall-rerun.yml` drives `ci_stall_rerun.mjs` over `lib/ci_stall_rerun.mjs` (pinned by `tests/ci_stall_rerun.test.ts`): it reruns a stall-killed job only on attempt 1 and only when the dead setup step is the sole failure, so it can never mask a real red; the driver is hand-runnable against a stalled run. NO npm alias for `gate_select.mjs` or `ci_shard_test.mjs`, deliberately: `tests/fenbridge_town_assets.test.ts` fingerprints all of `package.json` as a shipping-GLB input, so a new script entry invalidates the asset and demands re-exporting the whole fingerprinted family (or narrowing that fingerprint) in the same change. Release mint: `release_mint.mjs vX.Y.Z` is THE settings step at every new release branch (re-points the merge-queue ruleset include with a before/after audit dump; local gh admin login required by design, see docs/merge-queue.md "Minting a release branch"; skipping it is how the queue went silently dormant for three releases). Queueing from the CLI: `gh pr merge` fails on the queue-protected branches (auto-merge API is disabled); use the `enqueuePullRequest` GraphQL mutation (exact command in docs/merge-queue.md). Worktree hygiene: after teammate PRs land a pnpm-patched dependency, a stale node_modules reds `tests/three_compile_async_patch.test.ts` with a re-run-pnpm-install hint; `pnpm install --frozen-lockfile` in the worktree IS the fix. Measurement: `gate_profile.mjs`. | none (bundled FFmpeg) |
| Build | `build_media_manifest.mjs` (`generate` to `manifest.generated.ts`, `emit` to `dist/media`), `build_sitemap.mjs` (`sitemap:build`), `build_sfx_manifest.mjs` (`sfx:manifest`), `check_backdrop_survival.mjs` (post-`vite build` check): all run inside `npm run build`. `build_server.mjs` / `build_bot.mjs` esbuild-bundle the server and bot (`npm run server` / `npm run bot`). | none |
| Asset (FBX to GLB) | `combine_fbx_to_glb.mjs` (+ `combine_fbx_to_glb_entry.js`): merge a rigged character's FBX files (mesh + per-action animation FBXs, or one multi-take FBX) into one `.glb` with every clip. Parses FBX via headless three.js `FBXLoader`/`GLTFExporter` (skinning and embedded textures work where Node CLI converters fail), grafts clips by bone name, then gltf-transform. `--help` lists the flags (folder mode, `--base`/`--anim`, strip options, `--meshopt`/`--webp`). | local Chrome (`browser_path.mjs`) |
| Anim clip baking | `build_*_anims.mjs` one-off clip bakers per rig family (workflow: the `blender-anim-pipeline` skill); shared pure timeline/pose math in `anim/pose_blend.mjs` (+ `.d.mts`, pinned by `tests/pose_blend.test.ts`). | varies |
| Item art / icons (2D) | `convert_item_icons_webp.mjs` (`assets:items`): drop hand-authored raster art into `public/ui/items/`, run it, commit; each image is normalized to the `ICON_SIZE` WebP square declared in `public/ui/items/mapping.json` and the original is deleted, so the committed tree stays WebP-only and nothing converts at build time (`tests/item_icons.test.ts` fails on a committed non-webp and on a derived item id without art + provenance). Siblings: `assets:skills`/`assets:deeds`/`assets:professions`/`assets:chrome`, plus `assets:mapbg` (`build_map_backgrounds.mjs`). Audit tools: `item_art_audit.mjs` and `icon_asset_audit.mjs` (pure cores in `lib/`, pinned by `tests/item_art_audit_builder.test.ts` / `tests/icon_asset_audit.test.ts`); mob portrait tooling shares the `lib/mob_portrait_*` family. | none |
| SFX / audio | `sfx_conform.mjs` (`sfx:check` gate / `sfx:conform` = `--fix`; bundles `ffmpeg-static`/`ffprobe-static`) enforces the asset standard in `docs/design/sound_effects.md` (canonical home for the format/loudness/channel/naming rules); loudness/format/bitrate fail the gate, channel/naming are advisory unless `--strict`. Pure rules/manifest logic in `scripts/sfx/` (`sfx_conform_rules.mjs`, `sfx_manifest_builder.mjs`); generators `gen_sfx.mjs` (`sfx:gen`, conforms + downmixes each clip), `gen_ui_sfx.mjs` (`sfx:ui`), `gen_npc_voices.mjs`/`gen_npc_lines.mjs` (+ `voices/`), `render_music.mjs` (+ `music_render_entry.ts`); the SFX Studio `sfx_studio/` (`sfx:studio`, playback/encode spawns the bundled static `ffmpeg` via `sfx/ffmpeg_paths.mjs` with PATH fallback; its export conformance validation binds to `ffmpeg-static`/`ffprobe-static` directly, no fallback and no `WOC_FFMPEG_PATH`/`WOC_FFPROBE_PATH` override, so the verdict always matches the `sfx:check` toolchain; own CLAUDE.md; tutorial: `docs/sfx-studio-tutorial.md`) | varies (API keys; `gen_ui_sfx.mjs` still defaults to PATH `ffmpeg`) |
| Guide / wiki (`wiki/`) | `wiki/build_content.mjs` (bundles `src/sim` content into `src/guide/content.generated.ts`; `wiki:content`, in `pretest`/`build`; imports `wiki/family_guard.mjs`, the bestiary FAMILY_ORDER guard shared with `tests/guide.test.ts`, and `wiki/vendor_channel.mjs`, the pattern acquisition-channel derivation shared the same way: the generator and the guide test each used to re-derive the identical Set, so the shared module is what stops them drifting, and the per-arm literal exemplars stay as independent anchors so the shared derivation cannot become self-comparing), `wiki/render_model_stills.mjs` (+ `wiki/still_key.mjs`, `wiki/stills_render_entry.js`: headless-Chrome pre-render of the bestiary/class still WebPs into `public/guide-stills/`; `wiki:stills`, deliberately NOT in `build`. `tests/guide.test.ts` gates BOTH directions (every figure with a model has a committed WebP, AND no orphan WebP without a figure). Stills are deterministic per machine but NOT byte-identical across GPUs/drivers, so they are existence-gated, never diff-gated: re-render on the `--use-angle=swiftshader` path), `wiki/apply_guide_locales.mjs` (maintainer fill of `guide.*` prose into the locale overlays) | browser binary (stills only) |
| Browser E2E (offline) | `smoke_browser.mjs`, `smoke_mage.mjs`, `smoke_rogue.mjs`, `check_directions.mjs` | dev |
| MP E2E (browser) | `mp_browser.mjs`, `mp_combat_visibility.mjs`, `market_mp_e2e.mjs` | dev + server |
| MP integration (ws) | `mp_integration.mjs`, `chat_e2e.mjs`, `chat_log_persistence.mjs`, `social_e2e.mjs`, `crypt_raid.mjs` | server (+`ALLOW_DEV_COMMANDS=1` for raid) |
| Season 1 Armory | `armory_skins_e2e.mjs` (ws: buy/apply/wire/reconnect), `armory_visual_e2e.mjs` (browser: browse/inspect/buy/apply + screenshots), `armory_thumbs.mjs` (+ `armory_thumbs_entry.js`: pre-render the store thumbnails to `public/ui/store/armory/`), `browser_path_resolve.mjs` (lazy browser resolver for the asset pipeline) | server + economy service (+ dev for visual) / none (thumbs) |
| Security | `ws_security_e2e.mjs` (server), `malware_scan.mjs` (release-gate malicious-code flagger over the whole tree): `security:scan` exits 1 on ANY finding (most are expected false positives an agent triages); `security:gate` (CI) fails only on a HIGH finding surviving the path-aware priors (catalog: `docs/security/malware-scan-catalog.md`) | server / none |
| PR screenshots | `pr_screenshots.mjs` + `pr_shot_targets.mjs` produce the before/after PR screenshots the root workflow requires (captured locally and committed under `docs/screenshots`, never posted by CI); `pr_shot_targets.mjs` owns the change-aware path-to-screen mapping. Full recipe: the `pr-screenshots` skill. | dev |
| Perf / profiling | `profile.mjs` (scenario CLI, see its `SCENARIOS` map) over `scripts/profiler/` (own CLAUDE.md); `perf_baseline.mjs` (`perf:baseline`, graphics-preset baseline bench: fixed scenario suite, avg FPS + CPU/GPU via `profiler/system_sampler.mjs`, history + frozen-baseline verdicts in `docs/perf/baseline/`, headless parity shots + pixel diff; pure record/compare logic in `lib/perf_baseline_store.mjs`, pinned by `tests/perf_baseline_store.test.mjs`); `perf_hitch.mjs` (frozen frame-consistency referee for first-draw stalls, GC stutter, and heap ratchet; average FPS deliberately stays with `perf_baseline.mjs`; pure halves in `lib/perf_hitch_*.mjs`, pinned by `tests/perf_hitch_soak.test.mjs`, `tests/perf_hitch_store.test.mjs`, `tests/perf_hitch_crowd_reset.test.mjs`); `perf_tour.mjs` (`perf:tour`), `crowd_fps_bench.mjs` (`perf:crowd`), `prewarm_travel_bench.mjs` (`perf:prewarm`), `server_load_jitter.mjs` (`perf:load`), `load_professions.mjs` (`perf:professions`: the R36 professions 1,000-connection baseline capture; recipe in `docs/design/player-performance/professions-load-baseline.md`; pure halves in `lib/prof_load_util.mjs` and the shared `lib/loopback_guard.mjs`, pinned by `tests/prof_load_util.test.ts` and `tests/loopback_guard.test.ts`); the crowd, jitter, and professions gates share `lib/bench_gate.mjs`, pinned by `tests/bench_gate.test.ts`; `nythraxis_hitch_bench.mjs` (no npm alias; headed Chrome, same-checkout A/B of the encounter prewarm via `?encounterPrewarm=0`, reusing the `profiler/geared_arrival_roster.mjs` crowd; pure halves in `lib/nythraxis_hitch_bench.mjs`, pinned by `tests/nythraxis_hitch_bench.test.mjs`). Read its header before adding a phase: the arena entry pad sits OUTSIDE the server's mob interest radius, both legs are parked in a start zone that has never compiled the encounter NPC's model, and gap attribution refuses to credit a mark that fires all window long (the boss track calls `play()` about four times a second, which once sent an investigation down a wrong path). Every Node WS client sends chat and its `/dev` cheats through `lib/world_auth.mjs` `chatCommandMessage`: a top-level `{t:'chat'}` frame matches nothing in the server's command switch and is dropped in silence, which left five perf scripts measuring bots that were never levelled, geared or god-moded (scanned by `tests/world_auth_scripts.test.ts`); `feel_smoke.mjs` (`feel:smoke`), `asset_budget.mjs` (`asset:budget`); `live_program_hunt.mjs` (no npm alias; serves THIS worktree's dev client proxied to the production realm, purging the vite cache first, opens a headed Chrome for a manual online session, polls `perfStats().gpuPrep` live-program events plus the loopback render diagnostics that name materials, and writes one aggregated report at the end; pure aggregation in `lib/live_program_hunt_report.mjs` (+ `.d.mts`), pinned by `tests/live_program_hunt_report.test.ts`; procedure: the `hunt-live-programs` skill); `shader_harvest.mjs` + `shader_link_bench.mjs` (no npm alias; the pair that prices shader compilation per program. The harvest serves this worktree's dev client, enters the OFFLINE world by itself and walks a scripted tour, every zone, dungeon, dev raid, mount and ability VFX, once per graphics profile, recording the final GLSL of every program of every GL context through an init-script hook, `lib/shader_harvest_hook.mjs`; identity is a hash of the TEXT, never three's cache key, because several hosts bake JS values into their GLSL under one key. It proves its own fidelity by reading every world program back from the driver, and its report names the authored shader files whose own uniform names were never harvested: the tour's to-do list. The bench reads that corpus with no game and no dev server, links each program alone on a scratch context with salted texts and blocks on the link status, so it runs unchanged on a Windows box to measure the D3D11 cost; pure halves `lib/shader_harvest_corpus.mjs` and `lib/shader_link_bench_report.mjs` (+ `.d.mts`), pinned by `tests/shader_harvest_corpus.test.ts` and `tests/shader_link_bench_report.test.ts`) | dev (some + server) |
| Screenshot tours | `visual_tour.mjs`, `arena_visual.mjs`, `market_visual.mjs`, `social_visual.mjs`, `tour_expansion.mjs` | dev (some + server) |
| SEO / homepage / i18n | `homepage_verify.mjs`, `seo_audit.mjs`, `localization_e2e.mjs` (locale-matrix homepage E2E) | dev (+ server) |
| i18n pipeline | `i18n_build.mjs`+`i18n_admin_build.mjs` (resolved tables), `i18n_scan.mjs` (status registry), `i18n_resolved_hash.mjs` (`i18n:hash`, print-only diagnostic: prints locales/bytes/sha256 for ad-hoc byte-equivalence comparison; no committed baseline, the committed line-item locale slices plus the CI freshness diff and the determinism tests enforce equivalence), `i18n_coverage_summary.mjs` (CI step, posts the coverage counts to the GitHub job summary); seed `i18n_blocked_seed.mjs` owns `V07_SLASH`/`COPIED_ALLOW_IDS`; `i18n_pseudo.mjs` (en_XA dev pseudo-locale), `i18n_modulepreload.mjs` (lazy-locale boot modulepreload); `i18n_fill_worklist.mjs` (`i18n:worklist`, emits the gitignored `docs/i18n-scaling/worklist/` for the maintainer release fill) | `i18n:gen` |
| Scaffold / release | `new_endpoint.mjs` (`new:endpoint`, scaffolds a `RouteDef` module on the `server/http/` pipeline, see `server/http/CLAUDE.md`), `release_version.mjs` (`release:check`/`release:prepare`), `version_sync.mjs` (`version:sync`), `electron-dev.mjs`/`electron-build.mjs` (`electron:*`; both bundle vendor deps via `electron-vendor.mjs`) | none |
| Data export | `export_loot_spreadsheet.mjs` (esbuild-bundles `src/sim` to a loot sheet in `docs/`) | none |
| Admin / dev utils | `grant_admin.mjs`, `create_gm.mjs`; one-off DB migrations are `.ts` via `tsx` (`db:*` scripts) | `DATABASE_URL` |
| Production ops | `prod_cpu_monitor*.mjs` (supervised CPU incident capture + immutable in-image PID/profile helpers) | exact-command restricted SSH access to the production container; optional mode-0600 staff token for `ops.perf` tick detail |
| Local realms | `dev-realms.mjs` (launches built server processes) | built server (`npm run realms`) |
| Helper | `browser_path.mjs` (resolves Chrome/Edge/Chromium; override `BROWSER_PATH=`), shared pure helpers in `lib/` | none |

The full gate serializes only its `vitest (full suite)` step through the exclusive loopback
listener in `lib/gate_lock.mjs` (issue #2808). `lib/gate_child.mjs` owns the child process
group and finishes handled termination before the listener is released. A contended run
identifies the protocol holder, an unrelated service on the reserved port fails open, and
`GATE_NO_LOCK=1` opts out; `gate_select.mjs` and `gate_fast.mjs` never acquire this lock.

## Conventions (verifiable patterns to copy)
- ws scripts inline `mergeSelf`/`mergeEnts` to reconstruct delta snapshots
  (`DELTA_SELF_KEYS`, `ENTITY_IDENTITY_KEYS`, `snap.keep`). Match the wire field
  names exactly (`tid`, `lv`, `res`, `gcd`, ...), they mirror the server snapshot.
- E2E scripts track pass/fail via a local `check(name, cond, extra)` and
  `process.exit(fail > 0 ? 1 : 0)`; browser scripts also collect `pageerror`/console-error.
- Character names are letters-only (classic rule), scripts derive an `alpha` suffix
  from a base-36 timestamp so reruns don't collide.

## How to add one (module-first)
- **Where new script logic lands:** any logic worth a unit test, or needed by a second
  script, goes in a pure Node module (`scripts/lib/` or the subsystem dir, e.g.
  `scripts/sfx/`) with a hand-written `.d.mts` so a type-checked Vitest imports it
  directly; the entry script stays a thin orchestrator (CLI parsing, puppeteer/ws).
  Pattern: `profiler/metrics.mjs` (pure, tested in `tests/profiler_metrics.test.mjs`) +
  `profiler/harness.mjs` (orchestration); `sfx/sfx_conform_rules.mjs` (+ `.d.mts`,
  tested in `tests/sfx_conform.test.ts`). Don't clone another 300-line monolith.
- **Browser E2E / tour:** copy `smoke_browser.mjs` / `visual_tour.mjs`; import
  `BROWSER_PATH` from `./browser_path.mjs`, read state through `window.__game`,
  `mkdirSync('tmp')` before screenshots. Offline shot and tour scripts enter the running
  game via `enterOfflineGame` (`scripts/enter_offline_game.mjs`), which also dismisses the
  intro, tutorial, and camera-prompt overlays that must never appear in a captured
  screenshot, rather than re-implementing the entry flow.
- **MP integration:** copy `mp_integration.mjs`; reuse its `Client` class + merge helpers.

## Never
- These run directly under Node, not through the vite/esbuild build; keep deps Node-only
  (`ws`, `pg`, `puppeteer-core`). Most never touch `src/`. Scripts that need sim or i18n
  data bundle the TS with `esbuild` themselves (e.g. `export_loot_spreadsheet.mjs` and the
  `i18n_*` builders); follow that pattern and never `import` the TS sources raw.
- Don't hand-edit the generated i18n artifacts: regenerate with `npm run i18n:gen` and
  commit the regenerated line-item slices (canonical model, including how the freshness
  diff carries the byte-equivalence signal: `src/ui/CLAUDE.md`).

More agent context in levy-street/world-of-claudecraft

36 other files this repository gives its agents.