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.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
chore(prompts): file orders 453-454, world.three.ws outage masked as unknown and three root CVEs with no filed order
nirholasaad66045ba17
diff --git a/prompts/finish/453-auto-world-health-masked-down-state.md b/prompts/finish/453-auto-world-health-masked-down-state.mdnew file mode 100644index 000000000..738499575--- /dev/null+++ b/prompts/finish/453-auto-world-health-masked-down-state.md@@ -0,0 +1,85 @@+# 453. `/healthz` reports `world` as `unknown` when it is really `down`, hiding a 3-month-old, 222-occurrence outage from the one dashboard built to show it++How to run: paste this file's repo path into a fresh Claude Code chat in this repository and say "run this work order". Runnable now, no gate, no owner action required.++## Operating clause (binding)++- Read CLAUDE.md first. CLAUDE.md overrides everything, including this file.+- Finish 100% in this session. Never end the turn with a question, an option list, or an unexecuted plan. A judgment call goes in one line of the final report; it never becomes a question that halts work.+- The only permitted stops are the CLAUDE.md stop-and-ask gates: spending real funds or any irreversible on-chain write, git push or a production deploy, posting to an external channel, committing content that references a crypto project other than $THREE, and destroying unrecoverable data. This order touches none of them: it edits two JS modules, two docs files, and adds a test. It does NOT redeploy, recreate, or touch the `hyperfy-world` Cloud Run service or its domain mapping (see "Why this is not a redeploy order" below).+- The em-dash and en-dash characters are banned in everything you write.+- Concurrent agents share this worktree: stage explicit paths only (never `git add -A` or `git add .`), re-check `git status` and `git diff --staged` before each commit.+- Before committing, run `npm run check:rules -- --paths <files you touched>`. It must exit 0.+- Bug fixes are test-first (CLAUDE.md): confirm the existing/new test fails for the stated reason before changing `subsystem-health.js`, then fix, then confirm it passes.++## Why this matters (measured 2026-10-25)++Three independent measurements, taken in this order, establish the finding:++1. **The world has been down, repeatedly, for three months and is still down right now.** Queried the production database directly (`DATABASE_URL` resolves from `.env.local`, same convention `scripts/apply-migrations.mjs` uses):++ node -e "+ require('dotenv').config({path:'.env.local'});+ require('dotenv').config({path:'.env'});+ import('./api/_lib/db.js').then(async (m) => {+ const rows = await m.sql\`select signature, title, detail, count, first_seen, last_seen from ops_alerts where title ilike '%world%' order by last_seen desc limit 5\`;+ console.log(JSON.stringify(rows, null, 2));+ });+ "++ Top row: `title: "World DOWN", detail: "https://world.three.ws/status returned HTTP 404", count: 222, first_seen: 2026-07-21T04:30:00Z, last_seen: 2026-10-25T08:31:59Z`. The world-health cron (`api/cron/world-health.js`, runs every 15 minutes per `vercel.json`) has been correctly detecting and alerting on this for three months. This is not a blip.++2. **`/healthz` cannot show it.** `curl -s https://three.ws/api/healthz` reports the `world` subsystem as `{"status":"unknown","detail":"no world-health report yet"}` even though the cron ran 4 minutes earlier (confirmed via `gcloud scheduler jobs describe cron--api-cron-world-health --location=us-central1`, `lastAttemptTime` within the last 15-minute window, `status: {}` meaning the HTTP call itself succeeded). Invoking the cron's own endpoint directly with its scheduler secret (pulled from the scheduler job's own `httpTarget.headers.Authorization`, which is visible to anyone with `gcloud scheduler jobs describe` access) proves the cron does see and report the failure:++ curl -s -H "Authorization: Bearer <the scheduler job's own bearer secret>" \+ "https://three-ws-api-lp642k3kpa-uc.a.run.app/api/cron/world-health"+ # => {"status":"down","protected":null,"blueprintCount":0,"reason":"HTTP 404"}++ So the cron computes `down` correctly, in 200ms, and `/healthz` still says `unknown`. Root cause, read from the code: `checkWorld()` in `api/_lib/ops/subsystem-health.js:332` has exactly one source of truth, an ephemeral Redis-backed cache key (`WORLD_HEALTH_CACHE_KEY = 'world:health'`, 1-hour TTL) the cron writes with `await cacheSet(...).catch(() => {})` (`api/cron/world-health.js`, three call sites, all swallow the error). `api/_lib/cache.js` documents its own production failure mode in detail: a SET-failure-streak circuit (`SET_FAIL_THRESHOLD = 5` consecutive failures suppresses ALL writes for `SET_SUPPRESS_MS = 60_000`, falling back to a **per-instance** in-memory map) plus a `totalSetFailures` counter that `/healthz`'s own `cache` subsystem reports as 67 and climbing. Cloud Run runs multiple instances; a SET that falls back to instance A's memory is invisible to the instance that later serves the `/healthz` read. Any write that lands during a suppression window, or on an instance that later scales down, produces exactly the symptom measured: a durable, 222-times-confirmed `down` state reported as `unknown`.++3. **The underlying Cloud Run service is genuinely gone, not crashing.** `gcloud run services list --project=aerial-vehicle-466722-p5` (50 services, every region) has no `hyperfy-world`. The Cloud Run audit log confirms why:++ gcloud logging read 'resource.type="cloud_run_revision" AND protoPayload.methodName="google.cloud.run.v1.Services.DeleteService" AND protoPayload.resourceName:"hyperfy-world"' --project=aerial-vehicle-466722-p5 --freshness=90d --format=json++ `2026-10-23T02:48:38Z`, `principalEmail: [email protected]` (the project's own owner account), `DeleteServiceRequest` for `namespaces/aerial-vehicle-466722-p5/services/hyperfy-world`. **The owner deleted the service two days ago**, presumably after three months of an unresolved, repeatedly-alerting outage (the 222-count alert started 2026-07-21, long before the deletion). `gcloud beta run domain-mappings list` still shows `world.three.ws -> hyperfy-world` with `status: True`, i.e. the DNS/domain mapping is orphaned: it points at a route that no longer exists, so every real visitor to `https://world.three.ws` gets Google's bare, unbranded `Error: Page not found` HTML (verified live, `curl -s https://world.three.ws/` and `/status` both return it) instead of anything three.ws-branded.++## Why this is not a redeploy order++The owner's own account deleted `hyperfy-world` deliberately, two days ago, after the exact failure this order is about had been alerting for three straight months. Recreating it would second-guess a recent, explicit owner infrastructure decision this order has no basis to override. **Do not run `deploy/world/apply-hardening.sh`, do not recreate the `hyperfy-world` Cloud Run service, and do not touch the `world.three.ws` domain mapping** (`gcloud run domain-mappings` / `gcloud beta run domain-mappings`) in this order. The work here is entirely about making the platform's own monitoring and documentation tell the truth about a state that already exists, which is valuable regardless of whether the owner ever redeploys the world:++- Right now, nobody who checks `/healthz` (or any dashboard built on it) can see that `world` is down; they see `unknown`, which reads as "monitor hasn't run yet," not "has been failing for three months."+- `STRUCTURE.md` and `deploy/world/README.md` both still claim the service is "Live," which is false and will mislead the next engineer (or agent) who reads them before touching anything in `deploy/world/`.++## Tasks++1. **Fix the masking in `checkWorld()`** (`api/_lib/ops/subsystem-health.js:332`). When the Redis-backed cache entry is missing or stale (the existing `!parked`/`age > WORLD_STALE_MS` branches), fall back to the durable signal that already exists instead of reporting `unknown`: query `ops_alerts` for the most recent row whose `signature` matches the world-health cron's own alert signatures (`world-health:status-http`, `world-health:status-unreachable`, or derive them the same way `signatureOf()` in `api/_lib/alerts.js` does, since the cron passes a raw `signature` string in `opts.signature` which bypasses the hash (read `sendOpsAlert` closely: when `opts.signature` is set, `sig = signatureOf(opts.signature)`, so the hash of the literal string `'world-health:status-http'` is the stored value; compute it once and compare)). If that row's `last_seen` is recent (within, say, `2 * 15 minutes` plus slack, matching the cron cadence), report `status: 'down'` with the alert's own `detail` text instead of `unknown`. If no such row exists or it is stale too, `unknown` remains correct (the cron genuinely has not reported anything recently, which is the one case this status is honest). Add the DB query using the same `sql` import `api/_lib/alerts.js` already uses (`import { sql } from '../db.js'` or whatever that file's exact import is; read it first), wrapped in the same fail-soft pattern every other subsystem checker in this file uses (a DB read failure must degrade to the existing cache-only behavior, never throw and take down `/healthz` itself).+2. **Add a regression test** beside the existing subsystem-health tests (grep `tests/` for `subsystem-health` or `healthz` to find the right file and existing mocking pattern for `cacheGet`/DB calls) that: (a) reproduces today's bug, mocking `cacheGet` to return null and asserting the OLD code would say `unknown` even when a fresh `ops_alerts` row says otherwise, then (b) asserts the fixed `checkWorld()` returns `down` in that scenario, and (c) asserts it still returns `unknown` when neither source has anything recent. Confirm the test fails against the pre-fix code for the stated reason before applying the fix (bug-fixes-test-first).+3. **Correct the stale "Live" claims.** `STRUCTURE.md:277` currently reads `Live · hyperfy-world on Cloud Run`. Rewrite that cell to state the measured reality with the date: the Cloud Run service was deleted 2026-10-23 (owner action, confirmed via Cloud Run audit log), `world.three.ws` currently 404s, and the health monitor/cron remain in place for if/when it is redeployed. Do the same for `deploy/world/README.md`'s opening paragraph (currently states it "runs as its own Cloud Run service" in the present tense) and anywhere else `grep -rln "hyperfy-world\|world.three.ws" docs/ STRUCTURE.md deploy/world/` turns up a present-tense "it is live" claim that is now false. Do not delete the deploy config or the runbook; a future redeploy still needs them, and that decision belongs to the owner.+4. **Re-run the step 0 cron probe** after your fix ships to confirm `checkWorld()`'s new DB fallback actually reflects the live `ops_alerts` row (you cannot force `/healthz` on production to pick up a local code change, so verify this with a local/unit-level call: import `subsystem-health.js`'s `checkWorld` directly, or whatever export the file provides, in a one-off `node -e` script against the same `DATABASE_URL`, and confirm it returns `down` right now given the 222-count row measured above).++## Definition of done++- [ ] `checkWorld()` in `api/_lib/ops/subsystem-health.js` falls back to a durable `ops_alerts` read when the Redis-backed cache is empty/stale, and the new test (added in the same commit) proves it: fails before the fix, passes after.+- [ ] `npm run test:core` (or at minimum the new/touched test file via `npx vitest run <file>`) passes; no change to any other file's test outcomes.+- [ ] `STRUCTURE.md` row 277 (world/Hyperfy) and `deploy/world/README.md`'s opening description no longer claim the service is "Live" in the present tense; both state the dated, measured reality and cite this order's number.+- [ ] `grep -rn "hyperfy-world" STRUCTURE.md deploy/world/README.md` shows no remaining unconditional "Live"/"runs as" present-tense claim.+- [ ] `npm run check:rules -- --paths <files you touched>` exits 0.+- [ ] No change to any Cloud Run service, Cloud Scheduler job, or domain mapping. `gcloud run services list` / `gcloud beta run domain-mappings list` output is identical before and after (confirm with a before/after diff in the report).+- [ ] One commit for the code+test fix, one commit for the docs fix (or combined if the diff is small and one message honestly describes both).++## Never blocked++| Blocker | Resolution (act, do not ask) |+|---|---|+| `DATABASE_URL` does not resolve | Read it the same way `scripts/apply-migrations.mjs` does: `.env.local` then `.env` then `process.env`. It resolved in this session's measurement above; if it genuinely does not resolve for you, say so as a one-line finding, do not block the docs/cache-fallback-logic work on it (the test can mock the DB call instead of hitting it live). |+| The scheduler job's bearer secret is not visible to you | `gcloud scheduler jobs describe cron--api-cron-world-health --project=aerial-vehicle-466722-p5 --location=us-central1 --format=json` prints it in `httpTarget.headers.Authorization`; if your `gcloud` auth lacks permission, skip the live cron probe and trust the `ops_alerts` count (222) and the `/healthz` response alone, both already measured above. |+| You are tempted to "just redeploy the world since the code is all there" | Do not. The owner deleted the service two days ago after three months of this exact alert; that is a decision, not an accident left for this order to correct. Stay scoped to monitoring/docs truth. |+| `ops_alerts` has no recent `world`-signed row by the time you run this (the owner redeployed, or the signal rotated out) | Good, re-measure `/healthz` fresh; if `world` now reports `ok`/`down` correctly without your fix, the masking bug may still exist for the next multi-day gap, so ship the fallback logic anyway (it is correct regardless of today's exact state) and say in the report that the live symptom had already cleared by the time you checked. |+| The exact signature string the cron passes does not hash to what you expect | Read `api/cron/world-health.js`'s three `sendOpsAlert(...)` call sites for the literal `signature:` values it passes, and `signatureOf()` in `api/_lib/alerts.js` for how they are hashed; compute, do not guess. |++## Close out (required)++1. Verify every Definition of done line with the command output in front of you. Never claim a line you did not verify.+2. Commit with explicit paths, each subject describing that diff (e.g. `fix(ops): stop /healthz masking a 3-month world.three.ws outage as unknown`).+3. If every line passes, delete this file in the final commit (`git rm prompts/finish/453-auto-world-health-masked-down-state.md`) and append a dated entry to `prompts/finish/_context/production-100-PROGRESS.md` with the commit SHAs.+4. Final report, in this order: the three step-0 measurements reproduced with their output; the fix and its test (fail-before, pass-after); the docs diff; confirmation that no GCP infra changed; one-line judgment calls. No trailing questions.diff --git a/prompts/finish/454-auto-root-cve-triage-and-stale-solana-pay-pin.md b/prompts/finish/454-auto-root-cve-triage-and-stale-solana-pay-pin.mdnew file mode 100644index 000000000..c32b016cd--- /dev/null+++ b/prompts/finish/454-auto-root-cve-triage-and-stale-solana-pay-pin.md@@ -0,0 +1,62 @@+# 454. Three unaddressed high-severity CVEs in root `node_modules`, plus a root `@solana/pay` pin two major versions behind the repo's own workspaces++How to run: paste this file's repo path into a fresh Claude Code chat in this repository and say "run this work order". Runnable now, no gate, no owner action required.++## Operating clause (binding)++- Read CLAUDE.md first. CLAUDE.md overrides everything, including this file.+- Finish 100% in this session. Never end the turn with a question, an option list, or an unexecuted plan. A judgment call goes in one line of the final report; it never becomes a question that halts work.+- The only permitted stops are the CLAUDE.md stop-and-ask gates (spend/on-chain, push/deploy/publish, non-$THREE crypto commit content, destroying unrecoverable data). This order touches none of them: it edits `package.json`/lockfile-generating commands and runs `npm install` locally.+- The em-dash and en-dash characters are banned in everything you write.+- Concurrent agents share this worktree: stage explicit paths only (never `git add -A` or `git add .`), re-check `git status` and `git diff --staged` before each commit.+- Before committing, run `npm run check:rules -- --paths <files you touched>`. It must exit 0.+- Do not confuse this order with 444/449/450: those three already cover CVEs in VENDORED WORKER dependencies (`workers/rembg`, `workers/modly-host`, etc., which are byte-identical copies per `npm run check:vendored` and must not drift from their sibling fixes). This order is scoped to the ROOT `node_modules` tree only (the one `npm audit` at the repo root reports). Re-check `prompts/finish/` for a number higher than 454 before you start, in case a concurrent agent already filed something that overlaps; if one exists, narrow or drop the overlapping task and say so in the report.++## Why this matters (measured 2026-10-25)++`npm audit --json` at the repo root reports three high-severity advisories with no listed `fixAvailable`, confirmed independently via `npm ls <pkg>` (dependency chain) and `npm view <pkg> versions` (whether any patched version is actually reachable):++1. **`bigint-buffer` buffer overflow, GHSA-3gc7-fjrx-p6mg, CVSS 7.5.** `npm ls bigint-buffer` shows it is pulled in transitively through `@solana/buffer-layout-utils`, itself required by `@solana/spl-token` and `@solana/spl-stake-pool`, both real root dependencies used by Kamino-related code (`@kamino-finance/*` packages import `@solana/spl-token`). The advisory's vulnerable function (`toBigIntLE`/`toBufferLE` on attacker-controlled-length input) has no patched release: `npm view bigint-buffer versions` lists only `1.1.5` (current) with no later tag, and the GHSA advisory itself states there is no fix, recommending migration to `beB.js` style replacements or a length check at the call site. No forward `npm install bigint-buffer@latest` exists to resolve this.+2. **`lodash.set` prototype pollution, GHSA-p6mc-m468-83gw, CVSS 7.4.** `npm ls lodash.set` traces to `@bnb-chain/[email protected]`, already the latest published version (`npm view @bnb-chain/greenfield-js-sdk versions` confirms `2.2.2` is the tip), which pins `lodash.set@^4.3.2`, the only version ever published and the one the advisory covers unconditionally (the package was never patched; its README now recommends `lodash/set` with a destination-key allowlist instead). No forward dependency bump exists.+3. **`node-forge` RSA PKCS#1 v1.5 signature verification flaw, GHSA-86w9-cpqp-85rv, CVSS 7.5.** `npm ls node-forge` traces through `[email protected] → helia → @ipshipyard/libp2p-auto-tls → acme-client → node-forge`. `agent0-sdk` is already at its latest published version. The advisory range covers `node-forge`'s own current latest release (`npm view node-forge versions` tip matches the vulnerable range in the GHSA advisory), i.e. the upstream package itself has not shipped a fix as of this measurement.++Separately, `grep -n '"@solana/pay"' package.json multiplayer/package.json character-studio/package.json` shows the root pin is `"@solana/pay": "^0.2.6"` while two in-repo workspace packages (`multiplayer/package.json:25`, `character-studio/package.json:29`) already run `"@solana/pay": "1.0.16"`, and `npm view @solana/pay versions` shows the registry's latest is `1.0.26`. The root package is not a leftover: `grep -rln "@solana/pay" api/ src/ scripts/` finds real, reachable, money-adjacent call sites (`api/marketplace/buy-asset.js`, `api/purchase/skill.js`, `api/print/orders/[id]/confirm.js`, `api/_lib/subscription-checkout.js`, `api/_lib/purchase-confirm.js`, `api/_lib/circulation.js`, `api/_lib/solana/gasless-tx.js`, `src/marketplace.js`), meaning the root tree is running a transaction-request-building library two major versions behind the version already proven to work elsewhere in this same repo.++## Tasks++1. **Confirm reachability before choosing a mitigation for each CVE.** For each of the three packages, grep the actual call sites that reach the vulnerable function (not just `npm ls`'s existence in the tree):+ - `bigint-buffer`: is `toBigIntLE`/`toBufferLE` reachable with attacker-influenced buffer length anywhere in this repo's own code (not just inside the `@solana/spl-token` library internals, which three.ws does not control)? Check how `api/`/`src/` call into `@solana/spl-token`/`@solana/spl-stake-pool`/`@kamino-finance/*` and whether any of those call paths pass user-controlled byte lengths.+ - `lodash.set`: is `@bnb-chain/greenfield-js-sdk` actually invoked anywhere reachable from user input (`grep -rln "greenfield" api/ src/ scripts/`), or is it dead/unused in the root tree?+ - `node-forge`: is the `agent0-sdk → helia → libp2p-auto-tls → acme-client` chain's ACME/auto-TLS feature actually exercised by three.ws (grep for `agent0-sdk` usage and whether any code path triggers libp2p's auto-TLS certificate ordering), or is it an unused transitive feature of a p2p SDK that three.ws imports for other reasons?+2. **Apply the correct mitigation per package, based on step 1's answer:**+ - If a package's vulnerable path is unreachable from this repo's own code (the common case for transitive-only inclusions), add a `package.json` `overrides` entry is NOT appropriate here since no patched version exists to override to; instead add a documented risk acceptance: a short, dated note in `docs/ops/security-exceptions.md` (create it if it does not exist, following the doc-is-wired convention: link it from `STRUCTURE.md` or `docs/README.md` if either indexes ops docs) naming the GHSA ID, the unpatched package, the dependency chain, why the path is unreachable (cite the grep), and the date measured. This gives `npm audit` reviewers a durable, citable answer instead of a silently ignored warning every time they re-run the audit.+ - If step 1 finds a genuinely reachable path for any of the three, do not just document it: implement the mitigation that closes the path (an input length/type check before the vulnerable call, replacing the unpatched library call with a safe equivalent, or removing the unused feature import if the whole chain is dead weight the repo does not need, e.g. if ACME auto-TLS is never used, check whether `agent0-sdk`/`helia` can be imported without pulling in the auto-TLS submodule, or whether a newer/alternate helia transport avoids `node-forge` entirely).+3. **Bump the stale root `@solana/pay` pin.** Change `package.json`'s `"@solana/pay": "^0.2.6"` to match the version already proven to work in this repo's own workspaces (`1.0.16`, or the registry latest `1.0.26` if you confirm no breaking change affects the real call sites listed above). Read `@solana/pay`'s changelog/release notes between `0.2.6` and the target version for breaking API changes (the `0.x -> 1.x` jump is a major version bump and likely changed function signatures, e.g. `createQR`, `encodeURL`, `findReference`, `validateTransfer`). Update every root call site (`api/marketplace/buy-asset.js`, `api/purchase/skill.js`, `api/print/orders/[id]/confirm.js`, `api/_lib/subscription-checkout.js`, `api/_lib/purchase-confirm.js`, `api/_lib/circulation.js`, `api/_lib/solana/gasless-tx.js`, `src/marketplace.js`, `scripts/audit-deploy-artifacts.mjs`, `scripts/build-pay-skills.mjs`) for any signature change the release notes call out, matching the usage pattern already present in `multiplayer/` or `character-studio/` wherever they call the same functions.+4. **Verify nothing broke.** Run `npm install` at the root (confirm it completes without new high/critical advisories introduced), then `npm run test:core` (or the narrower test files covering marketplace/purchase/subscription checkout, grep `tests/` for the covered modules), and `npm audit --json` again to confirm the three named advisories are either resolved or explicitly documented as accepted risk (not silently present with no record).++## Definition of done++- [ ] `npm audit --json` at the root, re-run after this order's changes, shows each of the three named GHSA IDs (`GHSA-3gc7-fjrx-p6mg`, `GHSA-p6mc-m468-83gw`, `GHSA-86w9-cpqp-85rv`) either absent (because the unreachable dependency was removed/replaced) or present with a corresponding dated entry in `docs/ops/security-exceptions.md` citing the reachability analysis.+- [ ] `docs/ops/security-exceptions.md` (or the file you chose) is linked from an existing docs index (`STRUCTURE.md` or `docs/README.md`), per CLAUDE.md's "new developer-facing capabilities update docs/" rule.+- [ ] Root `package.json`'s `@solana/pay` pin matches the version used in `multiplayer/package.json` and `character-studio/package.json` (or a newer one you verified compatible), and every root call site listed above still builds/tests green against the new version.+- [ ] `npm run test:core` passes (or the specific marketplace/purchase/checkout test files you touched/verified, named explicitly in the report, with a one-line reason if the full suite was impractical to run).+- [ ] `npm run check:rules -- --paths <files you touched>` exits 0.+- [ ] `npm run check:vendored` still passes (confirms this order did not accidentally touch anything under `workers/` that 444/449/450 own).+- [ ] Commits use explicit paths; one commit per topic (CVE exceptions/fixes as one topic, `@solana/pay` bump as a separate topic, unless the diff is small enough that one honest combined message covers both).++## Never blocked++| Blocker | Resolution (act, do not ask) |+|---|---|+| `npm audit` output differs from what's measured above (advisories patched upstream since 2026-10-25, or new ones appeared) | Re-measure fresh with `npm audit --json`, trust what you see now over this file's text, and adjust scope accordingly; note the drift in one line of the report. |+| A reachable path is found for one of the three CVEs and the real fix requires removing a feature (e.g. dropping ACME auto-TLS support from the libp2p stack) | Do it if the feature is confirmed unused in production (grep call sites, check for any env var gating it); if it IS used, implement the narrower mitigation (input validation at the call boundary) rather than removing a live feature, and say so in the report. |+| `@solana/pay` 1.0.16 -> 1.0.26 (registry latest) has a breaking change affecting a root call site you cannot immediately fix cleanly | Pin to `1.0.16` instead (the version already proven working in this repo's own `multiplayer/`/`character-studio/` workspaces) rather than blocking on the newest version; note the deferred further bump as a one-line follow-up, not a question. |+| `docs/ops/security-exceptions.md` doesn't fit this repo's existing docs conventions | Check `docs/ops/` for an existing file that already tracks accepted risks or known issues (e.g. anything referencing prior CVE decisions) and append to that instead of creating a new one; only create new if nothing fits. |+| `npm install` after the pin bump changes unrelated transitive versions across the whole lockfile | That's expected lockfile churn from a real version bump; commit the full lockfile diff, don't hand-edit it, and confirm `npm run test:core` still passes despite the churn. |++## Close out (required)++1. Verify every Definition of done line with the command output in front of you. Never claim a line you did not verify.+2. Commit with explicit paths, each subject describing that diff (e.g. `fix(deps): document unreachable bigint-buffer/lodash.set/node-forge CVEs, bump root @solana/pay to 1.0.16`).+3. If every line passes, delete this file in the final commit (`git rm prompts/finish/454-auto-root-cve-triage-and-stale-solana-pay-pin.md`) and append a dated entry to `prompts/finish/_context/production-100-PROGRESS.md` with the commit SHAs.+4. Final report, in this order: the reachability finding for each of the three CVEs and the mitigation chosen; the `@solana/pay` bump and call-site verification; test results; one-line judgment calls. No trailing questions.