Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

chore(prompts): retire order 428, model-trellis VRAM recycle guard shipped

nirholas5bcf53e17512
diff --git a/prompts/finish/428-auto-model-trellis-vram-recycle.md b/prompts/finish/428-auto-model-trellis-vram-recycle.md
deleted file mode 100644
index 6429b9fbe..000000000
--- a/prompts/finish/428-auto-model-trellis-vram-recycle.md
+++ /dev/null
@@ -1,172 +0,0 @@
-# 428: give model-trellis a VRAM recycle guard before its own liveness probe kills it mid-job
-
-**How to run this:** paste this whole file into a fresh Claude Code session opened in the
-`three.ws` repo (any worktree). No TARGET needed; this file is complete on its own.
-
-## Binding operating clause
-
-1. Finish 100%. Never end this task with a question, a plan, or "want me to proceed?". Pick
- the reasonable interpretation and ship it. The only exception is the real production
- deploy of `model-trellis`, which is gate-2 (GPU Cloud Run service): leave that single
- `gcloud builds submit` step for the owner and say so in the report. Everything else,
- including writing and passing new tests, is this agent's job to finish, not describe.
-2. No mocks, no fake data, no stub functions, no `TODO`, no commented-out code, no
- `setTimeout` fake-anything, no em dash (`—`) or en dash (`–`) anywhere you write text.
-3. This is a bug fix: write a failing test that reproduces the gap FIRST, confirm it fails
- for the right reason, then fix the code, then confirm it passes. Commit the test and the
- fix together.
-4. Stage explicit paths only (never `git add -A` or `git add .`). Other agents share this
- worktree and may have unrelated work staged; re-run `git status` and
- `git diff --staged` immediately before your commit to make sure you are only committing
- what you touched.
-5. Commit message must describe the diff (see CLAUDE.md "Commit messages"): no "sync",
- "wip", "update", "chore: progress", etc. Something like
- `fix(model-trellis): recycle an instance before VRAM exhaustion kills it mid-job, not after`.
-
-## Why this order exists (measured 2026-10-24)
-
-`model-trellis`'s own `/health` liveness probe killed a live instance mid-inference TODAY:
-
-```
-2026-10-24T09:35:02.912342Z ERROR LIVENESS HTTP probe failed 3 times consecutively for
- container "server-1" on port 8080 path "/health". The instance has been shut down.
- Connection failed with status ERROR_TIMEOUT.
-```
-
-That kill was preceded and followed by a storm of Cloud Run "malformed response or
-connection error" 502s as clients tried to reach the dying instance (same minute, dozens of
-occurrences; `gcloud logging read` command to reproduce is in Step 0). This is not a one-off:
-the exact failure mode is already diagnosed in the worker's own source, left behind from a
-prior incident, at `workers/model-trellis/main.py:829-845` (the `finally:` block of
-`_run_job`):
-
-> "Nothing else frees it. Torch's caching allocator holds freed blocks in reserve, and
-> nvdiffrast's rasterizer allocates through its own cudaMalloc outside that cache, so an
-> instance's usable VRAM only ever shrinks. The instance stays healthy for a while and then
-> fails EVERY later job with `Cuda error: 2[cudaMalloc(&m_gpuPtr, bytes);]` out of
-> postprocess_mesh's `_fill_holes`, while its health check keeps passing and Cloud Run keeps
-> routing to it. That is exactly how this lane died: 1,189 generations on 2026-09-06, then on
-> 2026-09-09 thirteen jobs succeeded after a restart and every single job after them failed."
-
-`_release_gpu_memory()` (`main.py:848-858`) already calls `torch.cuda.empty_cache()` and
-`torch.cuda.ipc_collect()` after every job, and the comment explains why that is not enough:
-nvdiffrast's own `cudaMalloc` calls never go through torch's allocator, so they are
-unreachable by `empty_cache()`. VRAM only ratchets down.
-
-The worker already has exactly this pattern for HOST memory: `instance_health.py`'s
-`MemorySample` + `should_recycle()`, wired into `main.py`'s `_recycle_if_bloated()`
-(`main.py:641-675`), drains and restarts an instance BETWEEN jobs once host RAM has
-ratcheted past `RECYCLE_FRACTION` (80%) and grown at least `RECYCLE_MIN_GROWTH` (15%) past
-its post-load baseline. That guard reads cgroup memory files; it cannot see GPU device
-memory at all, so it never fires on this leak. There is no VRAM equivalent anywhere in the
-file (confirmed: `grep -n "memory_allocated\|memory_reserved\|mem_get_info\|VRAM" main.py
-instance_health.py` returns nothing today). That is the gap: an instance can be well under
-its RAM ceiling while its VRAM is exhausted, so it runs straight into the liveness-probe kill
-instead of recycling cleanly between jobs the way the RAM guard already does.
-
-This is a **live production defect** (today's kill is proof, not history) with a **known,
-already-diagnosed root cause**, and a **direct, non-owner-gated code fix** that extends an
-existing, already-tested pattern in the same file rather than inventing a new one. Per
-RUN-ORDER (live defect with a real fix outranks everything not already in flight), this is
-this run's top order.
-
-## Step 0: re-derive current state (re-run before touching anything)
-
-```bash
-# 1. Confirm the liveness-probe kill is still a live pattern, not historical.
-gcloud logging read 'resource.type="cloud_run_revision" resource.labels.service_name="model-trellis" textPayload:"LIVENESS HTTP probe failed"' \
- --project aerial-vehicle-466722-p5 --freshness=168h --limit=50 --format="value(timestamp)"
-
-# 2. Confirm no VRAM-aware guard exists yet (should return nothing).
-grep -n "memory_allocated\|memory_reserved\|mem_get_info\|vram\|VRAM" \
- workers/model-trellis/main.py workers/model-trellis/instance_health.py
-
-# 3. Re-read the leak diagnosis and the existing RAM-guard wiring in full.
-sed -n '620,680p;825,860p' workers/model-trellis/main.py
-sed -n '1,220p' workers/model-trellis/instance_health.py
-
-# 4. Confirm current healthz / test baselines so you know what you touched vs. pre-existing.
-curl -s --max-time 15 https://three.ws/api/healthz | python3 -c "import json,sys;d=json.load(sys.stdin);[print(s['name'],s['status']) for s in d['subsystems']['subsystems']]"
-cd workers/model-trellis && python3 -m pytest test_instance_health.py test_app_contract.py -q
-```
-
-If step 1 returns zero rows in the last 168h, the kill has stopped recurring on its own;
-still ship the fix (the root cause in the code comment is unchanged and the next heavy job
-will reproduce it), but note the gap in your report rather than treating it as resolved.
-
-## Tasks
-
-1. **Add a VRAM sample type and recycle check to `workers/model-trellis/instance_health.py`**,
- next to `MemorySample`/`read_memory`/`should_recycle` (this module is pure stdlib today;
- keep it that way, torch is NOT importable here, the caller passes in numbers it already
- has from `torch.cuda.mem_get_info()`):
- - A `VramSample` dataclass (or reuse `MemorySample`'s shape: `used_bytes`, `limit_bytes`,
- `source="cuda"`, with the same `.fraction` and `.describe()`), built from
- `torch.cuda.mem_get_info()` return values (`free_bytes, total_bytes`; used = total - free).
- - `VRAM_RECYCLE_FRACTION` (env `VRAM_RECYCLE_FRACTION`, default `0.90`, matching the
- tighter ceiling a VRAM OOM implies versus the host-RAM `0.80`) and
- `VRAM_RECYCLE_MIN_GROWTH` (env `VRAM_RECYCLE_MIN_GROWTH`, default `0.10`).
- - Reuse `should_recycle()` as-is if `MemorySample` covers the VRAM shape (preferred, avoids
- duplicating logic); only add a new function if the shapes genuinely diverge.
-2. **Wire it into `workers/model-trellis/main.py`:**
- - In `_load_pipeline()` (around line 281-296), after `_memory_baseline = read_memory()`,
- add a `_vram_baseline` sample captured the same way, using
- `torch.cuda.mem_get_info()` when `torch.cuda.is_available()`, else `None`.
- - In `_recycle_if_bloated()` (`main.py:641-675`), after `_release_gpu_memory()` has already
- run for the job (it's called from `_run_job`'s `finally`, which completes before
- `_run_inference`'s `finally` calls `_recycle_if_bloated`), sample current VRAM the same
- way and OR it into the existing recycle decision: recycle if the RAM guard says so, OR
- the VRAM guard says so. Log which guard fired (extend the existing `log.warning(...)`
- call, do not add a second one) so a future incident is diagnosable from logs alone.
- - Guard every new `torch.cuda.*` call behind `torch.cuda.is_available()` exactly like
- `_release_gpu_memory()` already does, so the unit tests (which import this module
- without a GPU) keep working untouched.
-3. **Tests first, per the bug-fix-is-test-first rule:** add to
- `workers/model-trellis/test_instance_health.py` (or a focused new test file beside it if
- the VRAM shape diverges enough to need its own helpers) cases mirroring the existing RAM
- ones (`test_recycles_a_ratcheted_instance`, `test_leaves_a_healthy_instance_alone`,
- `test_high_baseline_alone_never_recycles`, `test_unknown_memory_never_recycles`) applied to
- the VRAM sample/threshold. Also add a `main.py`-level test (alongside
- `test_app_contract.py`'s existing patterns, mocking `torch.cuda.mem_get_info` and
- `torch.cuda.is_available` the way that file already mocks CUDA availability) proving
- `_recycle_if_bloated` drains and signals a restart when VRAM alone has ratcheted past
- threshold even though host RAM is nowhere near its ceiling. Run the new tests, confirm
- they fail against the pre-fix code for the right reason (no VRAM path exists yet), then
- make them pass.
-4. **Update `workers/model-trellis/README.md`** if it documents the recycle thresholds (grep
- for `RECYCLE_FRACTION` in it first) so the new `VRAM_RECYCLE_FRACTION` /
- `VRAM_RECYCLE_MIN_GROWTH` env vars are discoverable the same way the RAM ones are.
-5. Append a `data/changelog.json` entry (internal/reliability category) describing the fix in
- user-relevant terms (Forge image-to-3D jobs on the `trellis` lane failing or stalling less
- often), per CLAUDE.md's Definition of Done. Run `npm run build:pages` after.
-
-## Definition of done (mechanically checkable)
-
-- [ ] `grep -n "mem_get_info" workers/model-trellis/main.py workers/model-trellis/instance_health.py` finds the new code.
-- [ ] `cd workers/model-trellis && python3 -m pytest -q` passes, including new VRAM-guard tests, with zero changes to pre-existing test outcomes.
-- [ ] The new tests, run against a git stash of just the `instance_health.py`/`main.py` changes (or checked out pre-fix), fail for the VRAM-guard-missing reason, not a setup error. State the before/after pytest output in the report.
-- [ ] `_recycle_if_bloated` recycles on VRAM growth alone (synthetic `mem_get_info` returning a shrinking "free" value across calls) even when the RAM sample is healthy, proven by a passing test.
-- [ ] No new `torch.cuda.*` call is reachable without a `torch.cuda.is_available()` guard (grep confirms every new call site is inside such a guard or inside a function already gated by one).
-- [ ] `npm run check:rules -- --paths workers/model-trellis/main.py workers/model-trellis/instance_health.py workers/model-trellis/test_instance_health.py` clean.
-- [ ] `data/changelog.json` has a new entry; `npm run build:pages` run after.
-- [ ] Code + tests committed with explicit paths; deploy (`gcloud builds submit` for `model-trellis`) is the one step left for the owner, named plainly in the report.
-
-## Never blocked (pre-answered)
-
-| Blocker | Do this |
-|---|---|
-| No GPU available in this environment to run real CUDA calls | Mock `torch.cuda.mem_get_info` and `torch.cuda.is_available` in tests, exactly as `test_app_contract.py` already does for other CUDA-gated paths. The unit tests must never require a real GPU; that is why `instance_health.py` is pure stdlib today. |
-| Can't verify the fix against a live GPU instance | That requires deploying `workers/model-trellis` to Cloud Run, a gate-2 action. Finish and commit all code and tests so the fix is deploy-ready; name the exact `gcloud builds submit` step as the owner's one remaining action. Do not stall on it. |
-| Unsure whether to reuse `MemorySample` or add `VramSample` | Reuse `MemorySample` if its three fields (`used_bytes`, `limit_bytes`, `source`) fit VRAM without a lie in the field names; only branch into a new type if something about VRAM genuinely does not fit (there is no such need identified in this order; default to reuse). |
-| Unsure what the right VRAM threshold is since there's no historical VRAM telemetry to calibrate against | Use the defaults specified in Task 1 (`0.90`/`0.10`), tighter than the RAM guard's `0.80`/`0.15` because a VRAM OOM has no graceful fallback (it crashes the job), whereas host RAM pressure degrades first. Make both overridable by env var exactly like the RAM pair, so the owner can tune later without a code change. |
-| `npm run check:rules` or `check:claude` fails on an unrelated pre-existing issue | Fix only what your diff touches; if the failure is clearly pre-existing and unrelated, note it in the report rather than scope-creeping into an unrelated fix. |
-
-## Report format
-
-1. Step 0 output: the fresh `gcloud logging read` liveness-kill count for the last 168h, and
- the pre-fix `grep` proving no VRAM guard existed.
-2. The diff summary: files touched, one line each.
-3. Before/after test output proving the new tests fail pre-fix and pass post-fix.
-4. The exact commit hash(es) and message(s).
-5. The one named owner action remaining (the `model-trellis` Cloud Run deploy), or "none" if
- somehow not applicable.
diff --git a/prompts/finish/_context/production-100-OWNER-ACTIONS.md b/prompts/finish/_context/production-100-OWNER-ACTIONS.md
index cb0ab97fe..16b79ef15 100644
--- a/prompts/finish/_context/production-100-OWNER-ACTIONS.md
+++ b/prompts/finish/_context/production-100-OWNER-ACTIONS.md
@@ -87,6 +87,7 @@ on it; some resolve themselves as other work lands.
| 68 | world.three.ws has been unreachable since the backing Cloud Run service `hyperfy-world` was deleted via the Cloud Run API by `[email protected]` at 2026-10-23T02:48:38Z (confirmed via `gcloud logging read 'protoPayload.methodName="google.cloud.run.v1.Services.DeleteService"'`), a deliberate recent action, not drift. The `world.three.ws` domain mapping is itself still healthy and provisioned; it now points at a service that no longer exists, which is why it answers a generic 404 instead of a branded error. Decide: redeploy (`bash deploy/world/apply-hardening.sh`, fully scripted and idempotent, documented in `deploy/world/README.md`) or formally retire the surface (remove the domain mapping and any in-product links to it). `/api/healthz` now correctly reports this as `world: down` instead of masking it as `unknown` (order 413). | decision | world.three.ws restoration or retirement | `deploy/world/README.md` |
| 69 | **Redeploy `remesh-service`.** Added 2026-10-24 by the triage-lane deep sweep: production logs show `remesh-service` segfaulting ("Uncaught signal: 11") twice in 24h inside `_convert_to_fbx_preserving_rig` → `_blender_convert`, the exact "Blender dies in its own interpreter teardown after a fully written export" failure that commit `59d9aa9cd` (2026-08-11, "stop discarding a finished FBX because Blender crashed on the way out") already fixed by judging completion on the FACE_COUNT marker and a non-empty output file rather than the child's exit code. `gcloud run revisions describe remesh-service-00005-8rr --region us-central1` shows that revision was created 2026-07-16, five weeks before the fix landed: this is pure deploy lag on a service three.ws's own deploy cadence does not currently cover (row 1 tracks `three-ws-api`, which is current at `660b5ad97`, 0 commits behind `threews/main`; the 20-service Cloud Run fleet deploys independently per service). No code change needed, the fix already exists; only a rebuild and redeploy of this one GPU worker is owner-gated. Command: `gcloud builds submit --config workers/remesh/cloudbuild.yaml .` from the repo root, then confirm no new "Uncaught signal: 11" lines appear for `remesh-service` over the following 24h. | one build + one deploy | Stops rig-preserving FBX exports from occasionally crashing the whole `remesh-service` instance mid-request | `workers/remesh/main.py` (`_blender_convert`), [docs/ops/production-log-triage.md](../../docs/ops/production-log-triage.md) |
| 70 | **Set `GITHUB_TOKEN` on `three-ws-api`.** Added 2026-10-24, order 412 close-out. Production runs every `api.github.com` call (ship feed, commit-feed-push cron) unauthenticated, sharing one 60-requests/hour budget per egress IP across both features; `gcloud run services describe three-ws-api --region us-central1 --project aerial-vehicle-466722-p5` confirms no `GITHUB_TOKEN`/`GH_TOKEN` is configured. Order 412 already made exhaustion a non-event (`/api/ship/feed` now serves the last-known-good feed marked stale instead of throwing; `pushTelegramLane()` now returns `{ skipped: 'github_rate_limited' }` instead of throwing), so this is optional, not a blocker. Setting the token raises the shared ceiling from 60 to 5,000 requests/hour, which reduces how often those stale/skip paths are ever exercised. Command: `gcloud run services update three-ws-api --region us-central1 --update-env-vars GITHUB_TOKEN=<a GitHub personal access token with no special scopes; read-only public access is enough>`. | minutes | Fewer stale ship-feed reads and skipped commit-feed-push ticks under shared-IP GitHub traffic | this order's commit, `api/ship/feed.js`, `api/_lib/commit-feed-push.js` |
+| 71 | **Redeploy `model-trellis`.** Added 2026-10-25, order 428 close-out. `main.py`/`instance_health.py` now carry a VRAM recycle guard (commit `9bbea4c095c55d9ca104fba0c657af3712df3538`) that restarts an instance cleanly between jobs once GPU memory has ratcheted toward its ceiling, the same way the existing host-RAM guard already does; this closes the gap that let the instance's own `/health` liveness probe kill it mid-inference twice in the 168h to 2026-10-25 (`LIVENESS HTTP probe failed` at `2026-10-24T09:35:02Z` and `2026-10-24T14:49:19Z`). The fix is code-only and fully tested (52/52 passing, including the new VRAM cases); only the GPU Cloud Run build/deploy is owner-gated. Command: `gcloud builds submit --config workers/model-trellis/cloudbuild.yaml .` from the repo root (or the NGC variant, `cloudbuild.ngc.yaml`, if that is the active build lane), then confirm no new `LIVENESS HTTP probe failed` lines appear for `model-trellis` over the following 24h. | one build + one deploy | Stops the trellis image-to-3D lane from crashing or getting killed mid-job once VRAM ratchets up | `workers/model-trellis/instance_health.py`, `workers/model-trellis/main.py` |
Deleted 2026-09-01: the former row 5 (`WALLET_ENCRYPTION_KEY_PREVIOUS` policy), which
declared itself "delete on reading" and had outlived that by three weeks.
diff --git a/prompts/finish/_context/production-100-PROGRESS.md b/prompts/finish/_context/production-100-PROGRESS.md
index bf587548b..f2e97858c 100644
--- a/prompts/finish/_context/production-100-PROGRESS.md
+++ b/prompts/finish/_context/production-100-PROGRESS.md
@@ -1786,3 +1786,15 @@ Added `scripts/check-cron-budget-wiring.mjs` (wired as `npm run check:cron-budge
Verification: `npm run check:cron-budget-wiring` exits 0. `npm run check:cron-syntax` exits 0 (150 declared crons, all valid). `npm run check:rules -- --paths <all ten fixed files, the new script, the new test, package.json>`: "OK: no hard-rule violations." `npm run test:core`: 41 files / 72 tests failed, same pre-existing order-401 baseline class (mcp-agent confirmation-required message-shape drift, an Upstash rate-limit quota exhaustion in `mcp-studio-ratelimit.test.js`); grepped the failing file list for every touched filename and for `cron-budget-wiring`: zero matches, so this order introduced no new failures. `git diff --staged --stat` reviewed before committing: exactly the ten two-line hunks, the new script, the new test, and the two-line `package.json` change (no stray em-dashes, no other files). Other agents' concurrent `public/changelog*.json`/`public/sitemap/index.html` churn in the shared worktree was left untouched; staged explicit paths only, never `-A`. Fix commit: `15e77e4c48...` (see `git log --oneline -1` on this worktree for the full SHA at close time).
Left: nothing for this order's own scope. `prompts/finish/427-auto-cron-maxduration-wiring-sweep.md` deleted in this closing commit.
+
+## 2026-10-25: order 428 (model-trellis VRAM recycle guard) closed
+
+Step 0 re-derived cleanly: `gcloud logging read` against `model-trellis` (project `aerial-vehicle-466722-p5`) for `LIVENESS HTTP probe failed` returned two rows in the last 168h, `2026-10-24T09:35:02.912342Z` (the order's cited kill) and `2026-10-24T14:49:19.036068Z` (a second one, same class, after the order was written), confirming the defect is still live, not historical. `grep -n "memory_allocated\|memory_reserved\|mem_get_info\|vram\|VRAM" workers/model-trellis/main.py workers/model-trellis/instance_health.py` returned only the pre-existing diagnosis comment in `main.py`'s `_run_job` finally block, confirming no VRAM guard existed yet.
+
+Did: added `vram_sample(free_bytes, total_bytes)` to `instance_health.py`, reusing `MemorySample`'s shape (`used_bytes = total - free`, `source = "cuda"`) rather than a divergent type, plus `VRAM_RECYCLE_FRACTION` (env `VRAM_RECYCLE_FRACTION`, default `0.90`) and `VRAM_RECYCLE_MIN_GROWTH` (env `VRAM_RECYCLE_MIN_GROWTH`, default `0.10`), tighter than the host-RAM pair since a VRAM OOM crashes the job outright with no graceful degradation. `should_recycle()` needed no change; its existing two-condition shape (near the ceiling AND grown past baseline) applies unchanged to a VRAM sample. Wired a `_read_vram()` helper into `main.py` (the only call site for `torch.cuda.mem_get_info()`, gated behind `torch.cuda.is_available()`), called it from `_load_pipeline()` to capture `_vram_baseline` the same way `_memory_baseline` is captured, and OR'd a VRAM check into `_recycle_if_bloated()` alongside the existing RAM check, extending the single `log.warning(...)` call to name which guard fired and both samples' values so a future incident is diagnosable from logs alone. Fixed a latent crash in the branch: the original code called `sample.describe()` unconditionally once a recycle decision was made, which is safe when only the RAM path can trigger it (should_recycle's own None-guard), but not once a VRAM-only decision is possible with `sample is None`; guarded both `.describe()` calls.
+
+Test-first, per the bug-fix rule: added VRAM cases to `test_instance_health.py` (`vram_sample` shaping, `should_recycle` applied to VRAM fractions, a tighter-threshold assertion) and a new `test_vram_recycle.py` exercising `main.py`'s `_recycle_if_bloated`/`_read_vram`/`_load_pipeline` directly, monkeypatching `torch.cuda.is_available`/`mem_get_info` per the order's own pre-answered blocker. This sandbox has no `torch` package at all (not just no GPU), so added `conftest.py`: a minimal `torch.cuda`/`torch.hub` stub installed into `sys.modules` only when a real `import torch` fails, leaving a real install (production, Docker) completely untouched. Ran the new tests against the pre-fix code (swapped `main.py`/`instance_health.py` back to `git show HEAD:...` temporarily, restored after): 3 of the new main.py-level tests failed with `AttributeError: module 'main' has no attribute '_read_vram'` and the instance_health tests failed to even collect (`ImportError: cannot import name 'VRAM_RECYCLE_FRACTION'`), both the stated missing-guard reason, not a setup error. Restored the fix; full suite 52/52 passed.
+
+Verification: `grep -n "mem_get_info" workers/model-trellis/main.py workers/model-trellis/instance_health.py` finds the new code. Every new `torch.cuda.*` call site (`main.py`'s `_read_vram`) sits directly behind its own `is_available()` guard; grepped to confirm. `npm run check:rules -- --paths workers/model-trellis/main.py workers/model-trellis/instance_health.py workers/model-trellis/test_instance_health.py workers/model-trellis/test_vram_recycle.py workers/model-trellis/conftest.py`: "OK: no hard-rule violations." `data/changelog.json` carries a new `fix`-tagged entry (`/image-to-3d` link); `npm run build:pages` run after, regenerating `CHANGELOG.md` and the `public/changelog*` outputs. `git status`/`git diff --staged` re-checked immediately before committing; staged explicit paths only (never `-A`). Fix commit: `9bbea4c095c55d9ca104fba0c657af3712df3538`.
+
+Left: the one gate-2 action named in the order, a real production deploy (`gcloud builds submit` for `model-trellis`), for the owner. Everything else in the order's definition of done is shipped and verified in this worktree. `prompts/finish/428-auto-model-trellis-vram-recycle.md` deleted in this closing commit.