Ships

Lambdas off the EC2 — serverless base = AWS account (not EC2), no container box for managed resources, each Lambda/compute gets its own raised plane

De-clutter grants (drop bold roads → quiet lines + guarded-vault checkpoint) + MMO/AI-training/AI-RAG gallery examples

Atlas docs: grant-roads + checkpoints, EC2/ECS/Fargate compute, containment model

Grant roads + police checkpoints (DUI barricade + flashing cruiser to vaults) + EC2/ECS/Fargate compute

Atlas docs: record CDK importer, AWS city vocabulary, telemetry opt-in-overlay decision

CDK-as-TypeScript importer — Lambdas as tents, IAM grants as roads (AWS-native extraction + city vocabulary)

Verify fixed deploy pipeline (LF scripts + synchronous build)

Force LF on shell scripts via .gitattributes — Windows CRLF broke deploy-ec2.sh on Linux EC2 (silent deploy failures)

Fix deploy.sh: synchronous EC2 build (detached nohup trigger silently failed to run the build)

Atlas CITY-1g + README lab-suite update

Docs: bring README lab-suite update from PR #3 onto main (Atlas CITY-1g preserved)

Atlas CITY-1g: externals as clouds (outbound, over consumers); webhooks as helicopters; clouds pickable

Atlas CITY-1f: helipads (air network) — buildings that call out get a fenced pad; helicopters on islands

Atlas CITY-1e: remove fake harbor; external islands sized by dependency count, routes on focus

Atlas CITY-1d: table road grid + orphan-table sorting (unused tables off to the side)

Atlas CITY-1c: buildings = modules (endpoints=doors, handlers=machines, actions=people); off-grid inside container; uniform roads

Atlas CITY-1b: street grid between blocks + off-grid module sorting (stateless districts detached)

Atlas CITY-1a: quiet edges + data avenue + coastline (mainland + offshore island externals)

Atlas CITY-0: generic model + example-architecture gallery (serverless/3-tier/event-driven)

Atlas CITY-0: generic city-role model + doc plan

Atlas UI: scale fog + clip planes to scene so buildings stay visible when zoomed out

Atlas UI: infra nesting (EC2 host + containers, tables grouped in mysql)

Infrastructure layer — EC2 host + containers from docker-compose

Docs: Atlas Phase 4 (talk to your architecture) shipped — end goal met

Atlas Phase 4: talk to your architecture (GraphRAG /api/v1/atlas/ask + chat panel)

Atlas Phase 3: self-updating architecture doc at /atlas/architecture

Atlas Phase 3: living architecture doc generator (graph → Markdown)

Docs: Atlas Phase 2b (handler nodes + LLM tier) shipped

Atlas Phase 2b: handler nodes + LLM-inferred edges on the 3D map

Atlas Phase 2b: handler nodes + Tier-2 LLM edge extraction (grounded, provenance-tagged)

Docs: Atlas Phase 2 external-services slice shipped

Atlas Phase 2: external services on the 3D map (arteries out of the system)

Atlas Phase 2: external-service extraction from adapters (Stripe/Polly/Grok/Anthropic/AWS/…)

Docs: mark Atlas Phase 1 (3D map at /atlas) done

Atlas Phase 1: 3D architecture map at /atlas (nested districts, data-flow highlight)

Nested-district layout unit test

Atlas Phase 0: deterministic graph substrate (endpoints/actions/datastores + provenance)

Add Atlas app card + about page to landing

Deploy.sh: auto-refresh /landing code-activity graph on web deploys

Refresh code-activity graph through 2026-07-07 (r72-r82 session work)

R82: EVEN OUT THE SEA FLOOR — runtime-detach the ~2349 deep 5x5x11 heightfield boxes (the uneven ocean floor, confirmed as the deepest meshes via the depth query). Sub reads seabedDepth() field not these visual boxes, so safe. Biggest single object-count cut. Reversible via EVEN_SEA_FLOOR flag

R82: even out the sea floor (detach ~2349 floor boxes) — biggest object-count cut

R81: DEEPEST-mesh diagnostic (user's 'closest to sphere centre = ocean floor' insight) — log the lowest-Y meshes + identity + parent to finally ID the sea-floor system

R81: deepest-mesh diagnostic (find the ocean floor by depth)

R80: pinpoint 5x5x11 box source

R80: pinpoint the 5x5x11 box (2349x) — log a sample's parent chain + world pos to name its creation site for instancing

R79: geometry-frequency diagnostic (find top instancing target)

R79: GEOFREQ diagnostic — count meshes by geometry signature (type + dims) to find the most-repeated shape = the highest-ROI InstancedMesh target (Win 2, step 1a)

R78: composition diagnostic — add group world-position + first-child box dims to the name hint, to locate/identify the ~10 uniform ~270-object box-pools (enemy hulls are only 2 boxes, so these aren't ships)

R78: locate the anonymous box-pool groups

R77: parked planes merged to 1 mesh each — cut the carrier object count (measure objs drop)

R77: parked planes → ONE merged vertex-coloured mesh each (was ~15 box parts). makeParkedPlane now wraps _buildParkedPlaneParts + _mergeGroupToMesh. Cuts ~14 objs/plane × ~20-26 always-in-scene planes = the bulk of the 897-object carrier. All _park usages are opaque Object3D ops so a Mesh drops in cleanly. Fallback to raw group if merge fails

R76: name scene-composition groups

R76: name the anonymous scene groups in the composition diagnostic (walk to first named descendant / geometry type) — identify what the ~6400-object diffuse bulk actually is

R75: scene-composition diagnostic

R75: scene-composition diagnostic — log total scene objects + top-level groups by descendant count, to find the REAL object-count driver (buildings were only 472/11000)

R74: city-merge diagnostic logging

R74: add MERGE diagnostic — log mergedCities/hiddenBuildings so we can see whether the city merge is actually running (r73 telemetry showed no draw/obj drop)

R73: Carrier00 client-side city merge (buildings → 1 mesh/city) — cut draws + object count + bend CPU. Measure impact

R73: CITY MERGE (client-side) — bake each city's static building bodies + roof caps into ONE vertex-coloured mesh via existing _mergeBaked (per-city, sphere-safe convention). Auto-excludes dynamic objects (roof heli, hangar planes, NPC crew, lights = separate objects). Throttled re-merge on build/raze. Cuts draw calls + object count + per-frame sphere-bend CPU. v1: no night-dim on merged cities. Toggle CITY_MERGE

R72: remove building burning effects (fire/smoke/scorch/ember) game-wide — buildings now static/mergeable. Step 1 before city merge

R72: remove all building BURNING effects (updateBuildingFx fire/smoke/ember neutered; scorch color removed from damage + heal). Damage is HP-only now; buildings stay their base colour → visually static → mergeable. Step 1 of city-merge

R71: live CPU/GPU split in the debug HUD (host loop CPU time vs GPU~) — diagnoses fill-bound vs sim-bound directly

R71: CPU/GPU readout in the debug HUD. main.js brackets its animation loop → window.__c00cpuMs (EMA JS frame time). Engine HUD shows 'CPU Xms · GPU~ Yms CPU-BOUND/GPU-BOUND' (GPU ≈ frame − CPU, valid below the 72Hz cap) + logs cpu/gpu to telemetry. Settles fill-vs-sim without guessing

R70: revert r69 world culling (net-negative — no perf gain, hid visible buildings; FPS is fill/CPU-bound not draw-bound)

R70: REVERT world culling (r69) — data proved it did nothing for perf (city stayed 1656 draws, objs/fps unchanged) while hiding faintly-visible fogged buildings. FPS is fill/CPU-bound (8fps at 240 draws), not draw-bound — draw culling was the wrong lever

R69: Carrier00 world culling (horizon + fog-distance) — collapse draw calls toward dense cities that are below the horizon/beyond fog

R69: WORLD CULLING phase 1 — cullIslands() hides city buildings that are geometrically invisible: below the planet horizon (deck/air/orbit — central angle vs viewer+object horizon half-angles) or beyond fog.far. three.js only frustum-culls (still draws everything in the view cone behind the horizon/fog). Targets the '1600 draws toward the city, ~150 visible' gap. Per-island, ~10Hz, state-change only

R68: mirror perf — throttle Reflector to every 3rd frame + 512² (was 768²). It does a full 2nd scene render; in Carrier00 that craters framerate (judder/tears). Shared engine, harmless to Chat

R67: fix Carrier00 geometry leak (missile flame geo cached, was per-shot + never disposed). Affects browser + VR both

R67: FIX geometry leak — missile flame built a NEW ConeGeometry per shot (weapons.js:92) and cleanup (line ~302) only scene.remove'd it, never disposing → geometries leaked ~200/min under AI missile fire. Now a single cached _mslFlameGeo shared by all missiles (nuke pattern). Confirmed via telemetry: geometries climbed while objs stayed flat = churn without disposal

R66: perf telemetry into shared engine (both apps, host-tagged) + gate ALL debug tracking/logging behind debug HUD visible ('Computer, debug off/on' toggle). Same debugger code in /chat + Carrier00

R66: perf telemetry moved into the shared engine (one impl for /chat + Carrier00, host-tagged); removed Carrier00's duplicate host-side sampler. All debug tracking now gated behind the debug HUD being shown

R65: (1) FIX worn avatar — Carrier00 never called engine.setUserAvatar, so the player had no body; now loads /models/aruishi.vrm (or localStorage cl_user_avatar) first-person. (2) PERF telemetry — every 2s in VR, POST FPS/ms/draws/tris/objects + head yaw to server log to correlate framerate with view direction

R65: fix worn user avatar in Carrier00 (setUserAvatar was never called) + VR perf telemetry (FPS/draws/tris/objects/yaw → server log) + engine getPerfSample()

R64: add live perf metrics to the VR debug HUD (FPS · ms/frame · draw calls · triangles) in the engine — flows to BOTH Chat and Carrier00. renderer.info reflects the host's whole scene in Carrier00. This is the 'measure first' tool for VR framerate debugging

R63: revert Carrier00 MSAA-off — broke the in-XR mirror; foveation (r61) keeps the fill win

R62: Carrier00 MSAA off (antialias:false) for VR fill — pairs with foveation. Chat renderer unchanged (keeps MSAA; has headroom)

VR perf: drop MSAA (antialias:false) on the main renderer — heavy VR fill cost on ocean/sky, can't be toggled per-session (context attr), so dropped globally. Pairs with foveation (r61). Tradeoff: desktop edges jag

R61: enable fixed foveated rendering on XR session start (VrmEngine.onXRStart) — big Quest fill-rate win, flows to BOTH Chat VR and Carrier00 (configures the whole XR render via the adopted renderer). XR-only; no effect on flat clients

Fix code-activity graph windowing at 1m/1w — bucketize now drops buckets before the window start (the code JSON isn't pre-windowed like the traffic API, so it was drawing full history back to March)

Landing code-activity: add AI-era band (backfill = one Opus 4.8 era; auto-appends a new segment when CURRENT_MODEL changes in gen-code-activity.mjs). + ai-eras.json

Add 2nd 'Code Activity' graph under Site Activity — git churn (lines added/removed) across CommsLink2 + Carrier00, backfilled from full history, filtered to hand-written source (excludes bundles/locks). Shares the same time-frame buttons. + gen-code-activity.mjs + code-activity.json

Carrier00 r60: add missing bug_open/progress/statement + voice_cmd_open listeners to the bridge — bug report now records into the (real) debug HUD

Carrier00 r59: mount chat's COMPLETE avatar integration (movement director, poses, animations, lip-sync, chat, voice commands, Q&A) via one shared bridge module

R59 WHOLESALE integration port: extract chat's COMPLETE client wiring (the 40-case movement director + every avatar socket handler + Q&A + lip-sync) into ONE shared module (avatarSocketBridge → avatarbridge.mjs). chat.js mounts wireAvatarSocket(socket, getEngine) — the whole feature set wired at once, not per-host. Removed Carrier00's overlapping hand-wired handlers. This is 'run chat's integration', not fix-one-function-a-day. (AvatarPanel still has its inline copy — delegating it to the shared module is the paired de-dup.)

R58 UNIFY the env — no more fork: engine.setEnv(env) hands Carrier00's env (chat's environment.ts, fed our planes) to the engine so its execVoiceCommand runs Computer env-commands on THAT one env. Relaxed the AR-only guard (!this.env||!liveAlign → !this.env; equivalent in /chat). onVoiceText routes ALL commands to the engine's handleVoiceLine now — env, exit, Q&A, reports all chat's code, one env

Carrier00 r58: unify env — engine commands run on Carrier00's env via setEnv; all voice commands through the engine. No fork

Carrier00 r57: add missing voice_cmd listener — the server-side Computer commands finally reach the client

R57 THE FIX: add the voice_cmd listener chat.js was missing. On Quest, voice is server-side; the server detects 'Computer' + emits voice_cmd with the command — Carrier00 never listened, so every Computer command was dropped. Now routes voice_cmd → onVoiceText → env/exit/Q&A. This is why nothing worked regardless of client changes

Carrier00 r56: fix voice commands — env commands no longer eaten by the engine's gated handler; route them to Carrier00's env, rest to the engine

R56 FIX the voice-command break I caused: my routing sent env commands to engine.handleVoiceLine, which EATS them (env gated in host mode → 'works in AR only' → returns true → never falls through). Now env commands ('make X visible') → Carrier00's working env handler; only exit/Q&A/bug/feature/chime → the engine

Use the EXISTING build number: revert my duplicate C00_BUILD slop; bump the engine's GHOST_BUILD r54→r55 and surface it in Carrier00's mount log + VR button. No new constant — the build number that was always in the engine

Carrier00: surface the engine's existing GHOST_BUILD (r55) in the mount log/VR button; remove my duplicate build constant

BUILD B49: add visible build number — big in the re-enabled in-VR debug HUD + on the VR button. Confirms the headset is on the latest build (not a cached one). Bump C00_BUILD every deploy

Carrier00 BUILD B49: visible build number in the in-VR debug HUD + VR button (stale-cache check)

Fix STT regression: setPhysicalHandler was forwarding EVERY engine physical event (proximity/grab per frame) to the socket, flooding it and starving the voice STT stream → no transcripts. Filter to only the low-frequency command/report events (bug/cmd_arm/report/dismiss/env_state)

Filter setPhysicalHandler to low-freq events only — fixes voice STT starved by the physical-event flood

Route voice to chat's handleVoiceLine (Computer chime + Q&A + bug/feature reports + exit) via the mounted engine; wire setPhysicalHandler to the socket

Route voice to chat's REAL command handler: transcripts → engine.handleVoiceLine (Computer wake word + chime + Q&A + bug/feature reports), engine.setPhysicalHandler → chat socket (bug_arm/bug_report/cmd_arm reach server). 'Computer exit' now hits the engine's exit command. Env commands fall back to Carrier00 onVoice until the engine's env is un-gated. NOT a rebuild — chat's code