Unity command-line workflow¶

Historical workflow and evidence: The batch descriptions below describe earlier source revisions; their passing results do not validate the current overhaul. For the current ability import, CLI command, environment requirements and scoped results, start with the Unity CLI report, playable-path report and handoff. Preserve the current package, settings and profile bytes before a run; restore only changes caused by that run.

Checked on 2026-10-24 from this Linux machine. Yes: the agent can edit this Unity project and invoke the installed Unity CLI/Editor directly. Import/compilation and a Linux IL2CPP player build completed with exit code 0. The graphical player reaches Tutorial with repaired pause/settings navigation and two verified MainMenu returns, and starts early Meadow gameplay with HUD, movement, enemies, damage, score, and advancing timers. Meadow pause/resume, confirmation cancellation, retry, and repeated arena return are player-verified. Batch 17 verifies Steam-unavailable local game-over results/save completion, and batch 18 verifies one-player level-up pause/selection/application/resume. Batch 20 verifies Meadow game-over cancellation/focus, retry, and MainMenu return. Batch 21 verifies MainMenu quit/corner Exit cancellation/focus and actual application exit. Batch 23 additionally verifies core settings values/Apply, pause/Back/resume, Tutorial and migrated child navigation. Batch 24 verifies saved graphics restoration, fullscreen/windowed/launch overrides and the affected cold handoff. Remaining controller-refresh/prompts, Database/focus, later-stage menu bindings and Windows/display acceptance remain incomplete. The logo-skip startup deadlock is now repaired and player-verified; other startup failure paths, a full gameplay pass, and Windows Steam acceptance remain unresolved.

Current owner constraint: build/validate locally for Linux; production Windows IL2CPP builds will happen on another PC. Windows platform support on this workstation is not required for local stabilization. Batch 01 adds an Editor-only regression runner; its three groups failed before the fixes and passed afterward. The original capability inventory below is an initial snapshot, not a claim that no validation tooling has since been added.

Batch 02 adds asynchronous Play Mode checks in an empty scene. Run the Editor directly without -quit, using -executeMethod TinyChaos.EditorTools.StabilizationChecks.RunBatch02; the runner owns exit after domain reload and real coroutine checks. The popup is tested with game time paused while Editor/player-loop execution continues. The final four checks pass, with Unity Version Control configuration and shutdown diagnostics still requiring disposition (TOOL-01).

Batch 03 verifies the real reward-import method using temporary in-memory stage/catalog data. Use the synchronous CLI command below with -executeMethod TinyChaos.EditorTools.StabilizationChecks.RunBatch03. Basic stage filters failed before the patch and all three check groups passed afterward (exit 0). This does not enter Play Mode or validate selectable-stage content/reward UI. The generator warning persists; the prior Version Control errors did not recur in these runs.

Batch 04 uses -executeMethod TinyChaos.EditorTools.StabilizationChecks.RunBatch04. It reads the real boot catalog in a preview scene and calls UnlockStage against cloned stages/characters, suppressing save IO. Seven content/method groups pass after scene/progression corrections (1/7 before). Scene-destination checks validate configuration rather than loading arenas or executing menu animations. The runner intentionally logs that resource saving is disabled; persistence is outside this check.

Batch 05 built the current dirty candidate with the CLI's built-in build command, preserving IL2CPP. A real 1280×720 OpenGL player launch with a disposable fresh/offline profile reproduced GAME-16/17 and the separate CONTENT-09 changelog failure. Startup-complete logging is not proof that the menu is usable.

Batch 06 adds -executeMethod TinyChaos.EditorTools.StabilizationChecks.RunBatch06: early character enable, readiness, selection-independent disable cleanup, and scene-controller binding checks. They pass 4/4 after the fixes (1/4 before). The rebuilt graphical Linux IL2CPP player records successful character and menu initialization with no logged exceptions. Its 61.867-second logo interval still needs focus/background/time-scale and frame/stack measurements; that interval is not a resolved freeze.

Batch 07 reuses that exact built assembly without a rebuild. It samples the candidate window's focus every half second and times native DiscordCreate with debugger entry/return breakpoints. The foreground logo takes 3.363 seconds; minimizing only the verified candidate for eight seconds increases it to 11.552 seconds. Record foreground/background state before treating wall-clock coroutine duration as a freeze. The native call was fast in both probes; no other Discord calls or Windows startup paths were cleared by that measurement. A later navigation exception led to GAME-18, repaired at the binding level in batch 08.

Batch 08 uses -executeMethod TinyChaos.EditorTools.StabilizationChecks.RunBatch08. Four groups check the existing Tutorial handler binding, actual persistent-event dispatch with scene loading guarded, nine remaining page arguments, and Tutorial scene inclusion/import. Results improve from 1/4 to 4/4. RuntimeOnly events require a temporary EditorAndRuntime override on the disposable preview to exercise dispatch in Edit Mode; never save that override. There was no new player build or real Tutorial entry/playthrough, and the batch-06 artifact predates the scene fix.

Batch 09 rebuilds the repaired scene into a Linux IL2CPP candidate (exit 0) and exercises the visible Tutorial button through PID/window/focus-checked X11 inputs. Entry, opening dialogue, and movement work; three recorded pause actions reproduce GAME-19 in ShowSettings, alongside missing panel/TabManager script warnings. The logo interval is 3.256 seconds with 7/7 focused samples. Saves remain isolated. Full Tutorial completion/menu return, arena gameplay, and the reported Steam freeze remain unverified.

Batch 10 adds -executeMethod TinyChaos.EditorTools.StabilizationChecks.RunBatch10: five scene-component groups, four actual settings-tab event groups, Tutorial pause/resume, and panel argument types. The corrected same-harness result is 0/11 before and 11/11 after. Preview EventSystems require scoped registration rather than assigning an unknown instance to EventSystem.current; the runner restores the registry. Linux IL2CPP build exits 0, and the player verifies Tutorial pause/settings/tab navigation/Back/resume. Confirmed menu return then fails under GAME-20; full settings-value/Apply behavior and gameplay remain pending.

Batch 11 adds -executeMethod TinyChaos.EditorTools.StabilizationChecks.RunBatch11. Five scene-entry fixtures exercise cold activation and paused/unpaused/repeated initializer readiness (2/5 before, 5/5 after); real transition/Start coverage comes from the rebuilt Linux player. A fresh launch completes its logo in 3.267 seconds and returns from paused Tutorial twice, logging time scale 1 and three menu initializations. Another launch stalled after a logo-skip marker for 88.578 focused seconds; it is not a passing startup result. SDK construction also logs three Discord errors in the successful-return probe. GAME-13/NET-02 own those remaining findings. An interrupted launch supplied no validation evidence.

Batch 12 adds asynchronous RunBatch12, using the matching Editor directly without -quit. It tests the real parent/child logo sequence and skip methods in an empty Play Mode fixture. A scoped 1/60-second capture step stabilizes correctness timing; restore it alongside time scale/background policy and do not interpret it as performance data. Final normal/phase/repeated/multiple skip checks improve from 1/6 to 6/6. The Linux IL2CPP build and both real-clock startup controls pass: normal logo 3.348 seconds, deliberately skipped sequence complete 0.228 seconds after skip, both reaching visible menus. SDK constructor errors remain NET-02; the reported Steam/Windows freeze is not certified resolved.

Batch 13 adds synchronous RunBatch13 for all five difficulty launch targets, preserved integer mappings, and guarded persistent-event dispatch (1/3 before, 3/3 after). Scene-only Linux rebuild succeeds; the same native assembly now loads Meadow and its default Soldier through actual Normal selection. The arena then remains inactive/paused-looking under GAME-22, with gate-sequence warnings under GAME-23. Source/class checks and a visible player do not prove a playable run. Normal-profile bytes/hashes remain unchanged in this batch, including engine preferences.

Batch 14 builds the runtime handoff repair and verifies it in two fresh Linux IL2CPP probes. Matching full native symbols permit read-only preparation/pause/timer inspection: original readiness is complete but paused with inactive zero timers; repaired early gameplay is unpaused with all timers advancing. Direct attach was rejected; launching the owned candidate as a debugger child avoids changing global ptrace policy. Record debugger interruptions as probe effects. Paired screenshots verify leftward travel; an alive-player Escape still fails under GAME-24. The longer probe reaches death and aborts on Save.Nickname's unguarded Steam API getter (CONTENT-04). No new Editor fixture or full-run pass is claimed; normal-profile bytes/hashes remain unchanged.

Batch 15 uses direct-Editor asynchronous RunBatch15: five in-memory routing groups plus normal/paused Play Mode groups for all six UI animation methods (4/7 before, 7/7 after). The Linux IL2CPP player verifies MainMenu exit-confirmation Cancel and two visible Meadow pause/resume cycles; native timer values stay equal while paused and advance after resume. Settings still does not navigate under GAME-24. Editor package exceptions are recorded separately from assertions. Four engine session preference values are reviewed/restored from pre-run bytes; the isolated player leaves the normal profile unchanged.

Batch 16 adds direct-Editor asynchronous RunBatch16 in the Editor-only TransitionChecks partial runner. Corrected original checks are 1/6, repaired 6/6: confirmation references/routes/guarded preview dispatch and normal/paused/overlapping gate coroutines. An invalid first singleton fixture is excluded and its crash artifact archived outside Git. The Linux player verifies confirmation No/Escape, one Meadow retry, two arena returns, and final MainMenu Cancel; locked-sequence warnings fall from two to zero. Normal-profile engine session changes are reviewed/restored from bytes, and player profiles remain isolated. No game-over/full-run or Windows pass is claimed.

Batch 17 uses synchronous RunBatch17 for Steam-unavailable nickname/score admission (1/3 → 3/3). Linux IL2CPP reaches visible death results and writes matching local progress; a second process logs loading the profile. A second completed accumulation run and online/Windows behavior remain unverified.

Batch 18 adds direct-Editor asynchronous RunBatch18 in RewardFlowChecks. Common reward-state, real-time display, reroll, menu-pause/queue ownership, marker/confirmation, and resume checks improve 9/17 → 17/17. Existing RunBatch15 pause checks remain 7/7. Empty pools and a stand-in card isolate state behavior. The Linux IL2CPP player additionally earns a real level-up, navigates/confirms by keyboard, applies damage 10 → 17, and resumes time 00:35 → 00:37. Real reroll/chest/boss rewards, repeats, co-op, and Windows remain unverified. The wrapper's partial focus sampling does not cover the entire run; exact executable/PID/window/focus guards cover each input and screenshot. Normal-profile engine session changes are reviewed and restored from bytes.

Batch 20 extends synchronous RunBatch20 in TransitionChecks: result ownership, six imported actions, actual preview dispatch/focus/cancel with guarded Yes, and pause controls (1/4 → 4/4). After Page gains explicit hidden/entered interaction ownership, legacy RunBatch10 passes 11/11 with Meadow's intentional GamePanel count adjusted to five, and RunBatch15 passes 7/7. The final Linux IL2CPP player verifies result No/Back, two ordinary reward confirmations/deaths, one retry, and MainMenu return. MainMenu's unrelated null quit-button targets are observed and remain open; only its keyboard quit-page Back is verified. Initial/superseded builds and input-timing mistakes are recorded separately from passing evidence. Normal-profile bytes and unrelated edits are preserved.

Batch 21 adds synchronous RunBatch21 in MainMenuQuitChecks. Original routing/ownership checks pass 1/5; the final expanded harness passes 5/5, including safe focus, repeated initialization, actual event dispatch with guarded Yes, configured-owner replacement/observer preservation, page-pop ordering, and existing result/pause controls. It restores original navigation modes in six result buttons after a previous over-broad YAML replacement. The Linux build succeeds; fresh and post-arena players verify mouse/keyboard cancellation and actual Yes quits with one request and exit 0 each. Configured menu navigation uses A/D, not Left/Right aliases. Normal-profile bytes remain unchanged.

Batch 22 adds synchronous TinyChaos.EditorTools.StabilizationChecks.RunBatch22Audit in SettingsAudit.cs. The six-scene preview audit completes with terminal exit 0 and writes /tmp/tinychaos-batch22-settings-audit.json; this is collection success, not a Settings pass. It verifies absent Meadow controls, incomplete/competing retained interfaces, and unresolved arena Settings routes. No runtime changes or new player build are included; batch 21 remains the latest player artifact.

Batch 23 adds synchronous TinyChaos.EditorTools.StabilizationChecks.RunBatch23 in SettingsFlowChecks.cs. Original 0/5 groups fail; expanded final 7/7 pass. Core checks include disposable config IO, repeat listener lifecycle, silent values/custom-switch presentation, pending applied state, child pause ownership, imported tab/confirmation controls and actual P2/credits dispatch. Existing legacy/Tutorial and quit suites pass 11/11 and 5/5. Linux IL2CPP players verify loaded/edited values, paused Apply, persisted volume, native child contents/Back/focus, clean resume and actual returns/quits. The final delivery build lives at /tmp/tinychaos-batch23-linux/TinyChaos.x86_64. Read the batch for provenance, excluded intermediate failures and remaining graphics-startup policy; do not equate these checks with full Settings/controller/platform acceptance.

Batch 24 adds synchronous TinyChaos.EditorTools.StabilizationChecks.RunBatch24 in GraphicsStartupChecks.cs. Original 0/6 groups fail; expanded 9/9 pass. Settings/entry/logo controls pass 7/7, 5/5 and 6/6. AppInitiator now awaits graphics; a native trial exposes and leads to repair of activation-disabled scene loading waiting for isDone. Five completed Linux IL2CPP cases verify fresh/saved resolution/fullscreen/VSync, paused fullscreen Apply, session overrides without config overwrite, subsequent restoration and actual quits. The guarded physical fullscreen window is 1920×1080 while Unity renders at the selected 640×360. Artifact /tmp/tinychaos-batch24-linux/TinyChaos.x86_64; read the batch for provenance, timings, authoritative exits, excluded overlap/trial and engine-pref restoration. Do not infer the Steam freeze's cause from these samples.

Runtime diagnostics¶

PlayerSettings has usePlayerLog: 1, so standard Unity player logging is enabled. Existing Debug.Log/Warning/Error calls cover startup, logo loading/completion/skip, scene activation, menu initialization, and arena start. Probe launchers use -timestamps and explicit temporary -logFile destinations.

Batch 19 adds GameDiagnostics to that existing log. It is off by default; enable with the exact launch argument -tinyChaosTrace. [TCTrace] lines identify the launch session, build/version/platform, monotonic elapsed milliseconds, sequence, and subsystem/event. Timed operations have correlated begin/end/failure markers and duration, independent of game time. Failure records include exception type rather than its message; the original exception still propagates. The new trace stops after 512 ordinary events plus one warning, without stopping gameplay/save operations. Existing Unity messages are outside that cap.

Coverage: outer startup and its Steam/service/save/settings/menu stages, actual scene-loaded events, modern save disk IO and player/config processing, reward enqueue/phases/reroll/confirmation, changed game-state flags, and applied time scale. Legacy stream-by-stream migration, every ability/spawn event, controller events, and background-thread diagnostics are not covered. No per-frame heartbeat or remote telemetry is added. Startup/service Steam-ID messages and the legacy resolver's full-path message are removed; other preexisting log sources still need review/redaction before sharing.

To collect a reproduction from a diagnostic candidate, launch it with -tinyChaosTrace -timestamps -logFile /tmp/tinychaos-repro.log on Linux, or -tinyChaosTrace -timestamps -logFile "C:/Temp/tinychaos-repro.log" on Windows after creating that folder. The flags can be supplied through the game's Steam launch options for that candidate. These options do not instrument the old public binary; it must contain this code. Reproduce once from a fresh process, retain the complete file before another run overwrites the chosen destination, and record the candidate/version, scene/action, approximate symptom time, foreground/fullscreen state, and input responsiveness. Do not use temporary isolated test profiles as a substitute for backing up actual saves when diagnosing save compatibility. Share a reviewed/redacted copy of the log, not credentials, identities, or save contents.

For freeze investigation, a last marker narrows the suspected interval; it does not prove the next operation caused the stall. Correlate with focus, rendering/input behavior, and stack/profiler evidence. A heartbeat on the blocked main thread cannot by itself establish why that thread stopped. Log collection and reproduction instructions must accompany diagnostic changes.

Installed and tested¶

Capability	Evidence / limit
Required Editor	`/home/freightpx/Unity/Hub/Editor/6000.2.8f1/Editor/Unity -version` returned `6000.2.8f1`, matching the project.
Unity CLI	`/home/freightpx/.local/bin/unity --version` returned `1.0.0-beta.12`. `run`, `build`, `test`, and live-command options are present in local help.
Headless import and C# compilation	The CLI command below exited 0. Log shows Csc/assembly copies for `Assembly-CSharp`, `Assembly-CSharp-firstpass`, and `Assembly-CSharp-Editor`, then `Exiting batchmode successfully now!`.
Compile warnings	Three `CS8785` warnings: `AttributeBasedFieldGenerator` threw `IndexOutOfRangeException` and did not generate output for those assemblies. The matching class is in the installed `com.unity.ai.inference` 2.4.1 package's `OperatorGenerator.cs`. No `error CS...` was found in this successful run. Its failure trigger/impact still needs investigation.
Platform modules	`LinuxStandaloneSupport` includes IL2CPP and produced the batch-05 player successfully. Windows extension support remains unavailable locally; production Windows IL2CPP is validated on the other PC.
Windows Steam build	Not verified and currently missing Windows platform support. Do not claim that this workstation can produce the existing Windows release profile yet.
EditMode/PlayMode tests	Custom Editor checks ran for batches 01–04, 06, 08, and 10–13, 15, and 16, including live Play Mode coroutine checks in batch 02. Those scoped passes do not establish a complete player playthrough.
Live Editor control	`unity list --project-path ...` returned `No Pipeline instance found`. No active Pipeline connection was established. No bridge package was installed by this audit.
Fullscreen/controller/gameplay verification	Batch 05 launched a graphical windowed player and observed menu failures. Fullscreen/display switching, controller UX, complete gameplay, and the reported freeze are not verified. Earlier headless checks cannot establish these behaviors.

Linux player build and startup probe¶

The successful build command was:

unity --non-interactive --no-banner build \
  '/mnt/work/Unity Project/Tiny-Chaos' \
  --target StandaloneLinux64 \
  --output-path /tmp/tinychaos-batch05-linux/TinyChaos.x86_64 \
  --log-file /tmp/tinychaos-batch05-build.log --no-tail \
  --timeout 1200 --allow-dirty-build \
  --provenance-path /tmp/tinychaos-batch05-provenance.json

The dirty-build override followed review of the intended candidate changes. Provenance records committed revision 5347e4600bb897ca1c9fa8cb80cb095f6ee0ce0a and dirty: true; it is not a Steam release identifier. The build took about 18 minutes with first-use shader/native compilation and exited 0. This CLI rejects a forwarded -nographics as a managed/reserved build flag; omit that extra argument.

Launch probes must isolate player data and ensure Steam does not replace the candidate with the installed library copy. Batch 05 used a new child-process XDG_CONFIG_HOME, confirmed generated player/config/cache files under the temporary root, and verified the normal game-profile hashes were unchanged. It added a development-only steam_appid.txt beside the temporary executable; this file must not enter a Steam depot. See Unity's persistent-path reference and Valve's restart/initialization reference. The batch record retains exact outcomes and limits.

Successful probe¶

unity --non-interactive --no-banner run \
  '/mnt/work/Unity Project/Tiny-Chaos' \
  --timeout 600 \
  --log-file /tmp/tinychaos-doc-audit-cli-linux.log \
  --no-tail -- -nographics -buildTarget Linux64

The installed CLI supplies batch/quit/project flags and manages launching the Editor. The detailed local log is at /tmp/tinychaos-doc-audit-cli-linux.log; /tmp is temporary and raw startup logs can contain authentication arguments. Keep sanitized results in the audit record, not raw logs in Git.

An earlier direct-Editor probe with -batchmode -nographics -quit -projectPath ... reached game-script compilation but timed out after 300 seconds during asset import (exit 124). The later CLI invocation completed. The timeout is not a reproduced 60-second player freeze.

Batch 12's normal profile contained only Unity engine preferences, whose hash changed during Editor Play Mode; no gameplay save/config files were present there before or after. The actual player probes used fresh isolated roots. A hash-only baseline cannot restore unknown preference values, so the file was retained and the workflow now captures preference bytes as well. Do not equate an empty Play Mode fixture with an unchanged whole profile.

Generated changes during verification¶

Unity automatically added com.unity.toolchain.linux-x86_64: 2.0.11 to the package manifest/lock during the probes. Those generated dependency edits were removed afterward; the committed dependencies were not intentionally upgraded. Unity's rewrite of EditorBuildSettings was also restored to its original bytes. Consequently this is evidence of operational CLI/import/compilation with Unity's automatic Linux toolchain resolution, not certification of a clean untouched-manifest Windows build.

Batch 10's time-scale checks also triggered a TimeManager serialization-format upgrade; time scale was restored to 1, and the reviewed format-only project edit was restored to exact pre-run bytes. Include TimeManager in the pre-run settings snapshot when invoking pause/resume methods.

Do not run a second Editor against this same project while one is open. Import caches and local platform selection may change during batch work. Review tracked file changes after each probe and preserve unrelated user edits.

The player build also generated Addressables linker/Linux metadata under Assets; those new source files were removed after the build. Performance-test JSON assets were generated and removed by their build callbacks. A URP modified flag had no filtered content difference: its blob hash matched the index. An optional status refresh was blocked by a nonempty .git/index.lock; that lock was left intact. Preserve/review it before a later Git checkpoint instead of deleting it as an empty stale lock.

Work the agent can perform next¶

Source/serialized-asset edits, custom regression entry points, Linux IL2CPP builds, and isolated player launch probes are available now. Follow the active rebuild order: the shared scene/isolated entry now has batch-36 evidence; R2 roster/device and action/session/context ownership now have batch-37/38 evidence. Batch 39 verifies disposable binding-profile/legacy-conversion work; batch 40 verifies blocked-session application and reversible drafts; batch 41 verifies device-owned capture; batch 42 verifies the independent config file adapter; batch 43 verifies the control-preset compatibility slice; batch 44 separates audio/locale loaded application; batch 45 wires production config ownership with disposable Editor tests; isolated Linux player startup/persistence validation precedes recovery/UI/consumer rollout. Do not resume the historical menu-fix queue or dedicated freeze investigation by default. Live Editor inspection/play control still needs an established connection; the current CLI checks/build do not depend on one.

For argument semantics, see the Unity 6.2 Editor command-line reference. Prefer this machine's installed unity ... --help when checking options specific to its CLI version.

Batch 35 adds direct Editor entry TinyChaos.EditorTools.RunLifecycleChecks.RunBatch35. Required Editor 6000.2.8f1 compiles the new runtime/Editor scripts; L01–L09 pass 9/9 and the authoritative process exits0. No Play Mode, scene load or player build. The async entry owns exit with a post-entry watchdog; launch directly without -quit. Tests use controlled in-memory participants, including actual worker-thread admission rejection. The batch distinguishes restored package/engine-preference changes, retained external licensing/log state, existing compiler warnings and unchanged normal game/profile/source evidence. This is lifecycle verification, not shared-scene/full-game/IL2CPP acceptance.

Batch 36 adds direct entry TinyChaos.EditorTools.RunSceneChecks.RunBatch36. Final process exits0, 7/7 import/PlayMode groups. SessionState gates resumption across the domain reload; an explicit watchdog bounds the run, scene setup is restored after leaving Play Mode, and the entry owns exit without -quit. The runner reuses the saved shared scene on later invocations and creates it only when absent. One initial additive/untitled-scene setup failure is excluded and corrected in the retained builder. Play Mode changed automatic Unity session keys in the normal game prefs as well as shared engine preferences; captured bytes were restored after verifying those engine-only differences. No raw values/logs are committed. The batch records source/GUID/build-dependency preservation and distinguishes the empty lifecycle fixture from gameplay/Windows/IL2CPP/controller evidence. For interactive use, open Tiny Chaos → Development → Run Lifecycle Arena, then open scene, enter Play Mode and Start; command helpers are tested, native window interaction/rendering remains unverified.

Batch 37 adds TinyChaos.EditorTools.PlayerRosterChecks.RunBatch37: final 9/9 SDK Play Mode groups, process exit0. The runner clones input settings for synthetic-device focus, restores the original object and virtual-device/native-flag changes, and waits until Edit Mode settles before restoring scene setup. It verifies the original Both backend defines and legacy API smoke. The first failures include a real Added-event pairing order problem corrected by post-update reconciliation; the retained P05 check passes. Input System 1.17.0 stays pinned in manifest/lock; only Unity's unrelated generated Linux toolchain addition is removed after review. The batch records preference restoration and the two expected package-pin differences. This does not certify action/legacy feel, physical devices, player builds or complete input migration.

Batch 38 adds TinyChaos.EditorTools.InputSessionChecks.RunBatch38: final 8/8 SDK Play Mode groups, process exit0. Use the required Editor with -batchmode -nographics -executeMethod TinyChaos.EditorTools.InputSessionChecks.RunBatch38 -logFile <private-path>, with this project path and no immediate -quit; the runner owns Play Mode/domain reload, watchdog, cleanup, scene restoration and exit. It uses simulated devices and in-memory binding overrides, without normal game-data IO. Corrections cover held-release rearming, disconnected-control callbacks and preventing input reopening after a run ends. All prior project bytes and reviewed engine preferences were preserved/restored; the batch records initial failed attempts separately. Raw movement is not legacy-equivalence evidence. No actor migration, physical-device or IL2CPP/player pass.

Batch 39 adds TinyChaos.EditorTools.InputProfileChecks.RunBatch39: 9/9 Edit Mode groups, required Editor process exit0. Direct -batchmode -nographics -executeMethod TinyChaos.EditorTools.InputProfileChecks.RunBatch39 with project/private-log paths and no immediate -quit; the synchronous entry owns exit. No Play Mode, device/user creation, scene loading or save IO. Tests cover all 16 legacy preset combinations, exact supported JSON data, malformed/future data, immutable failed edits, composite binding IDs and real SDK override round trips on disposable action copies. The old typed config writer is explicitly verified to drop the new section, keeping production writes gated. All prior project bytes match after restoring the sole generated Linux toolchain additions; only two automatic shared engine preference keys were restored. Normal game profile bytes never changed. Existing compiler warning categories remain; no player/physical input/write-failure evidence is claimed.

Batch 40 adds direct TinyChaos.EditorTools.BindingDraftChecks.RunBatch40: 9/9 simulated-device Play Mode groups, exit0, followed by unchanged TinyChaos.EditorTools.InputSessionChecks.RunBatch38: 8/8, exit0. Use the required Editor, explicit project/private-log paths, -batchmode -nographics, and no immediate -quit; each runner owns domain-reload resumption, watchdog, cleanup, scene restore and exit. A helper/type naming collision caused the first compile-only failure and is recorded separately. Checks include SDK-triggered device loss during application, blocked previews/cancel/defaults, actual run/scene handoffs and retained ownership; no capture UI, normal writes or physical input is certified. Generated package additions and reviewed engine session keys were restored from captured bytes; the batch records intentional input-source amendments.

Batch 41 adds direct TinyChaos.EditorTools.BindingCaptureChecks.RunBatch41: 10/10 simulated-device Play Mode groups, exit0. Unchanged TinyChaos.EditorTools.BindingDraftChecks.RunBatch40 also passes 9/9, exit0. Use the required Editor, explicit project/private-log paths, -batchmode -nographics, and no immediate -quit; each runner owns domain-reload resumption/watchdog/cleanup/scene restoration/exit. Checks cover input-update/release fencing, explicit cancel priority, canonical owned-device paths, conflicts/ambiguity, partial controller events and actual run/reload teardown. The initial suite passed; an expanded start-inside-onEvent trace then failed 9/10. After the opening-state correction, that same expanded suite passes 10/10. The unchanged draft 9/9 evidence is reused because only the capture component/fixture changed afterward. No production UI, normal-writing or physical-input claim. Generated toolchain additions and reviewed Unity engine session preferences were restored from captured bytes; source amendments and limits are in the batch record.

Batch 42 adds synchronous direct TinyChaos.EditorTools.ConfigPersistenceChecks.RunBatch42: final 10/10 Edit Mode groups, process exit0, with no Play Mode/scene entry. Use the required Editor with project/private-log paths, -batchmode -nographics and no immediate -quit; the entry owns exit. It creates only unique temporary fixture directories and verifies real Linux replacement/reload, six text encoding forms, exact backups and accepted remaps through the SDK. IO failure/permission/full-disk cases are injected. Initial 7/10 exposed uncaught verification and non-finite edit errors; final 10/10 also covers write-time reentry. Production writers/normal paths are not invoked; normal profile bytes remain unchanged. Generated package additions and two shared engine session keys were restored from capture. Windows, crash/power-loss, production handoff and recovery/retention remain unverified.

Batch 43 adds synchronous TinyChaos.EditorTools.SettingsCompatibilityChecks.RunBatch43. Use the required Editor with -batchmode -nographics -tinyChaosTrace, explicit project/private-log paths and no immediate -quit; the runner owns exit. Final 10/10 new and 10/10 repeated ConfigPersistenceChecks groups pass, both process exit0. It uses inactive preview objects and temporarily injected SaveManager/SaveService paths without the normal SaveService constructor; real public setters write only disposable fixture files, and loaded preset application writes none. Normal profile/preferences and generated package edits are audited/restored as recorded. No full startup, Play Mode, player build, physical mapping or Windows evidence.

Batch 44 adds synchronous TinyChaos.EditorTools.LoadedSettingsChecks.RunBatch44 using the required Editor, explicit project/private-log paths, -batchmode -nographics -tinyChaosTrace and runner-owned exit. Final 8/8 groups and repeated StabilizationChecks.RunBatch23 7/7 settings-screen groups pass, both process exit0. It manually steps the production locale iterator against disposable SDK settings/catalog/initialization; there is no real packaged localization preload, scheduler or localized rendering check. Actual audio sources and deliberate settings saves use injected disposable dependencies. First-run screen choice persistence is tested separately without applying graphics. Generated Linux toolchain/time serialization and shared Editor session preferences are reviewed/restored. Normal game profile bytes remain unchanged. No full startup, Play Mode/player build, audio playback or Windows check.

Batch 45 adds synchronous TinyChaos.EditorTools.ConfigOwnerChecks.RunBatch45, with the required Editor, explicit project/private-log paths, -batchmode -nographics -tinyChaosTrace and runner-owned exit. Final 10/10 new, RunBatch43 10/10, RunBatch44 8/8, RunBatch23 7/7 and RunBatch24 9/9 groups pass; five processes exit0. Existing fixtures attach ConfigSettingsOwner to disposable paths; no normal SaveService constructor, full startup/player entry or real-profile IO. Initial CO04 expectations used the wrong exception and then a non-schema version field; corrected fixtures pass against the implemented boundary. Bootloader's imported definition resolves. Generated package/time/preferences are reviewed/restored as recorded. A built Linux player with isolated fresh/current/legacy profiles and actual edit/restart persistence is next; Windows and recovery/retention remain open.

Batch 46 reuses the installed built-in CLI build with StandaloneLinux64, IL2CPP, a new /tmp output/provenance path, --allow-dirty-build, --no-tail and a 1,800-second limit; exit0 in 983.561 seconds. The candidate uses child-only XDG config/cache/data roots and a temporary development-only steam_appid file beside the executable. Two verified interactive runs quit naturally; four data/startup probes are explicitly terminated. All normal game-profile bytes and captured project files match after generated package/linker cleanup. No Editor regression rerun was needed for unchanged implementation.

The owned-window helper validates executable/PID/window, active window plus X input focus, geometry and viewable client. Fresh nonzero X-server timestamps were required for activation. Direct X11 client-buffer capture corrected a desktop/PIL coordinate mismatch; desktop crops are excluded. Background suspension and a first-frame prompt fade invalidated wall-time assumptions. Inspect the visible page before clicking: an extra custom-profile attempt opened Other/Credits, so its supposed volume edit is not evidence. Terminal audits distinguish an untracked first quit, a deadline-stopped trial, two verified natural quits and four controlled stops. These are harness dispositions, not a freeze investigation. Current/legacy native edits, other graphics modes/locale/audio output, gameplay, controllers and Windows remain unverified.

Batch 48 adds TinyChaos.EditorTools.StabilizationChecks.RunBatch48: launch the required Editor directly with -batchmode -nographics, the project path and a private log, without -quit. An empty-scene Play Mode harness owns completion/exit. Original 3/6 → fixed 6/6 bounds/event groups; RunBatch15 additionally passes 7/7 real normal-time/paused/delayed checks. For canvas slides, compare actual panel/viewport bounds in parent units rather than screen-pixel distances. The Linux IL2CPP player reproduces the old obstruction and verifies the correction at two client sizes. Forced tween completion is geometry evidence, not elapsed-time or native acceptance by itself.

Batch 49 adds self-contained TinyChaos.EditorTools.StabilizationChecks.RunBatch49, launched in the required Editor with -batchmode -nographics, private log and runner-owned exit (no -quit; a bounded outer timeout is appropriate). It reads Editor-only PlayerSetupReference.json, captured from the original production iterator, rather than rebuilding expected values from current code. All 22 groups pass without the old temporary export: seven definitions × two shop variants, inherited mount import, real coroutine/legacy adapter and invalid binding checks. Native Linux IL2CPP additionally verifies existing one/two-player setup; this does not certify full runs, physical devices or Windows.

Batch 50 adds TinyChaos.EditorTools.ActorRunChecks.RunBatch50 (12 headless groups) and RunBatch50Visual (13 including an actual shared-scene render). Use the required Editor directly, runner-owned exit and a bounded outer timeout. Headless uses -batchmode -nographics; the visual process uses -batchmode -force-glcore and must omit -nographics. It checks the installed URP SingleCameraRequest API, renders to a temporary target and writes a private PNG; inspect that image before claiming visible output. A scoped Localization GameView toolbar preference prevents a headless Editor UI exception and restores the previous key/value. Development MonoBehaviours must be outside Editor folders to attach in Play Mode; an entire UNITY_EDITOR guard keeps this fixture controller out of player builds. Inactive Light2D setup supplies sorting layers before deferred Awake. Final 13 + RunBatch49 22 + RunSceneChecks.RunBatch36 seven groups exit0; Linux IL2CPP also verifies current two-player gameplay. None establishes new motor feel or physical/Windows acceptance.

Batch 51 adds TinyChaos.EditorTools.MovementInputChecks.RunBatch51 (9 Play Mode SDK/reference groups) and RunBatch51SessionRegression (the original 8 session groups with scoped Localization toolbar restoration). Launch the required Editor with -batchmode -nographics -buildTarget Linux64, private log and runner-owned exit; wait for the terminal process result. LegacyMovementCapture.Run requires a graphical Editor/GameView and an owned OS keyboard sequence; it writes only temporary phase/ack/ready/JSONL data and never rewrites the checked-in reference. Supply phase requests atomically, wait for its first-sample readiness and acknowledge each phase. For GTK Editor input, validate the active owned client plus a focused descendant window: its legitimate 1×1 focus child differs from the top-level ID. Inspect the actual view and preserve prefs/layout outside the repo before these checks. The captured targetFrameRate setting did not impose a fixed Editor sampling interval; recorded per-frame deltas are authoritative. Do not treat these checks as native/physical/Windows acceptance or regenerate expected values after migration.

Batch 52 adds TinyChaos.EditorTools.MotorRunChecks.RunBatch52 (10 headless groups) and RunBatch52Visual (11 with before/after GPU capture). Both use the required Editor, explicit Linux64 target, runner-owned exit and private logs. The visual run uses -force-glcore and omits -nographics; inspect both produced PNGs before claiming visible motion. Deterministic scene checks temporarily use captureDeltaTime and restore it; this is correctness, not performance evidence. The existing 9 keyboard/8 session/22 character groups also pass, followed by a real Linux IL2CPP two-player run.

LegacyMovementCapture.RunBatch52 collects original axes with one temporary owned uinput pad, then closes that handle. RunBatch52Compare additionally observes real assigned SDK sessions, writing a separate temporary prefix and never replacing the checked-in original references. Validate active client plus owned GTK focus descendant, atomic phase requests/acknowledgments, first-sample readiness and actual backend identity. This machine's Gamepad interface is SDL, not the older generic Linux layout label; a guessed selector caused a failing trial before its correction. Final 48 phases produce 6,379 exact matching observations. Ensure no other joystick makes legacy axis indexing ambiguous, close only the owned virtual device and preserve profiles/preferences/layouts around Editor/player checks. Virtual devices do not qualify physical controllers or Windows.