Game paths (WS_GAME_DIR), engine version, number of cached mods, draft folder and log presence.

List mods: published cache in modsStorage (id, versions, latest, kinds, sizes) and developer-mode drafts in modsStorage/draft (draft field). Optional substring filter on id.

Source of a mod. mod_id like 'mod-6gqH17D5rDl' or '6gqH17D5rDl'; version defaults to latest; kind 'lua' or 'prm'. source: 'auto' (developer-mode draft in modsStorage/draft if present, else published cache), 'draft' or 'cache'.

Regex search (case-insensitive) across cached mod code and drafts; returns file:line with context lines.

Query Cache/Projects/WarSelection JSON (gameplay, visual, legacyIds, preload, styles, main, render, interfaces/...). Use path like 'build[10].costBuilding' or 'auras.0', or key_search (regex over keys and string values).

Search the API index: the live dump imported with import_api_dump (current engine) when present, with the bundled index as fallback (wsunitstats.com WSUS tree v258.4018 + verified notes from the api-cheatsheet). kind: 'function', 'event', 'field' or 'note'. Result index shows which is active.

Search the bundled Russian modding guide (guide-ru.md); returns section, line and snippet.

Tail of a game log (default gen/log.txt; also log_prev.txt, lagDiagnostics.log, ...) searched in likely locations; optional regex filter. Reports clearly where it looked if the log is missing. WS_LOG_PATH overrides the location.

Static check of mod Lua code (pass code, or mod_id of a cached mod): Lua 5.4 syntax plus known War Selection pitfalls (math.random in gameplay mods, missing root.f_recreateModifiedUnitTypes(), visual mods changing game state, math.atan2, removed/renamed functions, unknown addMod events, undefined handlers, unknown f_* names with suggestions). kind: auto | gameplay | visual. With mod_id, source: auto (draft if present, else cache) | draft | cache.

Unified diff between two cached versions of a mod (default: previous vs latest). draft=true compares published version v1 (default latest) with the developer-mode draft in modsStorage/draft.

Parse Lua errors in gen/log.txt ('Lua program ... run (Error) failed' blocks and [string "..."]:N: lines), group repeats, and map them to cached mods (chunk preview match + mods active at that moment). tail limits to the last N log lines; since is 'YYYY-MM-DD[ HH:MM[:SS]]' in log time.

Real usages of an API name across cached mods with file:line context, e.g. 'f_addCircle', 'landscape.zones.f_addCircle', 'root.f_recreateModifiedUnitTypes'. Underscore paths are matched too.

Which addMod events each cached mod registers (latest versions), with totals per event. Optional event filter, e.g. 'onUnitInZone'.

Starter code built from guide recipes taken from working mods (returned, never written). Call without template to list templates: blank_gameplay, blank_visual, zone_trigger, unit_death, special_command_pair, unit_stat_tweak.

Find unit types by legacy id or asset path substring (legacyIds.json) with their build rules from gameplay.json (cost, health). Example: 'worker', '201', 'airplane'.

Lua script for the in-game developer console / a dev-mode mod that dumps the root API tree into gen/log.txt as WSDUMP lines (read-only: indexes fields under pcall, never calls f_* functions). root: start path ('root', 'root.unitType[0]', 'root.session.visual'); space: 'gameplay' (gameplay mod root) or 'visual' (visual mod root). seeds=true embeds known names from the active index so removed names are detected even if the engine does not allow pairs(). compact=true returns one line for the console. Arrays are sampled (array_sample elements) and written as []. Then call import_api_dump.

Parse WSDUMP lines from gen/log.txt (or which='log_prev.txt', or an explicit file), build the live API index and report the diff against the bundled WSUS v258.4018 index (added / removed / changed paths, unexplored subtrees to dump next). Writes only to the per-user data folder (WS_MCP_DATA_DIR, default %LOCALAPPDATA%/war-selection-mcp), never to the game folder. Dumps of different subtrees are merged; a new engine version replaces the old index (backup kept). dry_run=true writes nothing. A dump without END is refused unless allow_partial=true.

Which API index is active (live dump or bundled), its engine version, entry counts, imported dumps, and whether it is stale compared to engine-version.txt in the game folder.

Store a snapshot of the game state in the user data folder (never the game folder): hashes of all Cache/Projects/WarSelection JSON files and engine-version.txt, normalized content of gameplay.json, visual.json, legacyIds.json, main.json, render.json, preload.json, and the active API index. Skipped when nothing changed since the latest snapshot unless force=true. Also taken automatically on server start.

Structured diff between two snapshots (default: previous vs latest; a/b accept a snapshot id, id prefix or engine version). Sections: changed files, unit types (legacyIds), build rules (cost, health, ...), researches and upgrades, auras, unit overrides, API index added/removed/changed signatures. Takes a new snapshot first if the game changed. With a single snapshot it explains that the next update produces the diff. The full diff is written to the data folder (diffs/).

Which cached mods and drafts reference what changed between two snapshots: removed/renamed unit type ids (unitType[id]), changed build rules (build[i]), researches/upgrades ([i]), removed or changed API functions and fields. Returns file:line with the code line and the reason.

Follow gen/log.txt: returns lines written since cursor and next_cursor for the next call. Without a cursor returns the last initial_lines lines. Detects the log being recreated at game start (rotated=true) and first returns the unread rest of the old session from log_prev.txt.

Start a background watcher on gen/log.txt (from the current end, or from_start=true). It parses Lua run/compile errors and engine warnings, maps them to the draft or cached mod source (explicit /modsStorage path or [string "..."] chunk preview) with a code excerpt, and survives log recreation at game start. Read events with watch_log_poll.

New watcher events after since_seq (use next_seq from the previous call). Each event: seq, kind (lua_error, compile_error, warning, engine_error), time, script, message, frames, source (mod, draft/cache, file, line, excerpt).

Stop the background log watcher. Collected events stay available to watch_log_poll.

WRITE: overwrite the existing draft modsStorage/draft/_-.lua of a mod (latest draft version by default). The game creates that file when the mod script is opened with 'edit script' in developer mode; this tool never creates files and never touches published files in modsStorage. The previous content is backed up to the user data folder (draft-backups). Save/apply in the game.