GameFrame 1.4.0

Added

• crates/library (gameframe-library) keeps a port's game data, saves and opt-in sections
  (mods, screenshots, recordings, custom). The game declares them in one library.json, with
  hooks for save cards and file checks. It has folder, memory and browser stores. In the browser,
  files are encrypted with a non-extractable WebCrypto key.
• templates/library-page/ is a plain HTML page for browser ports that works with the crate.
  It has a design system of --lib-* tokens, replaceable icons and named components. Panels
  show Markdown, a changelog, messages, a click-to-load YouTube video and GitHub releases, and
  ports can add their own. Markdown help pages sit at hash routes, with ::: tip boxes and
  ::: panel slots.
• crates/frame (gameframe-frame) is the contract between a port's core and the frame
  around it. It has event topics, a manifest of capabilities, renderers with coverage grades,
  settings and controls, and a session with listeners. A game joins in Rust, in any language
  over JSON lines, or with a frame.json alone. A demo game stands in when there is no port and
  presses its own controls. A minor contract version only adds fields, and older frames ignore
  them.
• crates/frame-ui (gameframe-frame-ui) draws the frame as Dioxus components for the browser
  and the desktop. Its tabs are Play, Settings, Library, help pages and Console, styled by the
  library page's tokens. examples/frame-demo runs it with no game, in both targets.
• Eleven ready-made themes in templates/library-page/themes/: Windows 98, XP and Vista,
  System 7, Aqua, BeOS, NeXTSTEP, CDE, GNOME 2, Amiga Workbench and Atari ST GEM. "preset"
  in library.json picks one for the HTML page and the frame. "presets" lets the player choose between them in the frame's Settings tab, saved as frame.preset.
• crates/disc-image and crates/game-source move from POD into GameFrame. They read CD images
  in place, and give a game's files from a folder, a disc image or a URL, in ranges in the
  browser.
• tools/llm/decision.py routes bounded choice, yes-or-no and score questions to a user-selected
  decision model through its native System One endpoint. decision_feedback.py stores explicit
  user corrections locally and exports training examples. Neither tool selects a paid service,
  changes model weights or uploads data.
• The site diary is now written live and then put together by day. During the day, each
  milestone gets a live entry named YYYY-MM-DD-HHMM-slug.md, which the diary shows with its
  time. On the next run, re-site and re-publisher turn each past day's live entries into
  one post in the style of update notes: what is new, a little detail, and a short change list.
  The post drops the repeats. tools/site/check.py fails while a past day still has live
  entries. --days lists those days, and --keep-live turns the check off.
• The plugin check in tests/run.sh ignores system files that sit on disk but not in git, and a
  new check fails if git tracks a .DS_Store, Thumbs.db, desktop.ini or __MACOSX file.

Changed

• Model-powered tools now default to the local provider. GAMEFRAME_LLM_ENDPOINT can point to a
  local or compatible endpoint; hosted services are selected by name with GAMEFRAME_LLM_PROVIDER
  with provider-specific model and key settings. Hosted providers and remote endpoints require
  confirmation before a request. Image location supports local vision models; function naming
  uses synchronous calls where a server has no batch API.
• The REA skill now documents how to check Ghidra provider readiness, open an explicit Ghidra
  session, inspect a native function and its raw instructions, retain the Evidence bundle, and
  close the temporary project. It separates focused REA analysis from whole-program Ghidra
  searches and emulator measurements.
• 86Box setup guidance now covers the optional GDB build, its dynamic-recompiler tradeoff and
  the debugger tools provided by the opt-in 86box-mcp server. The provider launcher places its
  automation socket in a home-mounted temporary directory for Docker builds, and defaults to
  token-protected TCP transport for container compatibility.

Full changelog: v1.3.0...v1.4.0

GameFrame 1.3.0

Changed

• Stage agents, separate tasks and worktrees are optional. The current session is the default,
  and a task being self-contained does not imply permission to delegate. Paid unattended runs
  and recurring schedules require the user's choice.

Added

• The modular GameFrame MCP server now exposes workflow and tool discovery, knowledge queries,
  progress and provider configuration, plus execution for every runnable catalog program and
  script. Long-running calls report progress and support cancellation. Its sample coverage check
  now resolves help for all 117 catalog entries, invokes the help path of all 95 runnable
  commands, runs a sample PE analysis, and checks progress, cancellation and timeout handling.
  External REA, DOSBox-X, MCPEmulate and 86Box servers are opt-in through gameframe mcp, with
  pinned package versions or source revisions. Their project-local launchers read custom server
  and emulator paths from .env. Copilot agent allowlists track each project's enabled providers.

• The new re-profile skill builds an evidence-backed game quick start after inventory. It
  records the game's family, engine, release, graphics, sound and input support, separates
  official support from community reports, and lists project-specific traps and next steps.

• A clean-room-style workflow with source-visible specification and source-blind implementation
  roles, a behavior-contract template, packet checklist, team guide and emulator/debugger options.
  It records the limits of prompt-based separation and the current gap in packet isolation tools.

• The observation guidance now covers 86Box as a configurable full-PC reference for DOS and
  Windows 3.x/9x games. It records sound-card resource settings, guest OS and machine details,
  and labels captures as emulator measurements rather than physical-hardware evidence.

• gameframe-sn76496 adds a TI SN76496 tone/noise model, input-clock advancement, PCjr C0h and
  original Tandy C0h–C7h adapters, PCjr and Tandy 61h output muxes and the Tandy PIT-2 input
  route. The Tandy adapter exposes the service manual's approximate 42 CPU wait states. Static
  traces of Sierra's original JR.DRV and TANDY.DRV confirm tone latch/data writes, attenuation
  writes, startup mutes and PSG-source selection. TI noise details, period-zero behavior, the
  Tandy mux's fourth input, NCR/PSSJ variants, sample parity, CPU wait mapping and analog behavior
  have software-only follow-up checks. The SN76496N timing source is the IBM PCjr reference; the
  Tandy service schematic confirms its matching 3.579 MHz clock.

• gameframe-saa1099 adds a Philips SAA1099 stereo sound generator and a two-chip Creative Music
  System/Game Blaster port model. It applies tone and octave writes at generator transitions,
  buffers envelope controls to waveform boundaries and models common CMS detection-port behavior.
  Static traces of CMSDRV.COM and Sierra's CMS35.BIN establish the chip ports, default base and
  detection probe. The noise seed, combined tone/noise mixing, exact custom-chip behavior, bus waits
  and analog output have software-only follow-up steps; physical card testing is optional.

• gameframe-sound-blaster adds port-level Creative DSP models for 1.xx through 4.xx cards,
  CT1335/CT1345/CT1745 mixer registers, SB16 MPU-401 UART, and FM routing through GameFrame's OPL2
  and OPL3 crates. Profiles cover SB Pro 1's dual YM3812 stereo path, Pro 2 YMF262 ports, and SB16
  8/16-bit mono/stereo DMA. DSP MIDI timestamps and UART reset restoration follow the published
  interface. The docs record preservation context, the bundled driver restriction and its
  assessment limits, the clean-implementation boundary, ADPCM/analog/timing limits, and software-
  only follow-up checks. Physical card testing is optional.

• An investigation of Creative's SBBASIC SB16/SB32/AWE32 package verifies the archive hash and
  release metadata. Its driver payload remains inside TTComp .PVL archives until the DOSBox-X
  installer can be driven to a temporary destination. The findings document records the exact
  software-only next step; no driver behavior is claimed.

• A PC audio coverage map separates chip crates, card models, compatibility libraries and host
  audio backends. It inventories common PC audio from the speaker and Tandy PSG through Sound
  Blaster, Gravis UltraSound, MIDI modules and late-1990s Windows audio, and prioritizes OPL3,
  Sound Blaster DSP/DMA, GF1 and MIDI work. It records the clean-implementation process and
  owner-selected licensing options.

• gameframe-opl3 adds a YMF262 chip model with two register banks, 18 channels, six selectable
  four-operator pairs, four connection algorithms, eight waveforms, four output words,
  OPL2 compatibility mode, shared note-select, timers, indexed I/O ports with timestamped
  write-spacing checks, and serial DAC frames. Timer divider phase resets when a timer starts. It reuses
  GameFrame's OPL2 engine and follows Yamaha's datasheet and YM3812 Application Manual. An original
  AdLib Gold Windows driver trace records its register write path, voice pools, busy polling and
  second data-port reads. The AdLib Gold Control Chip and port overlay are modeled separately in
  gameframe-adlib-gold. Independent four-operator carrier routing, physical parity, YAC512 analog
  conversion and card-level audio processing remain open.

• gameframe-yac512 adds a clean model of the YAC512's LSB-first serial receiver, offset-binary or
  two's-complement input selection, falling-edge channel latches and held digital input words. The
  floating DAC transfer and analog sample-and-hold stage stay documented as open behavior because
  Yamaha's available datasheet does not provide the conversion formula. The open-question page
  proposes software-only protocol and integration checks; physical hardware testing is optional.

• gameframe-adlib-gold combines the YMF262 with the documented AdLib Gold Control Chip port
  overlay, status, register reads/writes, EEPROM save/restore commands and audio-port relocation.
  The Developer Toolkit v1.01 resolves the Windows driver's 0xFF/0xFE bank switches and second
  data-port reads. It routes the MMA at offsets +4 through +7 and feeds its sampling request
  into Control Chip status. mix_sources() now applies the documented linear source-volume,
  speaker/microphone/telephone routing, output-channel selection, forced mono, mute and final
  output-volume controls. Analog tone and spatial processing remain documented limits.

• gameframe-ymz263 adds the YMZ263B/MMA digital model used by AdLib Gold. It includes dual
  128-byte PCM/ADPCM FIFOs, documented rates and sample layouts, timer counters, per-channel DMA
  request state, MIDI FIFOs and timestamped UART output. A static trace of the original GSS Wave/MIDI
  driver confirms its two index/data pairs and timer, sample and MIDI register use. EEPROM save
  latency stays configurable because its duration is unspecified. Analog mixer/filter behavior,
  external DMA/IRQ delivery and chip details needing software comparison are documented as open;
  physical hardware tests are not required.

Fixed

• The Windows 3.x and Windows 9x know-how entries now use the canonical virtual-machine
  runtime facet for 86Box. The 86box spelling remains a taxonomy alias.

GameFrame 1.2.0

[1.2.0] - 2026-10-25

GameFrame 1.2.0 expands the late-1990s replacement libraries, adds a clean-room Indeo 4.1
decoder and a runtime harness, and improves input capture and project safety. Know-how now has
broad starting entries for major topics alongside its specific failure notes.

Added

• Know-how now has broad starting entries for sound cards, CPU behavior, display output,
  CD-ROMs, input, networking, game files, and timing. The entries link to detailed guides, with
  case notes where available. Know-how guidance now calls for an overview when a major topic has
  only narrow entries.

• sgl.dll draws the immediate mode's shadow and light volumes (sgltri_shadow), which it
  only counted before. Each call's faces become the planes of one convex volume, oriented as
  PowerVR's driver orients them, and every pixel is tested against them: a shadow multiplies
  by its brightness, a light volume adds its colour. Texture wrapping now moves a vertex by one
  turn at most, as measured in the driver. In shadow mode a Gouraud face with a translucent map
  is drawn flat, as the driver does. The fog constant is 1.0, a person's choice until a PCX2
  picture settles it. Free texture memory and the sglhw.ini the library writes follow the
  driver's installer (TSPParamSize 256). sgltritest.c draws one volume of each kind.

• gameframe-msvc-crt adds safe byte memory operations, C byte-string functions, integer parsing
  and integer formatting. It models Windows long as 32 bits and documents its C-locale limits.
  The 2008, 2010, 2012 and 2013 x86 CRT exports and selected decompiles informed the new routines.
  Their runtime parity is still open.

• glide2x.dll draws under Wine on macOS. There Wine gives OpenGL 2.1, which cannot compile
  the library's shaders. The library now asks for a forward-compatible 3.2 core context when the
  first one is older than OpenGL 3. glidetest.exe passes all 27 checks under Wine on an Apple
  M3 Max (docs/knowhow/wine-macos-opengl-2-1.md).

• glide2x.dll now implements all 156 Glide 2 calls. The last 25 are in. The PCI library
  (pci*) shows one Voodoo Graphics. guMPDrawTriangle draws two textures in two passes, as
  Glide 2.43 does. The guMovie* calls record each frame shown as a TGA file. That is a
  Deviation, as Glide 2.43 cannot record. guEncodeRLE16 gives the same bytes as the
  original on 2009 test images, faults included. ConvertAndDownloadRle downloads zeros, as
  the original does, since its line decoder is empty. grSstConfigPipeline and
  grSstVidMode do nothing, as the window is the library's. glidetest.c checks the PCI
  library, the encoder, the two passes and a recorded frame.

• A project's target/, the user's own copy of the game, is now hard to delete by mistake. A
  disk cleanup took it for Cargo build output and lost three projects' game copies and an
  original save (docs/knowhow/game-folder-deleted-as-build-output.md).
  new-project.sh writes target/GAME-FILES-NOT-BUILD-OUTPUT.txt, and update-project.sh
  adds it and .cargo/config.toml (target-dir = "build") to older projects. A new delete
  gate (scripts/hooks/gates/deletes.py) blocks an agent's rm, move to the Trash,
  find -delete, git clean -x, cargo clean into target/ and build-folder cleaners on a
  game folder; GAMEFRAME_DELETE_GAME=1 on the command lets it through. ./gameframe doctor
  reports a missing or empty target/. templates/project/AGENTS.md says target/ is the
  only copy and build/ is Cargo's.

• glide2x.dll implements 131 of the 156 Glide calls, up from 55, so it runs more Glide 2
  games than POD. It now draws points, polygons, and the antialiased and clipping draws. It
  handles culling, the alpha test, colour and depth masks, depth bias, drawing to the front
  buffer, the lower left origin and the colour formats. It saves and restores state
  (grGlideGetState, grGlideSetState). Textures gain mipmaps, LOD bias, NCC tables,
  multibase, partial downloads, the gu texture manager and 3DF files. The frame buffer gains
  region reads and colour formats. The queries, statistics and gu fog tables are in. The
  fog tables match the original byte for byte. wrappers/glide/test/glidetest.c draws and
  checks a known scene through the DLL, and tests/run.sh builds it. The host tests cover
  clipping, culling, mip level layout, fog tables, 3DF files and NCC tables.

• sgl.dll now has SGL's immediate mode, which Hardwar's PowerVR mode uses. It has the
  sgltri_* calls for triangles, quads and rendering. It has SGL's DirectDraw mode with its 2D
  callback. It also has the end-of-render callback, the error, version and texture-memory
  calls and sgl_delete_all_textures. That is 14 more calls, so SGL has 61 of 134. The faces
  go through the scene graph's renderer. The header leaves facing, flat shading, translucency
  levels, the order of translucent passes and the fog register open. They were read from
  PowerVR's own SGLMID4.dll, partly by unattended re-tracer runs.
  wrappers/sgl/test/sgltritest.c draws a known scene with them. The plain-Rust part has
  host tests.

• Every wrapper DLL now exports every call of the original library, so any game that uses one
  loads. Calls implemented of calls exported: Glide 55 of 156 (Glide 2.43 and 2.1.1), SGL 47
  of 134, ATI3DCIF 6 of 17, S3D Toolkit 6 of 6, DirectDraw 2 of 9. Each crate's api.tsv
  holds the original's API table. wrappers/stubgen.py writes the crate's .def and
  src/stubs.rs from it. It stubs each call not written yet. It fails on a call written with
  the wrong convention. The originals stay outside the repository.

• tools/pe/apitable.py writes the API table of a 32-bit DLL or of an SDK's import library.
  For a DLL, each export's convention and argument bytes come from the ret N its code ends
  with. A header gives the parameter counts and return kinds. The tool is tested on a DLL
  built from our own C.

• The wrappers log what they lack in one way. shim::stub! and shim::gap! log the first call
  of each stub and unhandled mode with its arguments. They count the later calls. When the game
  exits, they list them all with their counts. ddraw.dll names each COM method that is a stub. sgl.dll now logs the
  convex objects it skips.

• Debug and release builds of the wrappers. cargo build gives symbols, debug assertions, the
  first 50 calls of each stub logged and OpenGL errors checked after each frame. cargo build --release gives link-time optimisation and stripped DLLs. Each log names its build.

• S3DTK_ExitLib and S3DTK_PhysicalToLinear, from the original's code. With them the S3D
  Toolkit is complete.

• wrappers/, a Cargo workspace of replacement libraries for the 3D cards of 1997, moved from
  the POD project: glide2x.dll (Glide 2.x on OpenGL), ddraw.dll (DirectDraw in memory,
  scaled), ati3dcif.dll and s3dtkw.dll (the chips' faces drawn in software), and sgl.dll
  (PowerVR SGL's scene-graph half on OpenGL). The shared crates are shim, raster,
  scalers and pixels. The game-specific parts became settings: WRAPPER_WINDOW_CLASS,
  WRAPPER_MARKER and a patch file named by WRAPPER_PATCHES. tests/run.sh runs the host
  tests, builds the DLLs, checks their export tables against the .def files and builds
  sgltest.c.

• Thirty-seven know-how entries: thirteen from POD (POD Gold, the PowerVR build, the emulated
  PC, ptrace under Wine, the FPU control word in the game's own thread and more) and
  twenty-four from Hardwar, among them running the original on a whole-process snapshot,
  registers left by callees, fake worlds and Ghidra function recovery. The taxonomy gains the
  API sgl (PowerVR).

• A guide to the replacement libraries, docs/hardware/wrappers.md:
  why games had a build per card, what each DLL draws and lacks, how to build and use them,
  patch files, logs, adding a game or a call, tests, and POD as the worked example with
  screenshots of its runs. The home page has a section on them.

• gameframe-indeo, a clean-room Indeo 4.1 decoder that matches Intel's IR41_32.DLL byte
  for byte, and ir41_32.dll, a Video for Windows codec built on it. The decoder's empty-band
  path now uses the same fill words as Intel's Pentium path.

• wrappers/maxi94 supplies a silent 94DLL32.dll so POD Gold's Maxi Sound 64 build starts,
  then maps its opened wave outputs and mixer lines to host audio. A full race measured the
  output. The sound-card API guide distinguishes measured behavior from unverified descriptions.

• tools/live/emupc.py gives each game's emulated PC a project-specific name and refuses to
  start a second copy for the same project.

• The runtime harness inspects a game folder, names its runtime needs and writes setup steps.
  Its initial modules cover Wine, emulated PCs, DOSBox-X, Steam, audio, disc drives and Glide
  wrappers. tools/live/align.py maps a known screen to a capture so scripts can place clicks;
  tools/llm/locate.py can locate a changed screen, and tools/formats/pngio.py reads and writes
  PNG. re-observe now plans the harness before the first run and maps click points before
  driving it.

• The repository now backs up its Codex Cloud environment settings, install script and start
  instructions under docs/working/ and scripts/.

Changed

• scripts/zcc.sh also finds a DLL's .def file one folder down, in ZCC_DEF_DIR/*/NAME.def,
  for a workspace with one .def in each crate.
• The replacement-libraries guide points at wrappers/ and says how a game uses them.
• Three know-how entries take POD's newer findings: the game races with the x87 word 0x027f,
  and CD audio and PulseAudio in the emulated PC.
• re-randomiser lists chance taken from the frame clock; the recording guide records the
  FPU's control word and measures sequences; re-start gives the order for moving to a newer
  version; the obje...

GameFrame 1.1.0

GameFrame 1.1.0 brings the lessons of POD, Hardwar and Tyrian into the framework: a know-how
layer of failure modes and context with a hook for every agent, tools for 32-bit and 1990s games
(a 32-bit emulator, Watcom register arguments, export gaps, card-library probes, recordings and
replays), tools that spend a plan's monthly API credits, guides for MMX, 3D cards, versions and
the story, a website for each project, and one GameFrame checkout per machine.

Added

• tools/llm/, tools that spend a Max or Team plan's monthly API credits
  (API credits): name_functions.py suggests names for every
  unnamed function in one Message Batch; skillcheck.py gives an agent one skill and a task
  on the sample game and checks the answer against ground truth (tests/skill-tasks.json);
  headless.py runs an agent unattended under a budget, and docs-check runs re-checker
  and re-editor over the documents; ask.py answers a question from the know-how entries.
  fake_api.py stands in for the API in tests/run.sh. The SDK is optional, in
  requirements-llm.txt. Know-how: api-credits-refused, the messages a refused run gives
  and the fix for each.

• ghidra-run.sh ... callargs regs=watcom: the constant each register gets before every call,
  in Watcom's order (EAX, EDX, EBX, ECX) or any list, where the decompiler shows no arguments.

• ghidra-run.sh ... fill-gaps: makes a function at each start exportcov finds, goes on past
  a bad one, and exports the binary again. The sample DLL gains a routine Ghidra misses.

• tools/verify/replay.py: checks a port's trace against a recording read from outside, where
  one sample can mix frames; a value passes when any state in its window holds it.

• tools/triage/axes.py: the up axis, its sign and the handedness of a 3D game, from a recorded
  path over the level's vertices.

• tools/pe/probegen.py: a probe library for a DLL a 32-bit game imports, exporting the same
  names (decorated __stdcall ones too) and logging every call with its arguments.

• The gameframe-scale crate: nearest, Scale2x (EPX) and a CRT look, for a finished frame.

• re-browse section 5: growing the viewer into an editor.

• tools/triage/buildid.py: everything a copy says about its own version (the disc's mastering
  date, link dates, VERSIONINFO, version strings, readme and setup lines), written into the
  project's docs/versions.md. re-inventory, re-start and the versions guide check on day one
  whether the copy is the latest official build, and where to search for later official
  releases; the template has a "Build identity" and an "Is this the latest official version?"
  section.

• Versions and their deltas: the versions guide now starts with
  finding every edition, takes the last version released as the default reference, and has the
  steps for moving to a newer edition mid-project. A project template, docs/versions.md,
  records each edition, its checksums, languages, content and builds, the data and code
  deltas, the extras and the reference. re-inventory and re-start have the step.

• tools/triage/versiondiff.py: two editions compared as folders or disc images: files added,
  removed and changed by folder, PE link dates and languages, as Markdown.

• Know-how: context-newer-edition-mid-project, from POD's first edition and POD Gold.

• ExportAll.java writes bodies.tsv, every piece of every function (start, end, entry), and
  exportcov.py reads it beside functions.tsv (or with --bodies). Before, a function whose
  body lies in several pieces counted as one run from its entry: Hardwar's export measured
  93.7% where 98.0% of its code is in functions.

• Know-how: a project whose ./gameframe runs a second clone or another project's copy of
  GameFrame (pin the machine's one checkout in .env), and scripted edits that stop matching
  after a formatter reflows the code.

• Three guides from the POD: Planet of Death project:
  Recording the original, and replaying it,
  Replacement libraries for a 1990s game and
  Writers, editors and mods; and a section on the emulated-PC route in
  Running the original.

• scripts/zcc.sh: rustc's linker for 32-bit Windows DLLs through zig cc, exporting exactly
  the names in a .def file.

• pe32_emu: array, put and get lay out the game's structures; the sample DLL gains
  sum_list and heaviest_path to test them.

• tools/formats/derived.py: which fields next to geometry are bounds, centres, normals or
  plane distances.

• Reading the story, from the Hardwar project: the guide
  Reading the story for design decisions, which makes the case that a
  game's manual and its own text say what each system is for and which must be exact, with
  Hardwar as the worked example. re-inventory has a new step, "Read the story", and
  re-start, re-surveyor and the games taxonomy point to it. New projects get a
  docs/lore.md template with the table "in the story → in the code → evidence".

• A case study of Hardwar (1998), and Hardwar in the vehicle simulations' reference games.

• tools/triage/sentences.py: the sentences in a program or a Ghidra strings.txt, ASCII and
  UTF-16, with addresses, for reading the story.

• tools/formats/shadetable.py: a palette game's shade, fog or light table, with the levels
  that are black, unchanged and white, the colour it fades toward, the shift that reaches
  normal light, and a picture.

• xorscan.py --records and --key-in: a key XORed into one field of every directory record,
  read from the names' zero padding and completed from the executable.

• rawimage.py and catalog.py --dac shift: 6-bit palettes shifted left by 2 (63 is 252).
  The catalogue fills a palette of fewer than 256 colours with magenta.

• constants.py reports Park-Miller's 16807 without --all when its modulus 0x7fffffff, or
  Schrage's 127773 or 2836, is beside it.

• new-site.sh --manual: a Pages workflow that runs only when started by hand. New sites get a
  theme to colour from the game and a public/ folder; re-site asks for figures and diagrams
  in every diary entry from the first. re-browse describes the viewer's --export mode for
  agents.

• Know-how from Hardwar: Watcom pseudocode that drops register arguments, the x87 control word
  0x0c7f, a variable frame step in replays, 6-bit palettes shifted by 2, light tables with an
  unchanged level, worktrees without the ignored folders and Ghidra's project lock, and
  reading the story. The entries on missed functions and on Watcom name exportcov and Hardwar.

• Know-how entries for GameFrame's own tools: unmapped memory under the emulators, an import
  with no handler, a tool run without the .venv, and Ghidra refusing a path in a dot folder.

• dos_env has a keyboard: env.press(scan, at, hold) and env.key_script('10:39:3') put
  make and break codes on port 0x60 and raise IRQ 1 through the game's INT 9 handler, which
  acknowledges through port 0x20. The BIOS's INT 9 feeds the INT 16h queue, and INT 16h waits
  for a key still to come. The DOS sample gains wait_keys and a keyboard handler.

• tools/triage/exportcov.py: how much code a Ghidra export covers, its largest gaps, and the
  likely starts of the functions it missed (call targets, starts after a return or padding),
  written for the batch decompile.

• pe32_emu: fpu_cw= loads an x87 control word before a call, fpu_modes() lists the cases
  whose result depends on the rounding mode, and until= stops at an address and returns the
  stack there, as for a call to sprintf. The sample's 32-bit DLL gains fix_mul (a magic-number
  fadd) and report (a call to wsprintfA).

• validate.py --write: decode, encode and compare every file, naming the first differing byte.
  The sample decoder has an encode.

• tools/live/memlog.py (read a recording back: summary, CSV), tools/live/emulock.py (who
  uses a shared emulator) and tools/live/loopcut.py (a recorded path cut into one loop).

• Thirty-five know-how entries promoted from the POD: Planet of Death project. They cover
  replacement card libraries under Wine (Glide 2, the S3D Toolkit, ViRGE surfaces, missing
  card libraries), mods (the install folder first, values replaced at run time, mods in a
  reference recording),
  recording a run from memory and replaying it (samples that straddle frames, stand-ins for
  unported logic, a game clock that is not real time, waiting for a phase), x87 rounding and
  truncating helpers, functions Ghidra missed and claims that need an address scan, editors
  and writers (one edit type, float views, derived geometry data, round trips of every file,
  axes measured in the running game), input drivers (held keys, click timing, closed racing
  lines), shared VMs (pkill, sudo and DISPLAY), keeping every dialog, and the emulated-PC
  route (CD drives under Wine on Linux, Xvfb and a window manager, SSH, a script that shadows a
  standard module). The card builds' context now says to measure what the card is given.

• tools/triage/refs.py: every instruction that refers to an address, found in the code bytes
  (32-bit immediates and displacements, 64-bit RIP-relative). Each hit is marked as a read, a
  write or a value. Hits outside any function are marked too. The sample's 32-bit DLL has a
  table with two writers to test it.

• tools/live/memrec.py: snapshots of a running game's wr...

GameFrame 1.0.1

GameFrame 1.0.1 sets up projects for the coding agents they name, and adds a website with a
diary of the work.

Skills and agents

• A new skill, re-site, builds and keeps a project's website: a VitePress site in
  sites/<name>/, or one site/. It holds a diary with one entry per milestone and the
  project's documents shown through @include, so each has one copy. Entries are written for
  readers, as findings with their evidence, never as commit lists or tool output.
• A new task agent, re-publisher, writes the diary entry for each milestone, adds pages for
  new documents and checks the site before re-lander commits it.
• scripts/new-site.sh starts a site from templates/site/, with a GitHub Pages workflow that
  builds every site in the project.
• tools/site/check.py checks a site for game files, decompiled code, missing includes, diary
  entries without a title or summary, and entries that read like a commit log.
• New projects get milestones in their AGENTS.md and checklist. A viewer of every asset comes
  before the game, since each format then becomes a reader, a document and a viewer panel that
  the rest of the project reuses. re-start gives the same goals.

Projects

• new-project.sh --agent LIST sets a project up for the coding agents it names: claude,
  codex, gemini, copilot, cursor, opencode, or all (the default). Each agent gets its
  skill link, its agents, its gate hooks and its MCP servers. Without claude the project has no
  .claude/settings.json or CLAUDE.md.
• update-project.sh --agent LIST adds agents to a project. Without it, the script refreshes
  the agents whose files the project already has.
• A plugin project now works in the other agents too. They get a copy of the skills in skills/
  with the .agents/skills link, and Cursor gets its agents in .cursor/agents.
• ./gameframe gate KIND runs GameFrame's gates from a plugin project, which has no scripts/.
  Its Codex, Gemini CLI, Cursor and Copilot hooks call it.
• scripts/clients.py holds the list of files each agent needs. Both project scripts use it.
• A copied project's hook files now come from GameFrame too, so new-project.sh --copy gives
  Codex, Cursor and Copilot their hooks.

GameFrame 1.0.0

GameFrame 1.0.0 runs its playbook in any coding agent. Claude Code, Codex, Gemini CLI, GitHub Copilot, Cursor and OpenCode can each use the skills, the agents, the gates and the MCP servers.

Skills

• The skills live in one skills/ folder. .claude/skills and .agents/skills link to it, so every agent finds the same copy.
• The skills' wording no longer assumes Claude Code.

Agents

• agents/re-*.md stays the one source for the 9 stage agents and 9 task agents.
• gameframe agents --emit all writes copies for Codex (.codex/agents), Gemini CLI (.gemini/agents), Copilot (.github/agents) and OpenCode (.opencode/agents). Each copy keeps its agent's limits, as an allowlist, a deny map or a sentence in its instructions.
• A session that cannot start subagents takes each role itself, from the agent's file.
• The support matrix in docs/working/agents.md shows where each client reads rules, skills, subagents, hooks and MCP servers.

Gates

• A git pre-commit hook blocks game material and decompiled code for every client and for people.
• Hook adapters for Claude Code, Codex, Gemini CLI, Cursor and Copilot. Outside Claude Code, agents name themselves to the gates with GAMEFRAME_AGENT=<name>.

MCP and rules

• gameframe mcp --emit all writes each client's MCP configuration from .mcp.json, and points each client at AGENTS.md.

Projects

• new-project.sh --copy and update-project.sh copy the skills folder and every client's agents. Older projects' .claude/skills move to skills/.

Plugin

• The Claude Code plugin now carries version 1.0.0. Claude Code updates it when the version changes, so plugin projects move from release to release.