diff --git a/.forgeplan/adrs/ADR-011-ship-three-js-threlte-as-a-lazy-client-chunk-for-the-map-view-3d-minimap-raise-per-image-dist-cap-3-mib-to-3-5-mib.md b/.forgeplan/adrs/ADR-011-ship-three-js-threlte-as-a-lazy-client-chunk-for-the-map-view-3d-minimap-raise-per-image-dist-cap-3-mib-to-3-5-mib.md
new file mode 100644
index 0000000..272ff26
--- /dev/null
+++ b/.forgeplan/adrs/ADR-011-ship-three-js-threlte-as-a-lazy-client-chunk-for-the-map-view-3d-minimap-raise-per-image-dist-cap-3-mib-to-3-5-mib.md
@@ -0,0 +1,214 @@
+---
+depth: standard
+id: ADR-011
+kind: adr
+last_modified_at: 2026-07-08T01:40:00.424794+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: PRD-030
+  relation: informs
+- target: PRD-039
+  relation: informs
+- target: PRD-036
+  relation: based_on
+status: active
+title: Ship three.js + Threlte as a lazy client chunk for the Map-view 3D minimap; raise per-image dist cap 3 MiB to 3.5 MiB
+---
+
+# ADR-011: Ship three.js + Threlte as a lazy client chunk for the Map-view 3D minimap; raise per-image dist cap 3 MiB → 3.5 MiB
+
+| Field | Value |
+|---|---|
+| Status | Draft |
+| Date | 2026-07-08 |
+| Depth | Deep |
+| Decision drivers | client runtime-dependency footprint, packaging size cap, on-demand load, reversibility, governance precedent |
+| Decision-makers | autonomous orchestrator + named user (explosivebit) — user explicitly chose "raise the cap to 3.5M" |
+| Supersedes | None |
+| Superseded-by | (open) |
+
+## Context
+
+The composed-map arc (EPIC-001 T4 → PRD-036 render-proof → PRD-037/RFC-031 drill-down → PRD-038 onboarding) has landed a flat 2D "map" view. **PRD-039** adds a 3D isometric "exploded-pyramid" layered overview in that view's bottom-right corner (replacing the flat 2D navigation minimap **on the Map view only**), so a newcomer can see the whole stack of altitudes at once and jump between them. PRD-039 states the 3D-rendering capability in rule-11-compliant language (no library named in its FRs) and **explicitly defers the packaging-cost decision to a companion ADR** — this ADR is that companion. PRD-039 §Open-Questions Q1 and conflict C-1 name the exact tension: an added 3D render chunk raises packaged image size and presses against PRD-030's per-image dist-size cap.
+
+Rendering a true-3D isometric stack requires a WebGL runtime; the arc chose **three.js + @threlte/\*** (proven earlier this session by the `/iso-spike`). Bundle work performed this session to make that affordable, measured verbatim: unused `@threlte/extras` draco/basis model-loaders (~1.5 MiB) were **stubbed out via a vite alias**; `three` was kept **out of the SSR server bundle** (`ssr=false` + browser-guarded dynamic import → **0 `three` markers in `dist/index.js`**); `three` + Threlte are a **separate lazy client chunk (~808 KiB)** fetched only when the Map view opens. Result: `dist/` went **6.0 MiB → ~3.4 MiB**. The remaining **~808 KiB is `three` itself — irreducible** for the 3D feature; it is already code-split and lazy, but because `init` is a `cp -r` of `dist/`, the whole chunk ships on disk in every image and therefore counts against the per-image cap **regardless of runtime laziness**.
+
+The decision being recorded here is already applied in code: commit **`a6ef030`** ("build(idef0): raise dist cap 3M -> 3.5M for lazy 3D Map minimap") set `IMAGE_DIST_MAX_BYTES = 3.5 * 1024 * 1024` in `scripts/build.mjs`, carrying an explicit `// TODO(iso-adr): record the deliberate bump in an ADR ... before this ships`. This ADR is the record that code comment asked for. Note the drift the ADR must formalize: **PRD-030 NFR-001 / SC-4 and rule 21 still read "≤ 3 MB"**, and the `a6ef030` code comment mis-cites the governing NFR as "NFR-005" (the flag-lifecycle NFR) when the correct citation is **NFR-001 / SC-4 / rule 21** (the size NFR). Prior art strengthens the reversibility story: an earlier "Force 3D — experimental Threlte view mode" (#103/#104, which bumped the experimental cap to 6M) was **reverted** (`7f907dd` / `dffbe25` reverted); the present approach is deliberately narrower — a lazy corner minimap at 3.5 MiB, not a full view mode at 6 MiB.
+
+**ADI note (HARD RULE 2).** `forgeplan_reason PRD-039` was invoked and returned *"LLM provider unavailable or not configured"* — the same workspace-MCP reasoning gap PRD-037/038/039 recorded. The Abduction → Deduction → Induction cycle was therefore run **manually** over the three genuinely contested options and is folded into the Considered-options / Decision-outcome sections below.
+
+## Decision drivers
+
+- **DD-1 (EMPIRICAL CONSTRAINT)**: `three` is ~808 KiB and irreducible for a real 3D isometric render; after stubbing draco/basis (~1.5 MiB) and excluding `three` from SSR, `dist/` still lands at ~3.4 MiB — over the old 3 MiB cap. Source: this session's measured bundle work.
+- **DD-2 (PACKAGING CONSTRAINT)**: every published image ships all chunks on disk (`init` = `cp -r dist/`), so a *lazy* chunk still counts against the per-image cap. Source: PRD-030 NFR-001/SC-4, rule 21, ADR-005 (image = build artifact, not runtime config).
+- **DD-3 (COLD-START / UX)**: the 3D cost must not tax any non-Map view's load (PRD-039 FR-005 / NFR-002). Source: PRD-039.
+- **DD-4 (READ-ONLY / NO NEW SURFACE)**: the minimap is a pure client render of the existing read-only `/api/map` (SPEC-006) data — no new endpoint, no spawn, no network egress. Source: PRD-039 NFR-006, rule 22.
+- **DD-5 (REVERSIBILITY / GOVERNANCE PRECEDENT)**: adopting a client runtime dep AND moving a size-discipline governance constant both set precedent; the choice must be cheap to back out. Source: the prior Force-3D revert (`7f907dd`).
+
+## Considered options
+
+### Option 1 — Ship three.js + @threlte/\* as a lazy client chunk in the default image, and raise the per-image dist cap 3 MiB → 3.5 MiB (CHOSEN)
+
+Keep the bundle work done this session (draco/basis stub, `three` out of SSR, `three`+Threlte as a separate ~808 KiB lazy chunk loaded only on Map-view open). Bump `IMAGE_DIST_MAX_BYTES` from `3 * 1024 * 1024` to `3.5 * 1024 * 1024` so the ~3.4 MiB `dist/` clears the assertion.
+
+**Pro**:
+- The flagship 3D structural overview ships in the **default** `stable` image — every user gets it with no flag, no discovery cost.
+- Download is deferred: the ~808 KiB chunk is fetched only when the Map view opens; non-Map views pay **zero** cold-start (DD-3, FR-005).
+- No new server surface / no egress — client-only render of existing `/api/map` data (DD-4, rule 22 intact).
+- Reuses this session's already-landed, already-measured bundle reductions (6.0 → ~3.4 MiB); nothing is thrown away.
+
+**Con**:
+- +~1.7 MiB install size vs the 2D-minimap baseline; `three`'s ~808 KiB is irreducible and still counts against the on-disk cap despite runtime laziness (DD-1/DD-2).
+- Moving the governance cap +0.5 MiB weakens a size-discipline guardrail PRD-030 set deliberately: every future image now has slack it did not have to justify (DD-5).
+- Adds a client runtime dependency (`three` + `@threlte/*` + transitive) with its own upgrade/security maintenance surface.
+
+**Verdict**: SUPPORTED — the only option that ships the feature by default while keeping non-Map views cold-start-free; cost is bounded (+0.5 MiB cap, +~1.7 MiB install) and reversible.
+
+### Option 2 — Do nothing: revert the 3D minimap, keep the flat 2D navigation minimap (baseline)
+
+Back out the 3D overview and the cap bump; the Map view keeps the reused flat 2D `Minimap`.
+
+**Pro**:
+- Default image stays ≤ 3 MiB; the PRD-030 cap and rule 21 are untouched.
+- No new client runtime dependency, no new maintenance/security surface.
+
+**Con**:
+- Loses the entire PRD-039 comprehension-at-altitude capability — the "see the whole layered stack at once" goal goes unmet.
+- Discards this session's measured bundle work (draco/basis stub, SSR exclusion, code-split) that already made the feature affordable.
+- Does not resolve the standing product need; the arc is abandoned rather than shipped.
+
+**Verdict**: REFUTED — meets the size guardrail only by discarding the feature the guardrail exists to serve; no product value delivered.
+
+### Option 3 — Keep 3D, but as an opt-in separate image (`dist-<name>/`) so the default `stable` image stays ≤ 3 MiB
+
+Use the existing image framework (PRD-030 / RFC-026 / ADR-005): ship the 3D chunk only in an opt-in `dist-<name>/` image; `stable` stays lean and only opt-in installs pay the `three` cost.
+
+**Pro**:
+- Default `stable` stays ≤ 3 MiB — the guardrail is preserved for the majority who never open the Map view.
+- The image framework already exists to carry exactly this kind of variant.
+
+**Con**:
+- Fragments the install UX that PRD-030 **just consolidated** — reintroduces a "which image do I pick" decision for a flagship feature that should be default-visible.
+- Most users would never see the 3D overview (behind a flag) → large discovery loss for a headline capability.
+- Build-pipeline + `init`/`update` flag plumbing + a doubled smoke matrix (build/verify both images) — real engineering cost for a benefit (0.5 MiB leaner default) that the raised cap makes marginal.
+- Splits the map feature-set across images: the composed-map view would behave differently depending on which image was installed.
+
+**Verdict**: REFUTED (for now) — defensible size-hygiene, but it buries a default-worthy feature and re-opens the install-UX fragmentation PRD-030 closed; the 0.5 MiB saved does not justify it. Revisit only if a genuine sub-3-MiB "lean" track is demanded (see Open questions).
+
+## Decision outcome
+
+**Chosen option**: **Option 1 — ship three.js + @threlte/\* as a lazy client chunk in the default image, and raise the per-image dist cap 3 MiB → 3.5 MiB.**
+
+Rationale referencing DD-1..DD-5:
+
+1. **DD-1 + measured ~808 KiB irreducible / ~3.4 MiB `dist/`** — after every affordable reduction (draco/basis stub −~1.5 MiB, `three` out of SSR), the artifact still clears 3 MiB by ~0.4 MiB; a 3.5 MiB cap is the smallest bump that admits it.
+2. **DD-2 + `cp -r` packaging** — laziness defers the *download*, not the *on-disk* cost, so the cap must move for the default image to ship at all; Option 3's alternative (keep the cap, move the chunk) is what the middle path costs, and DD-5 rejects that overhead.
+3. **DD-3 + FR-005 trace** — the lazy chunk keeps every non-Map view cold-start-free, so the +0.5 MiB is paid only by Map-view users, at Map-view-open time.
+4. **DD-4 + rule 22** — the minimap is a client-only render of existing read-only `/api/map` data, so this decision adds **no** server/network/trust surface; the cost is purely packaging.
+5. **DD-5 + the Force-3D revert precedent** — the change is a one-commit-ish backout (revert `a6ef030` + drop the lazy-chunk import + remove `three`/`@threlte/*` deps → back to the 2D minimap), which the earlier #103/#104 revert already demonstrated is clean.
+
+The decision is **reversible by design** (see Rollback Plan below). This mirrors the already-executed Force-3D revert (`7f907dd`).
+
+**Override note (HARD RULE 2).** The user pre-decided "raise the cap to 3.5M" over the do-nothing and opt-in-image alternatives. The manual ADI cycle above independently reaches the same recommendation (Option 1); the dismissed alternatives are documented in full rather than omitted.
+
+**PRD-030 reconciliation — supersede vs. amend (explicit flag; orchestrator decides at activation).** **Recommendation: an ADR-recorded amendment SUFFICES; do NOT `/supersede` PRD-030.** Reasons: (a) PRD-030 is a broad, active (R_eff 1.0) artifact governing the whole feature-flag/image system — only a **single NFR threshold** moves (3 → 3.5 MiB); superseding it would terminally retire a still-valid, still-governing decision to change one number. (b) `supersede` is terminal and for wholesale replacement; the image system PRD-030 describes is entirely intact. (c) The link is therefore `informs` (this ADR informs/overrides one PRD-030 constraint); `refines` would also be defensible, but `informs` is the recorded relation. The residual editorial drift — PRD-030 NFR-001/SC-4 text, rule 21 text, and the `a6ef030` code comment's mis-cited "NFR-005" all still say/point wrong — is a **fix-forward documentation task**, not a supersede: update those three to read "≤ 3.5 MiB per ADR-011 / NFR-001". Tracked in Open questions.
+
+## Consequences
+
+### Positive
+
+- The 3D isometric overview ships in the **default** image — no flag, no fragmented install UX, full discovery.
+- Non-Map views stay cold-start-free: the ~808 KiB chunk is fetched only on Map-view open.
+- This session's bundle discipline is preserved and recorded: draco/basis stub (−~1.5 MiB), `three` excluded from SSR (0 `three` markers in `dist/index.js`), code-split lazy chunk → `dist/` 6.0 → ~3.4 MiB.
+- Zero new server/network/trust surface — rule 22 untouched (client render of existing `/api/map`).
+
+### Negative
+
+- +~1.7 MiB install size vs the 2D baseline; `three`'s ~808 KiB is irreducible and still counts against the on-disk cap even though lazy.
+- The size-discipline guardrail is weakened by +0.5 MiB: every future image now carries slack it did not have to justify — future size regressions have more room to hide before the assertion fires.
+- A client runtime dependency (`three` + `@threlte/*` + transitive) is now on the maintenance/security surface (upgrade cadence, advisories).
+- The draco/basis stub is a load-bearing vite alias: if a future `@threlte/extras` feature needs the real loaders, the stub silently breaks it. A follow-up item tracks this before any such use.
+
+### Neutral
+
+- The cap constant already sits at 3.5 MiB in code (`a6ef030`) with a `TODO(iso-adr)` pointing at this ADR; this ADR closes it.
+- The authoritative packaged-size delta is still to be captured at PRD-039 prove-phase (`du -sb dist*/` EVID); this ADR uses the session measurements verbatim.
+
+## Rollback Plan
+
+If the decision fails (e.g. the 3.5 MiB slack proves unacceptable, `three` becomes a maintenance/security burden, or the 3D minimap is dropped), back out in this order — the earlier Force-3D revert (`7f907dd`) proves this is clean:
+
+1. **Revert the cap bump**: revert commit `a6ef030` so `IMAGE_DIST_MAX_BYTES` returns to `3 * 1024 * 1024` in `scripts/build.mjs`.
+2. **Remove the lazy chunk**: delete the Map-view 3D-overview widget's dynamic `three`/`@threlte/*` import so nothing pulls the chunk; the Map view falls back to the flat 2D `Minimap` (PRD-039 FR-007 already specifies an honest 2D fallback).
+3. **Drop the deps**: remove `three` + `@threlte/*` from `template/package.json#dependencies`; the vite draco/basis stub alias goes with them.
+4. **Rebuild + verify**: `npm run build` must re-pass the (restored) 3 MiB assertion; `npm run smoke` green on the `stable` image.
+
+Trigger for executing this rollback: either Revisit-Trigger metric or event below firing, or a superseding ADR.
+
+## Compliance / Revisit Trigger — MUST
+
+**This decision MUST be re-opened** when any parseable trigger below fires:
+
+- [ ] **Type**: metric — any emitted `dist*/` image exceeds **3.5 MiB** (`IMAGE_DIST_MAX_BYTES`) again.
+  - **Verification step**: `scripts/build.mjs` size assertion fails, or `du -sb dist*/` reports > 3,670,016 bytes for any image.
+  - **Next-action**: new ADR (`supersedes` ADR-011) deciding split-image vs. a further bump — do NOT silently raise `IMAGE_DIST_MAX_BYTES` again.
+- [ ] **Type**: event — `three` is dropped/replaced, or the 3D Map minimap is reverted (cf. the prior Force-3D revert `7f907dd`).
+  - **Verification step**: `three` / `@threlte/*` no longer in `template/package.json#dependencies`.
+  - **Next-action**: re-open to lower `IMAGE_DIST_MAX_BYTES` back toward 3 MiB (the cap rationale evaporates without the feature).
+- [ ] **Type**: date — 2027-01-08 (+6 months from creation).
+  - **Verification step**: calendar; a session on/after this date reads this trigger.
+  - **Next-action**: reassess whether `three` is still the lightest viable 3D runtime and whether the 3.5 MiB slack is still warranted.
+
+**Mark `[x]` to flag a trigger as fired.** Guardian will BLOCKER any artifact relying on an ADR with `[x]` triggers until the ADR is superseded or the trigger is unchecked with justification.
+
+## Invariants — SHOULD
+
+- **INV-1**: `three` MUST stay **out of the SSR server bundle** — 0 `three` markers in `dist/index.js`; SSR-guarded (`ssr=false` + browser-guarded) dynamic import only.
+- **INV-2**: the 3D rendering MUST remain a **separate lazy client chunk** loaded only on Map-view open — never inlined into the base bundle.
+- **INV-3**: the raised cap is **3.5 MiB, not a blank cheque** — no image may exceed it without a superseding ADR.
+- **INV-4**: the 3D minimap MUST remain a **pure client render of existing read-only `/api/map` data** — no new server surface, no spawn, no network (rule 22).
+
+## Open questions — SHOULD
+
+- The authoritative measured `du -sb dist*/` delta and the ~808 KiB `three`-chunk figure land in **PRD-039's prove-phase EVID** (PRD-039 Q2 / AC-5); this ADR uses the session measurements and the EVID is linked `informs` before activation.
+- Whether PRD-030 NFR-001/SC-4 text, rule 21 text, and the `a6ef030` code comment (mis-cited "NFR-005") should be **editorially updated** to "≤ 3.5 MiB per ADR-011 / NFR-001", or left with this ADR as the overriding record (recommend: editorial update, tracked separately — **not** a supersede).
+- Whether a future third "lean/LTS" image should carve the 3D chunk out to keep a sub-3-MiB track (defers to ADR-005's image framework — the rejected Option 3 path; not decided here).
+
+## Trust Calculus — chosen option (full-ADR bar: F+G+R ≥ 14)
+
+Scored on the 0–9 rubric for **Option 1**:
+
+- **F (Foundation / factual grounding) = 7** — the load-bearing numbers are concrete and first-party this session: `IMAGE_DIST_MAX_BYTES = 3.5*1024*1024` verified by grep; `a6ef030` verified by git blame; 6.0 → ~3.4 MiB, ~808 KiB, −~1.5 MiB draco/basis, 0 SSR `three` markers given verbatim. Not yet 9 because they are not yet captured in a linked EVID.
+- **G (Generality / robustness of reasoning) = 7** — three genuine options incl. do-nothing and the opt-in-image middle path; the core reasoning ("laziness defers download not on-disk cost; `cp -r` ships all chunks") generalizes.
+- **R (Reliability of sources) = 6** — sources are the working tree (grep), git history (blame/log), and the PRD bodies (read) — high reliability, but the packaging-delta EVID (`du -sb dist*/`) is still to be minted at PRD-039 prove-phase.
+
+**Sum = 20 ≥ 14 → proceed; no `evidence-gatherer` dispatch required.** R is deliberately capped pending the prove-phase EVID; that gap is surfaced in Consequences/Neutral and Open questions rather than papered over.
+
+## Affected Files
+
+Informative scope (not requirements) — the actual code change is owned by PRD-039's build/RFC phase:
+
+- `scripts/build.mjs` — `IMAGE_DIST_MAX_BYTES` 3 → 3.5 MiB (already applied in `a6ef030`); the `TODO(iso-adr)` comment closed by this ADR.
+- `template/package.json` — new `dependencies`: `three` + `@threlte/*`.
+- `template/vite.config.ts` (or equivalent) — the draco/basis stub alias + the `ssr=false` / code-split wiring keeping `three` out of `dist/index.js`.
+- `template/src/widgets/…` — the on-demand-loaded 3D Map-view overview widget (dynamic import site).
+- **Governance docs to reconcile (fix-forward, not part of this decision's activation)**: `.claude/rules/21-template-purity.md` (cap text 3 → 3.5 MiB), and PRD-030 NFR-001/SC-4 text — see Open questions.
+- **Unchanged**: `bin/` (rule 23 untouched — still `node:*` + `citty`); the read-only `/api/map` server surface (rule 22 untouched).
+
+## References
+
+- **PRD-039** — parent product spec (3D isometric layered overview minimap); this ADR is the "companion ADR" PRD-039 Q1/C-1 defers the cap decision to.
+- **PRD-030 (NFR-001 / SC-4)** — the per-image dist-size cap this ADR amends (3 → 3.5 MiB); rule 21 mirrors it.
+- **PRD-036** — Phase-1 composed-map render parent (lineage); provides the minimap slot replaced on the Map view.
+- **rule 21** (`.claude/rules/21-template-purity.md`) — `dist*/` size cap assertion; **rule 22** (`.claude/rules/22-readonly-proxy.md`) — read-only proxy boundary (untouched).
+- **ADR-005** — "Image as build artifact, not runtime config" — the image framework the rejected Option 3 would have used.
+- **RFC-026** — build-pipeline architecture for the image system (cap assertion lives in `scripts/build.mjs`).
+- **commit `a6ef030`** — "build(idef0): raise dist cap 3M -> 3.5M for lazy 3D Map minimap" (the applied change + `TODO(iso-adr)`).
+- **commit `7f907dd` / `dffbe25` (#103 / #104)** — the reverted "Force 3D" Threlte view mode + its reverted 6M cap bump (reversibility precedent).
+- **EVID (PRD-039 prove-phase)** — measured `du -sb dist*/` delta + on-demand-load trace + no-regression smoke; linked `informs` before activation.
+
+
+
+
+
+
diff --git a/.forgeplan/evidence/EVID-099-prd-039-ac-5-adr-011-dist-cap-build-pass-3-29-mib-under-3-5-mib-cap.md b/.forgeplan/evidence/EVID-099-prd-039-ac-5-adr-011-dist-cap-build-pass-3-29-mib-under-3-5-mib-cap.md
new file mode 100644
index 0000000..82e1f20
--- /dev/null
+++ b/.forgeplan/evidence/EVID-099-prd-039-ac-5-adr-011-dist-cap-build-pass-3-29-mib-under-3-5-mib-cap.md
@@ -0,0 +1,181 @@
+---
+depth: standard
+id: EVID-099
+kind: evidence
+last_modified_at: 2026-07-08T01:59:22.502906+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: PRD-039
+  relation: informs
+- target: RFC-036
+  relation: informs
+- target: ADR-011
+  relation: informs
+status: draft
+title: 'PRD-039 AC-5 + ADR-011 dist-cap: build PASS 3.29 MiB under 3.5 MiB cap'
+---
+
+## Verdict
+
+**CONCERNS**
+
+Build passes cleanly under the raised 3.5 MiB cap (3.29 MiB measured, ~220 KiB margin); `svelte-check` reports 0 errors; `vitest` reports 782/782 passing (0 failed, 0 skipped). The `three`/`@threlte` code-split is verified structurally sound (0 markers in the SSR bundle `dist/index.js`, draco/basis loaders absent from the tarball). These measurements **fully support** ADR-011's dist-cap decision and PRD-039 AC-6 (quality gate) and the bundle-size half of AC-5. **CONCERNS, not PASS**, because this EVID's RUN scope did not cover: PRD-039 AC-1/AC-3 (Map-view-only render, depth control/toggle — need Playwright/manual UI verification, not run here); AC-5's governance half (rule-22 spawn/write/network greps — not run here); and AC-2's automated half — RFC-036's own Test Strategy Hooks call for `shared-drill-bus` reducer unit tests (idempotence, descend/ascend, no re-entrant loop, NFR-004) and these **do not exist** in the test suite (0 test files under `widgets/iso-map/`, 0 test file for `shared-drill-bus.svelte.ts`). AC-2 currently rests entirely on one manual, non-repeatable observation (see below).
+
+## Ground-truth verification
+
+- Base..head: `54a905c862b542f14a2c5929aa44f450c63ffd21..HEAD` (source: merge-base with `develop`; HEAD = `9b3636a` on `feat/idef0-3d-iso-view`)
+- Diff probe: `git diff --stat 54a905c8..HEAD` (from a clean `bash --noprofile --norc` shell, `set +u`)
+- Diff state: **DELTA=PRESENT** — 230 files changed, 57717 insertions(+), 243 deletions(-)
+- Expected delta tokens (source: PRD-039/RFC-036/ADR-011 claims): `IsoMapCorner`, `shared-drill-bus`, `IMAGE_DIST_MAX_BYTES` — all three (source: claim/RFC/ADR)
+- Token probe: `git diff 54a905c8..HEAD --name-only | grep -iE "iso-map|shared-drill-bus|build.mjs|vite.config"` + `grep -n "IMAGE_DIST_MAX_BYTES" scripts/build.mjs` → **FOUND** (all three)
+- Verdict floor from ground-truth gate: **PASS-eligible** (diff present, all expected tokens found)
+
+```
+=== git diff --stat base..head (tail) ===
+ template/src/widgets/iso-map/IsoScene.svelte                     |  217 +
+ template/src/widgets/iso-map/index.ts                            |    1 +
+ template/src/widgets/iso-map/lib/iso-materials.ts                |  140 +
+ template/src/widgets/iso-map/lib/iso-projection.ts                |  448 +
+ template/src/widgets/iso-map/lib/leader-line.ts                  |   39 +
+ template/src/widgets/iso-map/lib/motion.ts                       |   16 +
+ template/src/widgets/iso-map/model/iso-view-state.svelte.ts      |  641 +
+ template/src/widgets/iso-map/ui/IsoA11yProxy.svelte               |   79 +
+ template/src/widgets/iso-map/ui/IsoControls.svelte                |   66 +
+ template/src/widgets/iso-map/ui/IsoDeeperMarker.svelte            |   55 +
+ template/src/widgets/iso-map/ui/IsoFrustum.svelte                 |   46 +
+ template/src/widgets/iso-map/ui/IsoIcomArrows.svelte              |   64 +
+ template/src/widgets/iso-map/ui/IsoLayerCard.svelte               |  100 +
+ template/src/widgets/iso-map/ui/IsoLeaderLine.svelte              |  132 +
+ template/src/widgets/iso-map/ui/IsoMinimap.svelte                 |  218 +
+ template/src/widgets/iso-map/ui/IsoNodeBox.svelte                 |   63 +
+ template/src/widgets/iso-map/ui/IsoNodeCard.svelte                |  141 +
+ template/src/widgets/iso-map/ui/IsoPlane.svelte                   |  157 +
+ template/src/widgets/iso-map/ui/IsoSliverPlane.svelte             |   29 +
+ template/src/widgets/iso-map/ui/IsoZoneFrame.svelte               |   85 +
+ template/vite.config.ts                                           |   18 +
+ template/vite/stubs/three-loaders.ts                              |   20 +
+ 230 files changed, 57717 insertions(+), 243 deletions(-)
+DELTA=PRESENT
+
+=== token probe ===
+scripts/build.mjs
+template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts
+template/src/widgets/dependency-graph/ui/IsoMapCorner.svelte
+template/src/widgets/iso-map/* (20 files)
+template/vite.config.ts
+
+scripts/build.mjs:32:const IMAGE_DIST_MAX_BYTES = 3.5 * 1024 * 1024;
+scripts/build.mjs:430:  if (totalBytes > IMAGE_DIST_MAX_BYTES) {
+scripts/build.mjs:432:    `${targetName}/ is ${(totalBytes/1024/1024).toFixed(2)}M, cap is ${(IMAGE_DIST_MAX_BYTES/1024/1024).toFixed(0)}M ...`
+```
+
+## Runner detected
+
+- Ecosystem: node (root build pipeline) + node/svelte (template)
+- Runner: `npm run build` (root, wraps `node scripts/build.mjs`); `svelte-check` (template); `vitest` (template)
+- Output format: text (build log + svelte-check summary line + vitest text reporter)
+- Config source: root `package.json#scripts.build`; `template/package.json` (svelte-check via `npx`); `template/vitest.config.ts`
+
+## Command run
+
+```bash
+cd /Users/explosovebit/Work/ForgePlanWeb && npm run build
+# -> node scripts/build.mjs
+
+cd /Users/explosovebit/Work/ForgePlanWeb/template && npx svelte-check --threshold error
+
+cd /Users/explosovebit/Work/ForgePlanWeb/template && npx vitest run
+
+# packaged-size measurement (BSD du has no -b; used find+stat for exact bytes)
+find dist -type f -exec stat -f%z {} \; | awk '{sum+=$1} END{print sum}'
+du -sh dist
+find dist-nightly -type f -exec stat -f%z {} \; | awk '{sum+=$1} END{print sum}'
+du -sh dist-nightly
+
+# code-split verification
+grep -c -iE "BufferGeometry|WebGLRenderer|from ['\"]three" dist/index.js
+find dist -iname '*draco*' -o -iname '*basis*'
+```
+
+Exit codes: `npm run build` = **0** | `svelte-check --threshold error` = **0** | `vitest run` = **0**
+
+## Summary
+
+| Metric | Value |
+|---|---|
+| Build (root `npm run build`) | exit 0; both images built: `stable` (dist/ ready, 3.29M) + `nightly` (dist-nightly/ ready, 3.29M) |
+| Cap assertion (`scripts/build.mjs` `IMAGE_DIST_MAX_BYTES=3.5*1024*1024`) | **passed** — no `totalBytes > IMAGE_DIST_MAX_BYTES` error thrown for either image |
+| **`dist/` measured size** | **3,444,656 bytes** (exact, `find+stat` sum) = **3.29 MiB** / `du -sh` reports **3.4M** |
+| **`dist-nightly/` measured size** | **3,444,657 bytes** = **3.29 MiB** / `du -sh` reports **3.4M** |
+| Cap (ADR-011) | 3.5 MiB = 3,670,016 bytes |
+| Margin under cap | 3,670,016 − 3,444,656 = **225,360 bytes (~220 KiB, ~6.1%)** |
+| svelte-check | 2344 files checked, **0 errors**, 8 warnings, 2 files with problems |
+| vitest — Test Files | **60 passed (60)**, 0 failed |
+| vitest — Tests | **782 passed (782)**, 0 failed |
+| vitest — Skipped | 0 (none reported) |
+| vitest — Flaky | not measured (single run, no `--retry`/`--reruns` pass performed) |
+| vitest — Duration | 4.82s (transform 31.48s, import 39.02s, tests 1.60s) |
+
+## AC coverage delta
+
+Parent: PRD-039 (+ RFC-036 realization, ADR-011 packaging decision)
+
+**AC-5 — governance & bundle-size constraint (NFR-001, NFR-006):**
+- Bundle-size half: **MEASURED, PASS.** `du`-equivalent (`find+stat`, BSD `du` has no `-b`) gives exact `dist/` = 3,444,656 bytes (3.29 MiB), `dist-nightly/` = 3,444,657 bytes (3.29 MiB), both under the ADR-011 cap of 3.5 MiB (3,670,016 bytes) by ~220 KiB. This is the authoritative measured delta PRD-039 Q2/NFR-001 left as TBD — recorded here.
+- Governance half (rule-22 spawn/write/network greps): **NOT RUN** in this EVID pass — out of the instructed RUN scope. Recommend a follow-up governance check (e.g. `security-expert` or a rule-22 grep pass over `template/src/routes/api/` + `template/src/shared/server/`) before activation claims AC-5 fully closed.
+
+**AC-6 — quality gate:** **MEASURED, PASS.** `svelte-check --threshold error` = 0 errors (2344 files, 8 pre-existing warnings — consistent with PRD-039's "pre-existing warnings OK" note). `vitest run` = 782/782 passing, 0 failures.
+
+**AC-4 — on-demand load + zero regression (FR-005, FR-006), partial:**
+- Zero-regression: **supported** — 782/782 tests pass including composed-map render/model tests (`tour.render.test.ts`, `nav-contract.render.test.ts`, `drill-state.test.ts`, `camera-bus.test.ts`, etc.) with no observed failures.
+- On-demand load: **structurally supported, not dynamically traced.** `dist/index.js` (the SSR bundle) has **0** matches for `BufferGeometry|WebGLRenderer|from ['"]three` (confirms ADR-011 INV-1: three stays out of SSR). The three/@threlte code lives in a separate lazy client chunk `dist/client/_app/immutable/chunks/CUbqzil1.js` (824,215 bytes ≈ 805 KiB — matches ADR-011's claimed "~808 KiB lazy chunk"), which is NOT part of `index.js`. `find dist -iname '*draco*' -o -iname '*basis*'` returned empty (draco/basis loaders correctly stubbed/absent). This is strong structural evidence for FR-005, but no browser network trace was captured to directly observe "chunk absent on non-Map view, fetched on Map-view open" (NFR-002) — that requires a live Playwright pass, not run in this EVID.
+
+**AC-1, AC-3 — NOT covered by this EVID.** Map-view-only rendering (AC-1) and the depth control/toggle (AC-3) require live UI verification (Playwright or manual) — outside this EVID's instructed RUN scope (build/svelte-check/vitest/grep only).
+
+**AC-2 — bidirectional drill sync, weak coverage:**
+- **Manual observation (recorded as manual, NOT an automated test — one-shot, not a regression guard):** the orchestrator live-verified in dev that clicking a zone in the 3D corner descended the 2D map into it, and the 2D "All" breadcrumb reset the 3D to root, with 0 console errors.
+- **Automated coverage gap (real finding):** RFC-036's own "Test Strategy Hooks" section explicitly calls for `shared-drill-bus` reducer unit tests (same interaction sequence → same final focus; descend-then-ascend returns to prior focus; `descend(current)` is a no-op; no re-entrant emit loop — NFR-004/INV-E). **These tests do not exist.** `find src/widgets/iso-map -iname '*.test.*'` = empty (0 test files for the entire 20-file, ~2700-line 3D widget). `grep -rl -iE "shared-drill-bus" src --include="*.test.*"` = empty (0 tests reference the bus). The composed-map model test directory has tests for `drill-state.test.ts`, `camera-bus.test.ts`, `tour-state.test.ts`, `level-documents.test.ts`, `node-tabs.test.ts` — but none for `shared-drill-bus.svelte.ts` (53 lines, new in this diff). PRD-039 AC-2 itself requires "verified end-to-end + by focus-chain unit tests" — the unit-test half is unmet.
+
+## Failing tests
+
+None. 0 failures in vitest (782/782 passing); 0 errors in svelte-check.
+
+## Slow tests (top 5)
+
+vitest text reporter did not emit per-test timing in this run (only aggregate phase timing: transform 31.48s, import 39.02s, tests 1.60s). No individual slow-test outliers surfaced.
+
+## Flaky candidates
+
+None measured — a single `vitest run` pass was performed without `--retry`/`--reruns`; flakiness was not probed in this EVID.
+
+## Code-split verification (task-specific checks)
+
+```
+$ grep -c -iE "BufferGeometry|WebGLRenderer|from ['\"]three" dist/index.js
+0
+
+$ find dist -iname '*draco*' -o -iname '*basis*'
+(empty)
+
+$ (supplementary, not requested but load-bearing for the "code-split is real" claim)
+$ for f in dist/client/**/*.js: grep -c -iE "BufferGeometry|WebGLRenderer"
+dist/client/_app/immutable/chunks/CUbqzil1.js : 7 matches, 824215 bytes
+```
+
+Confirms: three/@threlte is fully absent from the SSR server bundle (`dist/index.js`, 0 markers) and from the tarball's draco/basis loaders (stubbed/absent per RFC-036's vite alias), while genuinely present as an isolated ~805 KiB lazy client chunk — matching ADR-011 INV-1/INV-2 and RFC-036 INV-A/INV-B.
+
+## Next steps
+
+- **CONCERNS resolution before PRD-039 activation:** dispatch `coder` (or a follow-up sprint) to add `shared-drill-bus.svelte.ts` reducer unit tests per RFC-036's own Test Strategy Hooks (idempotent descend, ascend-returns-to-prior-focus, no re-entrant loop) — this closes AC-2's automated half and NFR-004/INV-E.
+- **CONCERNS resolution:** run rule-22 governance greps (spawn/execFile/fetch/write scans over `template/src/routes/api/` + `template/src/shared/server/`) to close AC-5's governance half — recommend `security-expert` dispatch.
+- **CONCERNS resolution:** a live Playwright pass (network/asset trace + Map-view-only render + depth control/toggle) would close AC-1, AC-3, and the NFR-002 half of AC-4.
+- **PASS, hand to guardian:** the measured build/cap/quality-gate claims in this EVID (ADR-011 dist-cap decision, PRD-039 AC-5 bundle-size half, AC-6 quality gate) are solid and can support activating **ADR-011** specifically. PRD-039 as a whole should stay `draft` pending the three CONCERNS items above.
+
+## Structured Fields
+
+verdict: supports
+congruence_level: 3
+evidence_type: measurement
+
+
+
diff --git a/.forgeplan/evidence/EVID-100-code-review-of-rfc-036-prd-039-3d-iso-map-concerns-zero-tests-sync-drop-race-rfc-code-drift.md b/.forgeplan/evidence/EVID-100-code-review-of-rfc-036-prd-039-3d-iso-map-concerns-zero-tests-sync-drop-race-rfc-code-drift.md
new file mode 100644
index 0000000..0765d28
--- /dev/null
+++ b/.forgeplan/evidence/EVID-100-code-review-of-rfc-036-prd-039-3d-iso-map-concerns-zero-tests-sync-drop-race-rfc-code-drift.md
@@ -0,0 +1,113 @@
+---
+depth: standard
+id: EVID-100
+kind: evidence
+last_modified_at: 2026-07-08T02:05:10.526109+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: RFC-036
+  relation: informs
+- target: PRD-039
+  relation: informs
+status: draft
+title: 'Code review of RFC-036/PRD-039 (3D iso-map): CONCERNS — zero tests, sync-drop race, RFC/code drift'
+---
+
+## Verdict
+
+CONCERNS
+
+One-line justification: the feature is architecturally sound and its two hardest invariants (SSR-three-exclusion, no `shared/ui` re-skinning) verify clean under a real build — but it ships with **zero unit tests** for the single most load-bearing new contract (the shared-drill-bus sync loop), a genuine desync race in that same sync path, and a companion RFC that documents an API/mechanism the shipped code doesn't actually have.
+
+## Scope
+
+- Parent: RFC-036 (`based_on` PRD-039), companion ADR-011
+- Diff range: `f0ffeb7..9b3636a` (`HEAD~14..HEAD` on `feat/idef0-3d-iso-view`) — the 14 iso-specific commits, isolated from the `develop` merge-base which pulls in ~100 unrelated commits (chat/composed-map history already shipped)
+- Files reviewed: 29 files, 3236 insertions / 12 deletions
+- Files: `template/src/widgets/iso-map/**` (20 files, new widget), `template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts` (new), `template/src/widgets/composed-map/ui/ComposedMapView.svelte` (+65 lines, sync wiring), `template/src/widgets/dependency-graph/ui/{IsoMapCorner.svelte (new), DependencyGraph.svelte (+23/-7)}`, `template/vite.config.ts` + `template/vite/stubs/three-loaders.ts` (draco/basis stub), `scripts/build.mjs` (cap 3→3.5 MiB), `template/package.json` (+three, +@threlte/core, +@threlte/extras, +@types/three)
+
+## Tools run
+
+| Tool | Exit | Notes |
+|---|---|---|
+| svelte-check --threshold error | 0 | 2344 files, 0 errors, 8 warnings in 2 files unrelated to this diff (no iso-map/threlte/three matches in the warning set) |
+| rule-24 grep (`:global()` reaching primitive classes) | 0 | ran over `widgets/iso-map`, `widgets/composed-map`, `widgets/dependency-graph` — no upper-layer reach into `shared/ui` primitive internals |
+| rule-21 grep (three/@threlte dependency placement) | manual | confirmed `three`, `@threlte/core`, `@threlte/extras` under `template/package.json#dependencies` (not devDependencies); `@types/three` correctly under `devDependencies` |
+| real build (`npm run build` product already present) | n/a | inspected the already-built `dist/` (stable image) as ground truth for the SSR/lazy-load claims — see below |
+| vitest | n/a | no test files exist in the diff to run (see Finding #2) |
+
+## Ground-truth verification
+
+- Base..head: `f0ffeb795a0092a4f1cfb609264460e64b58db7b..9b3636a` (source: derived — `develop` merge-base pulls in unrelated history, so the 14-commit range matching "iso-spike" (`2bfac1c`) through "resolve TODO(iso-adr)" (`9b3636a`) is used instead, matching the task's own `HEAD~14` fallback)
+- Diff probe: `git diff f0ffeb7..HEAD --stat -- template/ scripts/ package.json` → **DELTA=PRESENT** (29 files, 3236 insertions)
+- Expected delta token: `shared-drill-bus` (the RFC's own load-bearing contract name) → **FOUND**: `template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts` exists, is imported by both `ComposedMapView.svelte:80` and `IsoMinimap.svelte:41-45`
+- Additional ground truth (SSR-exclusion invariant, INV-A/ADR-011 INV-1): `grep -c -iE "BufferGeometry|WebGLRenderer|Object3D|from ['\"]three" dist/index.js` → **0** (confirms three.js is genuinely absent from the SSR bundle; an earlier broad `grep -c three` returned 2 hits that were investigated and are confirmed false positives — HTML-entity names `leftthreetimes`/`rightthreetimes`/`lthree`/`rthree` in a markdown-entity table, and one unrelated `<option value="three">` in a dropdown — not the `three.js` package)
+- Additional ground truth (lazy-chunk claim, FR-005/NFR-002): `find dist/client/_app/immutable -name "*.js" -exec du -h {} \;` → an 808 KiB chunk (`CUbqzil1.js`) exists; `grep -l "OrbitControls\|THREE\.\|WebGLRenderer" dist/client/.../CUbqzil1.js` confirms it is the three/Threlte chunk; `grep -c CUbqzil1 dist/client/.../entry/start.*.js dist/client/.../entry/app.*.js` → **0** in both eager entry chunks, referenced only via a genuine `import(...)` inside the map-view's own route chunk — confirms the chunk is not eagerly loaded on non-Map views
+- Verdict floor from ground-truth gate: PASS-eligible (diff present, expected token found, invariants hold under real build) — findings below are quality/robustness gaps found on top of a genuine, working change, not evidence the change didn't land
+
+```
+$ git diff f0ffeb795a0092a4f1cfb609264460e64b58db7b..HEAD --stat -- template/ scripts/ package.json | tail -5
+ template/vite.config.ts                            |  18 +
+ template/vite/stubs/three-loaders.ts               |  20 +
+ 29 files changed, 3236 insertions(+), 12 deletions(-)
+
+$ grep -c -iE "BufferGeometry|WebGLRenderer|Object3D|from ['\"]three" dist/index.js
+0
+
+$ find dist/client/_app/immutable -name "*.js" -exec du -h {} \; | sort -rh | head -3
+808K	dist/client/_app/immutable/chunks/CUbqzil1.js
+420K	dist/client/_app/immutable/chunks/BqNcAaJ-.js
+336K	dist/client/_app/immutable/chunks/BMsIFlOI.js
+
+$ grep -c CUbqzil1 dist/client/_app/immutable/entry/start.Bbib7K2x.js dist/client/_app/immutable/entry/app.BitgxMJP.js
+dist/client/_app/immutable/entry/start.Bbib7K2x.js:0
+dist/client/_app/immutable/entry/app.BitgxMJP.js:0
+```
+
+## Findings
+
+| # | Severity | Category | Location | Description | Recommended fix |
+|---|---|---|---|---|---|
+| 1 | HIGH | 🐛 Bug | `template/src/widgets/iso-map/model/iso-view-state.svelte.ts:413-438` (`applyExternalFocusChain`) + `template/src/widgets/iso-map/ui/IsoMinimap.svelte:124-136` (INBOUND `$effect`) | `applyExternalFocusChain` bails out completely (`if (animationKind !== null) return;`) when an externally-driven chain (e.g. a 2D-map drill) arrives while the 3D view is mid-animation — no queuing, no scheduled retry. The consuming `$effect` only re-fires when `sharedFocusChain()` changes *again*; if no further chain change happens, the 3D view is left permanently desynced from the 2D map, contradicting the RFC's own claimed NFR-004/INV-E "no drift, no divergent foci" guarantee (comment even admits "best-effort... the caller's own effect will see the still-unreconciled chain and retry on the next change" — but there is no "next change" if the user stops interacting). | On the animation settling (`animationKind` transitioning back to `null`), re-check `sharedFocusChain()` against the local chain and apply any pending mismatch instead of relying on an unrelated future chain change. |
+| 2 | HIGH | 🧪 Test gap | `template/src/widgets/iso-map/**`, `template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts` | Zero test files ship with this diff (confirmed via `git diff --stat f0ffeb7..HEAD` — 29 changed files, none `*.test.ts`). RFC-036's own "Test Strategy Hooks" section explicitly demands "bus reducer unit tests (idempotence, descend/ascend, no re-entrant loop — NFR-004)", a "bidirectional-sync contract test", and an "honest-fallback failure injection" test — none exist. The one genuinely load-bearing new mechanism in this PR (the content-guarded sync loop, Finding #1's exact failure mode) has no coverage at all. | Add unit tests for `shared-drill-bus.svelte.ts` (idempotent `setSharedFocusChain`, `chainsEqual`) and a reducer test for `iso-view-state.svelte.ts`'s `applyExternalFocusChain` covering the mid-animation-arrival case from Finding #1. |
+| 3 | MEDIUM | 🐛 Bug | `template/src/widgets/dependency-graph/ui/IsoMapCorner.svelte:26-36` | FR-007's "honest fallback" is only half-implemented: the `{#await}...{:catch}` block only catches a **rejected dynamic-import promise**. A runtime failure during `<mod.IsoMinimap>`'s render/mount (e.g. WebGL context creation failing inside `@threlte/core`'s `<Canvas>`) is not caught by anything in this diff — no `<svelte:boundary>`, no try/catch around the mount call. The RFC explicitly claims "IsoScene's WebGL/Threlte init failure throws. IsoMapCorner catches it" (§Data Flow, Named failure path) — that mechanism as coded cannot intercept a post-import render/init error, only an import-time one. | Wrap `<mod.IsoMinimap />` in a Svelte 5 `<svelte:boundary onerror={...}>` so a WebGL-init failure inside the mounted component also falls back to the 2D-unavailable state, not just an import failure. |
+| 4 | LOW-MEDIUM | 📚 Docs | `template/src/widgets/iso-map/IsoScene.svelte:37-40` | Stale comment: `// TODO(spike): de-risking prototype... Throwaway route, not linked from any nav — proves Threlte renders our real composed-map data...` is now false — commits `0950859` (graduate routes/iso-spike → widgets/iso-map), `12a7194` (mount as Map-view corner minimap), and `5b946bd` (drop the throwaway /iso-spike route) mean this component **is now** linked from nav and **is** the production surface. Violates rule 10 ("stale comments referencing removed code"). | Delete or rewrite the stale `TODO(spike)` block; the file is no longer a throwaway spike. |
+| 5 | LOW | 📚 Docs | `template/src/widgets/iso-map/ui/IsoFrustum.svelte:2`, `IsoPlane.svelte:2`, `IsoControls.svelte:2`, and ~11 other `ui/*.svelte` + `lib/*.ts` files under `widgets/iso-map/` | The generic `// TODO(iso-promote): promote to widgets/iso-map + move shared drill logic to entities on graduation` comment, copy-pasted verbatim across ~14 files, is half-stale: the "promote to widgets/iso-map" clause is already done (that IS these files' current location, per commit `0950859`). Only the "move shared drill logic to entities" half is still pending work. Confusing for a future reader trying to scope what remains. | Reword the recurring TODO to state only the remaining work ("move shared-drill-bus to entities on graduation") — drop the already-completed "promote to widgets/iso-map" clause. |
+| 6 | LOW-MEDIUM | 📚 Docs | RFC-036 body, §Risks R-4 and §Proposed Direction ("Lazy-chunk boundary") vs. `template/vite.config.ts:37-51` and `template/vite/stubs/three-loaders.ts` | RFC-036 asserts twice that `// TODO(iso-draco-basis)` guards the load-bearing draco/basis vite alias ("This alias is load-bearing (Risk R-4)... `// TODO(iso-draco-basis)` guards it"). `grep -rn "iso-draco\|draco-basis" template/vite.config.ts template/vite/stubs/three-loaders.ts` returns nothing — no such marker exists in the actual code. Per rule 10, a load-bearing workaround that can "silently break" future usage (the RFC's own words) requires a TODO — it's missing, and the RFC overstates what was implemented. | Add the missing `// TODO(iso-draco-basis)` marker to `vite.config.ts` at the alias definition, matching what the RFC already claims exists. |
+| 7 | LOW | 📚 Docs | RFC-036 §"Function Signatures / Component Contracts" vs. `template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts:19-53` | The RFC documents a `shared-drill-bus` API with `descend()`, `ascend()`, `focusTo()`, `visibleDepth`/`setDepth()`, `hidden`/`toggleVisible()`. The shipped module exposes only `sharedFocusChain()`, `setSharedFocusChain()`, `chainsEqual()` — depth-window and visibility are local-only state inside `iso-view-state.svelte.ts`, never shared via the bus. RFC-036 states it "documents the design as built" — this section doesn't match what was built. | Update RFC-036's Function Signatures section to reflect the actual thin 3-function bus contract, or note explicitly that depth/visibility are intentionally NOT part of the shared surface. |
+
+## Positive observations
+
+- The sync-loop guard mechanism itself is well designed: `setSharedFocusChain`'s content-guarded write (`chainsEqual` no-op, `shared-drill-bus.svelte.ts:49-53`), combined with the `untrack`-wrapped INBOUND effect and a `sharedChainPrimed` skip-first-run flag (wired symmetrically in `ComposedMapView.svelte:552-575` and `IsoMinimap.svelte:106-136`), was traced by hand through a click→propagate→settle cycle and terminates correctly in the common (non-animating) case — a legitimately careful piece of reactive-state design, undermined only by the animation-in-flight edge case in Finding #1.
+- Rule 21 (template purity / dependency placement) is fully respected: `three`, `@threlte/core`, `@threlte/extras` land under `template/package.json#dependencies` (not `devDependencies`); `@types/three` correctly under `devDependencies`.
+- The lazy-load boundary is real, not just claimed: verified against an actual build artifact (not the RFC's prose) that the three/Threlte chunk is absent from both eager entry chunks and is fetched only via `IsoMapCorner`'s `browser`-guarded dynamic `import()`.
+- `IsoA11yProxy.svelte` is a solid accessibility pattern: correct visually-hidden CSS (clip-rect, not `display:none`, so it stays in the tab order and the a11y tree), one focusable proxy button per currently-dwellable target, and immediate (no artificial dwell-delay) open on keyboard focus since a Tab lands on a committed target unlike a passing-through mouse hover.
+
+## Test coverage delta
+
+- Before: n/a (new widget)
+- After: 0% — no test files in this diff (Finding #2)
+- Branches gained: none covered
+- Branches still uncovered: shared-drill-bus idempotence/loop-guard, bidirectional sync end-to-end, depth-window control, honest-fallback path, the exact race in Finding #1
+
+## Next steps
+
+- Dispatch a coder agent for Finding #1 (the animation-in-flight sync-drop) — this is the one finding that undermines a stated invariant (NFR-004/INV-E) under a plausible interaction sequence, not just a hygiene gap.
+- Dispatch a coder/tester agent for Finding #2 (test suite) before this ships past draft — RFC-036 itself gates Phase 1/2 on exactly these tests existing.
+- Findings #4-7 (docs/comments) are cheap fix-forward items; batch them into the same PR or a fast follow-up.
+- Finding #3 (fallback boundary) is a `should`-priority FR-007 gap — worth fixing but not release-blocking on its own.
+- Re-review after Findings #1/#2 land; the remaining findings (#3-7) do not need a second full pass, just a diff spot-check.
+
+## Structured Fields
+
+verdict: weakens
+congruence_level: 3
+evidence_type: audit
+
+## References
+
+- Parent: RFC-036 (based_on PRD-039), companion ADR-011
+- Related EVIDENCE: EVID-099 (PRD-039 AC-5 dist-cap build-pass claim — noted but not relied upon as ground truth; this review independently re-derived the same dist-cap/SSR-exclusion facts from the actual build artifact rather than trusting that EVID's title)
+- Related ADR: ADR-011 (ship three.js+Threlte lazy chunk; cap 3→3.5 MiB) — this review's Ground-truth verification section independently confirms ADR-011 INV-1 (SSR three-free) and INV-2 (lazy-only) hold under a real build
+
+
diff --git a/.forgeplan/evidence/EVID-101-re-review-of-evid-100-fix-commits-rfc-036-prd-039-3d-iso-map-concerns-3-4-closed-rfc-function-signatures-drift-still-open.md b/.forgeplan/evidence/EVID-101-re-review-of-evid-100-fix-commits-rfc-036-prd-039-3d-iso-map-concerns-3-4-closed-rfc-function-signatures-drift-still-open.md
new file mode 100644
index 0000000..5556163
--- /dev/null
+++ b/.forgeplan/evidence/EVID-101-re-review-of-evid-100-fix-commits-rfc-036-prd-039-3d-iso-map-concerns-3-4-closed-rfc-function-signatures-drift-still-open.md
@@ -0,0 +1,121 @@
+---
+depth: standard
+id: EVID-101
+kind: evidence
+last_modified_at: 2026-07-08T10:17:43.378163+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: RFC-036
+  relation: informs
+- target: PRD-039
+  relation: informs
+status: draft
+title: 'Re-review of EVID-100 fix commits (RFC-036/PRD-039 3D iso-map): CONCERNS — 3/4 closed, RFC Function-Signatures drift still open'
+---
+
+## Verdict
+
+CONCERNS
+
+One-line justification: the two HIGH findings (the sync-drop race and the zero-test-coverage gap) are genuinely, non-vacuously closed — a real `pendingExternal` retry mechanism plus 16 passing tests that exercise the exact mid-animation race — and the MEDIUM WebGL-boundary gap is closed with a real `<svelte:boundary>`; but the fourth EVID-100 finding (RFC-036/code drift) is only 3/4 closed — RFC-036's own "Function Signatures / Component Contracts" section still documents `descend()`, `ascend()`, `setDepth()`, `toggleVisible()`, `hidden` as `shared-drill-bus` methods that do not exist in the shipped module, and the fix's own new source comment explicitly defers correcting the RFC document itself ("that is Profile A/B territory... not this coder change").
+
+## Scope
+
+- Parent: RFC-036 (`based_on` PRD-039), companion ADR-011; re-reviewing EVID-100's CONCERNS verdict
+- Diff range: `0f1ffed..HEAD` (`3bd0a4d` fix commit + `3e948dd` test commit, on `feat/idef0-3d-iso-view`) — the two fix commits landed after EVID-100
+- Files reviewed: 26 files, 418 insertions / 104 deletions (per `git diff --stat`), plus a fresh `forgeplan_get RFC-036` read of the artifact body itself
+- Files: `template/src/widgets/iso-map/model/iso-view-state.svelte.ts`, `template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts` (+ new `.test.ts`), `template/src/widgets/iso-map/model/iso-view-state.render.test.ts` (new), `template/src/widgets/composed-map/ui/ComposedMapView.svelte`, `template/src/widgets/iso-map/ui/IsoMinimap.svelte`, `template/src/widgets/dependency-graph/ui/IsoMapCorner.svelte`, `template/src/widgets/iso-map/IsoScene.svelte`, 13× `widgets/iso-map/{ui,lib}/*` (TODO dedup), `template/src/widgets/iso-map/index.ts`, `template/vite.config.ts`
+
+## Tools run
+
+| Tool | Exit | Notes |
+|---|---|---|
+| `npx vitest run shared-drill-bus iso-view-state.render` | 0 | 2 test files, 16/16 passed |
+| `npx vitest run` (full suite) | 0 | 62 test files, 798/798 passed — no regression from the fix |
+| `npx svelte-check --threshold error` | 0 | 2346 files, 0 errors, 8 warnings (same 2 pre-existing files as EVID-100, unrelated to this diff) |
+| `npm run build` | 0 | `dist/` 3.29M, `dist-nightly/` 3.29M — both under the 3.5 MiB cap |
+| `grep setSharedFocusChain template/src/` | 1 (no matches) | confirms the rename to `focusTo` left no orphan references |
+| `grep -c -iE "BufferGeometry\|WebGLRenderer\|Object3D\|from ['\"]three" dist/index.js` | — | 0 — SSR three-exclusion invariant (INV-A/ADR-011 INV-1) still holds after the fix |
+
+## Ground-truth verification
+
+- Base..head: `0f1ffed..HEAD` (source: task-provided — `0f1ffed` is the pre-fix sync commit, `HEAD` = `3e948dd`)
+- Diff probe: `git diff 0f1ffed..HEAD --stat -- template/` → **DELTA=PRESENT** (26 files, 418 insertions(+), 104 deletions(-))
+- Expected delta tokens (derived from EVID-100's own recommended fixes): `pendingExternal` (Finding #1 fix), `svelte:boundary` (Finding #3 fix), `shared-drill-bus.svelte.test.ts` + `iso-view-state.render.test.ts` (Finding #2 fix) → all **FOUND** in the diff
+- Verdict floor from ground-truth gate: PASS-eligible (diff present, all expected tokens found, invariants hold under a real build) — the CONCERNS verdict below is about one specific finding remaining open, not about whether the fix commits landed
+
+```
+$ git diff 0f1ffed..HEAD --stat -- template/ | tail -3
+ template/vite.config.ts                            |  56 +++++---
+ 26 files changed, 418 insertions(+), 104 deletions(-)
+
+$ cd template && npx vitest run shared-drill-bus iso-view-state.render
+ Test Files  2 passed (2)
+      Tests  16 passed (16)
+
+$ npx vitest run   # full suite
+ Test Files  62 passed (62)
+      Tests  798 passed (798)
+
+$ npx svelte-check --threshold error
+1783505732569 COMPLETED 2346 FILES 0 ERRORS 8 WARNINGS 2 FILES_WITH_PROBLEMS
+
+$ npm run build
+[build] dist/ ready (3.29M, image=stable, features=0)
+[build] dist-nightly/ ready (3.29M, image=nightly, features=0)
+
+$ grep -c -iE "BufferGeometry|WebGLRenderer|Object3D|from ['\"]three" dist/index.js
+0
+
+$ grep -rn "setSharedFocusChain" template/src/ ; echo "exit: $?"
+exit: 1
+```
+
+## Per-finding closed/open status (against EVID-100)
+
+| EVID-100 # | Severity | Category | Status | Evidence |
+|---|---|---|---|---|
+| #1 sync-drop race | HIGH | 🐛 Bug | **CLOSED** | `iso-view-state.svelte.ts:112-140` adds a module-level `pendingExternal` slot + an `$effect.root` watcher that fires when `animationKind` settles to `null` and a pending target exists; `applyExternalFocusChain` (lines ~434-465) now records into `pendingExternal` instead of silently returning when `animationKind !== null`, and clears it before re-invoking itself (idempotent, no re-entrant loop). `iso-view-state.render.test.ts` exercises exactly the race: an update arrives mid-animation ("must NOT yet show ext-b"), then asserts convergence to the LATEST chain (`["ext-a","ext-b"]`) once `currentAnimationKind()` returns to `null` — this is a real assertion of the fix's actual behavior, not a tautology. |
+| #2 test-gap | HIGH | 🧪 Test gap | **CLOSED** | 16 new tests across `shared-drill-bus.svelte.test.ts` (11 tests: `chainsEqual`, reducer idempotence incl. array-identity-vs-content, bidirectional-sync contract, echo-does-not-refire loop guard) and `iso-view-state.render.test.ts` (3 tests: root-ascend no-op, mid-animation convergence, post-convergence idempotence). Ran via `npx vitest run` — 16/16 pass, non-vacuous (real ordering assertions, real reference-identity checks, not `expect(true).toBe(true)`-style padding). The `.render.test.ts` split (dom/happy-dom project) vs `.test.ts` (node/unit project) is deliberate and documented — `$effect` is a no-op under the node transform, so the retry mechanism genuinely needs the browser-conditioned project to execute for real. |
+| #3 WebGL boundary | MEDIUM | 🐛 Bug | **CLOSED** | `IsoMapCorner.svelte:34-40` wraps `<mod.IsoMinimap />` in `<svelte:boundary>` with a `failed` snippet rendering `"3D minimap unavailable"` — now catches a post-import render/mount failure (e.g. WebGL context creation failing inside `<Canvas>`), complementing the existing `{:catch}` for import-rejection. Degrades to the same UI state as the import-failure path; the flat 2D map stays unaffected either way. |
+| #4 doc/RFC drift (bucket of 4 sub-findings in EVID-100: #4 stale spike comment, #5 TODO(iso-promote) dedup, #6 phantom TODO(iso-draco-basis), #7 RFC Function-Signatures mismatch) | LOW–LOW/MED | 📚 Docs | **PARTIALLY CLOSED (3/4)** | Stale "throwaway spike" comment: **removed** (`IsoScene.svelte`). `TODO(iso-promote)` dedup: **done** — single canonical copy at `widgets/iso-map/index.ts:1-6`, all ~13 other files' copies stripped, `lib/motion.ts` now points at the canonical copy instead of repeating it. `TODO(iso-draco-basis)` marker: **added** at `template/vite.config.ts`'s alias definition, matching what RFC-036 already claimed existed. **RFC-036 Function-Signatures mismatch: NOT CLOSED.** `forgeplan_get RFC-036` shows the body unchanged since before the fix — the "Function Signatures / Component Contracts" section still documents `descend(zoneId)`, `ascend()`, `visibleDepth`/`setDepth(levels)`, `hidden`/`toggleVisible()` as `shared-drill-bus` methods. The shipped module (`shared-drill-bus.svelte.ts`) exports only `sharedFocusChain()`, `focusTo()` (renamed from `setSharedFocusChain` to match the RFC's name for that one function), and `chainsEqual()` — depth/visibility remain local-only state inside `iso-view-state.svelte.ts`, never on the bus, exactly as EVID-100 found. The fix adds a substantial new code comment (`shared-drill-bus.svelte.ts:16-38`) explaining the gap and stating "RFC-036's Function Signatures section still needs a follow-up edit to reflect this; that is Profile A/B territory (ADR/RFC ownership), not this coder change" — i.e. the drift is now *documented in code* but the actual forgeplan artifact other engineers/agents will read (RFC-036 itself) still overstates the implemented contract. |
+
+## Findings
+
+| # | Severity | Category | Location | Description | Recommended fix |
+|---|---|---|---|---|---|
+| 1 | LOW | 📚 Docs | `.forgeplan/rfcs/RFC-036-*.md` §"Function Signatures / Component Contracts" vs. `template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts:41-90` | Carried forward from EVID-100 Finding #7, only partially addressed: the RFC still documents `descend()`, `ascend()`, `visibleDepth`/`setDepth()`, `hidden`/`toggleVisible()` as bus methods; only `focusTo`/`sharedFocusChain` exist. The code now explains the gap in a comment but the RFC document itself was never edited, so the artifact remains an inaccurate contract reference for any future reader (including another agent scoping graduation work off the RFC). | Dispatch a Profile A/D agent (`adr-architect` or `artifact-maintainer`) to update RFC-036's Function Signatures section via `forgeplan_update` to reflect the actual 3-function bus contract, noting depth/visibility are intentionally local-only — the shared-drill-bus.svelte.ts comment already states the correct content, it just needs to land in the RFC body. |
+
+## Positive observations
+
+- The `pendingExternal` retry mechanism is a clean, minimal fix for a genuinely subtle race: it reuses the existing `animationKind` state as the single trigger condition, stores at most one pending target (not a queue — correctly modeling "always converge to latest," not "replay every intermediate step"), and is proven idempotent by test (`is idempotent once converged` — no animation, no state churn on a no-op reconciliation).
+- The test split between `.test.ts` (node/unit) and `.render.test.ts` (dom/happy-dom) is a well-reasoned, explicitly-documented engineering call — the comment block in both files states *why* `$effect` needs the browser-conditioned project, backed by an empirical claim ("verified empirically: a minimal `$effect.root` repro in 'unit' never ran its effect body"). This is exactly the kind of test-infrastructure judgment that prevents a future contributor from "fixing" the split by merging the files and silently losing coverage of the real mechanism.
+- The `shared-drill-bus.svelte.ts` comment explaining the RFC/code naming and scope mismatch (lines 16-38) is honest and precise about what it does NOT do ("that is Profile A/B territory... not this coder change") — this is the right instinct (a Profile C-coder correctly declining to touch a forgeplan artifact), it just means the loop isn't closed yet and needs an explicit follow-up dispatch rather than being silently treated as done.
+
+## Test coverage delta
+
+- Before (EVID-100): 0% — zero test files for `shared-drill-bus.svelte.ts` or `iso-view-state.svelte.ts`'s external-sync path
+- After: 16 new tests across 2 files — reducer idempotence, bidirectional-sync contract, echo-loop-guard (11 tests), mid-animation convergence + post-convergence idempotence (3 tests) + root-ascend no-op (1 test) in the render suite
+- Branches gained: sync-drop-race retry path (Finding #1's exact failure mode), bus reducer idempotence, cross-reader single-source-of-truth
+- Branches still uncovered: `IsoMapCorner`'s new `<svelte:boundary>` `failed` path (no test forces a render-time WebGL failure to confirm the boundary actually degrades — Finding #3's fix is verified by code-reading, not by an automated failure-injection test, matching RFC-036's own "Honest-fallback failure injection" Test Strategy Hook which remains unautomated)
+
+## Next steps
+
+- Dispatch a Profile A/D agent to close the one remaining item: update RFC-036's Function Signatures section (via `forgeplan_update`, not direct file edit) to match the shipped 3-function `shared-drill-bus` contract.
+- Optional, not blocking: an automated failure-injection test for `IsoMapCorner`'s new `<svelte:boundary>` (force a WebGL init throw and assert the `failed` snippet renders) would close RFC-036's own "Honest-fallback failure injection" Test Strategy Hook, currently verified only by code inspection.
+- Once the RFC update lands, this is ready for the `guardian` pre-activation gate — no functional blockers remain; full test suite (798/798) and build (3.29M/3.5M cap) are green.
+
+## Structured Fields
+
+verdict: weakens
+congruence_level: 3
+evidence_type: audit
+
+## References
+
+- Parent: RFC-036 (`based_on` PRD-039), companion ADR-011
+- Supersedes-in-spirit: EVID-100 (this re-review confirms 3 of its 4 findings closed; the 4th — RFC/code drift on Function Signatures — remains open under a narrower scope than EVID-100 originally found, since 3 of its 4 sub-items are now closed)
+- Related ADR: ADR-011 (ship three.js+Threlte lazy chunk; cap 3→3.5 MiB) — this review's build check reconfirms the cap holds (3.29M/3.5M) and the SSR three-exclusion invariant still holds after the fix commits
+
+
+
diff --git a/.forgeplan/evidence/EVID-102-guardian-gate-review-of-prd-039-adr-011-rfc-036-3d-iso-map-chain-concerns.md b/.forgeplan/evidence/EVID-102-guardian-gate-review-of-prd-039-adr-011-rfc-036-3d-iso-map-chain-concerns.md
new file mode 100644
index 0000000..504fad8
--- /dev/null
+++ b/.forgeplan/evidence/EVID-102-guardian-gate-review-of-prd-039-adr-011-rfc-036-3d-iso-map-chain-concerns.md
@@ -0,0 +1,136 @@
+---
+depth: standard
+id: EVID-102
+kind: evidence
+last_modified_at: 2026-07-08T10:42:02.046721+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: PRD-039
+  relation: informs
+- target: ADR-011
+  relation: informs
+- target: RFC-036
+  relation: informs
+status: draft
+title: 'Guardian gate review of PRD-039/ADR-011/RFC-036 (3D iso-map chain): CONCERNS'
+---
+
+## Verdict
+
+**CONCERNS**
+
+- **PASS** — orchestrator may activate. *(not this)*
+- **CONCERNS** — orchestrator must dispatch the named fixers/reviewers, land their EVIDENCE, then re-run `guardian` before activation. **(THIS VERDICT)**
+- **BLOCKER** — halt. *(not this — nothing is broken; foundation is sound and reversible)*
+
+One-line justification: every prior finding (#1 sync-drop race, #2 test-gap, #3 WebGL boundary, #4 RFC/code drift) is **genuinely closed** — verified in the actual fix code + 16 passing non-vacuous sync tests + the reconciled RFC body, with build/cap/svelte-check/SSR-exclusion all measured green — but the chain carries **zero terminal PASS EVIDENCE** and **two of PRD-039's own ship-gate acceptance criteria are never verified by any EVID**: AC-5's rule-22 governance half and AC-1/AC-3 + FR-005's browser render-proof / on-demand-load network trace (the latter is the exact "load-bearing gate" a prior guardian pass, EVID-086, refused to waive for this same composed-map arc).
+
+## Artifacts under review
+
+- **PRD-039** — `prd`, status `draft`, R_eff **0.30** (live score; grade B) — "3D isometric layered overview minimap for the composed-map view". Parent lineage: PRD-036 (`based_on`), EPIC-001 T4.
+- **ADR-011** — `adr`, status `draft`, R_eff **0.70** (live score; grade B) — "Ship three.js+Threlte lazy client chunk; raise per-image dist cap 3 → 3.5 MiB". `based_on` PRD-039/036, `informs` PRD-030.
+- **RFC-036** — `rfc`, status `draft`, R_eff **0.30** (live score; grade B) — "Lazy 3D iso-map widget, 2D-synced via a three-free shared-drill-bus". `based_on` PRD-039, `refines` ADR-011, `informs` SPEC-006.
+
+> **R_eff note (correction of a stale field).** `forgeplan_get` returned `r_eff_score: 0.0` for ADR-011 and RFC-036 (a stale cached field). The live `forgeplan_score` recomputation returns **0.70 / 0.30 / 0.30** — all **> 0**, so the CLAUDE.md Red-Line-3 / rule-11 "no activation at R_eff==0" gate is **NOT** tripped. My `forgeplan_score` calls should have refreshed the persisted values; the orchestrator should confirm `forgeplan_score` ≥ 0 immediately before `forgeplan_activate`.
+
+## EVIDENCE chain inspected (chronological)
+
+| EVID | Body verdict | Structured `verdict` (R_eff) | Source role | Critical findings (one-line) |
+|---|---|---|---|---|
+| `EVID-099` | CONCERNS | supports · CL3 · measurement (score 1.0) | tester | Build PASS 3.29 MiB < 3.5 cap (both images); svelte-check 0; vitest 782/782; SSR three-free (0 markers in `dist/index.js`); 808 KiB lazy chunk. Flagged AC-1/AC-3 (UI) + AC-5 governance half **not run**; AC-2 unit tests **absent at the time**. Ground-truth: DELTA=PRESENT, tokens FOUND. |
+| `EVID-100` | CONCERNS | weakens · CL3 · audit (score 0.5) | code-reviewer | 7 findings: #1 HIGH sync-drop race, #2 HIGH zero-tests, #3 MED WebGL-init-not-caught, #4–7 doc/RFC drift. three-leak flag refuted as false positive. Ground-truth: DELTA=PRESENT, `shared-drill-bus` token FOUND, SSR grep 0. |
+| `EVID-101` | CONCERNS | weakens · CL3 · audit (score 0.5) | code-reviewer (re-review) | #1/#2/#3 **CLOSED non-vacuously** (pendingExternal retry + `<svelte:boundary>` + 16 passing tests, full suite 798/798); #4 doc-drift **3/4 closed**, RFC Function-Signatures item still open **at time of writing (10:16)**. Ground-truth: DELTA=PRESENT, `pendingExternal`/`svelte:boundary`/test-files FOUND. |
+
+No superseding EVID exists, but the single open item in the latest EVID (EVID-101 Finding #1 — RFC Function-Signatures drift) was closed by a **later artifact edit**: RFC-036 `updated_at 2026-07-08T10:31` — **15 min after** EVID-101 (10:16). I verified against the **current** RFC body (generator≠verifier): its Function-Signatures section now documents exactly `sharedFocusChain()/focusTo()/chainsEqual()` and states descend/ascend are consumer-level and depth/visibility are local — the stale `descend()/ascend()/setDepth()/toggleVisible()` bus API is **gone**. Finding #4 is therefore closed at both code and doc level.
+
+**Chain state: 3 EVIDs — 0 BLOCKER, 3 CONCERNS, 0 PASS.**
+
+## Independent verification (generator≠verifier — I checked the code + ran tests, not the prose)
+
+| Claim | Method | Result |
+|---|---|---|
+| #1 sync-drop race fixed | `grep pendingExternal / $effect.root` in `iso-view-state.svelte.ts` | ✅ `pendingExternal` slot (l.127) + `$effect.root` watcher (l.134-138) re-applies on `animationKind` settle; `applyExternalFocusChain` (l.443-448) records instead of dropping |
+| #3 WebGL boundary | read `IsoMapCorner.svelte` | ✅ `<svelte:boundary>` + `{#snippet failed()}` wrapping `<mod.IsoMinimap/>` (l.39-44); browser-guarded dynamic `import()` (l.22) |
+| #2 test-gap | `find … *.test.*` | ✅ `shared-drill-bus.svelte.test.ts` + `iso-view-state.render.test.ts` present on disk |
+| #2 tests pass + non-vacuous | `npx vitest run shared-drill-bus iso-view-state.render` | ✅ **2 files, 16/16 passed**; assertions test content-equality, idempotence via array-ref identity, single-source-of-truth, echo-loop-guard — not tautological |
+| #4 RFC/code contract match | `grep export … shared-drill-bus.svelte.ts` | ✅ exports exactly `sharedFocusChain / chainsEqual / focusTo`; **zero** stale `descend/ascend/setDepth/toggleVisible/setSharedFocusChain` |
+| Dist under cap | `find dist* -stat` byte sum | ✅ dist 3.28 MiB, dist-nightly 3.28 MiB — both < 3.5 MiB cap (3,670,016 B); ADR-011 metric revisit trigger NOT fired |
+| rule-22 client surface | `grep spawn/fetch/write` new widget code | ✅ only 1 `fetch()` — a **GET** to existing read-only `/api/map/layers/<zone>` (encodeURIComponent'd); no new endpoint / spawn / mutation / external net |
+
+## Gate criteria
+
+| # | Criterion | Status | Notes |
+|---|---|---|---|
+| 1 | Artifact MUST validation (all 3) | ✅ | `forgeplan_validate` PASS, 0 MUST errors each. SHOULD `no-placeholders` warnings on ADR-011/RFC-036 are the **intentional** `TODO(iso-adr)`/`TODO(iso-promote)`/`TODO(iso-draco-basis)` code-marker references — accurate, not stubs. |
+| 2 | Required reviewer EVIDENCE linked | ⚠️ | tester + code-review + re-review present; **no governance/security EVID (rule-22, AC-5) and no render-proof EVID (AC-1/AC-3/FR-005 dynamic)** — both are PRD-039 ship-gates. |
+| 3 | No BLOCKER in chain | ✅ | Zero BLOCKER verdicts; all HIGH/MED findings verified closed. |
+| 4 | Unresolved HIGH-severity CONCERNS | ✅ (0) | #1/#2 HIGH → CLOSED; #3 MED → CLOSED; #4 doc → CLOSED via RFC edit. |
+| 5 | Activation policy satisfied | ⚠️ | R_eff>0 ✅; ADI on ADR-011 sound (3 options, F+G+R=20≥14) ✅; but PRD-039's own AC-1/AC-5 verifications are unrecorded. |
+| 6 | Project-specific gates | ✅ | build/cap/svelte-check/SSR-exclusion independently confirmed. |
+| 7 | Blast radius within stated threshold | ✅ | see below — matches artifacts' "additive, read-only, reversible" claims. |
+| 4b | Linked-ADR Revisit Triggers | ✅ | ADR-011's own triggers: metric (image>3.5MiB) NOT fired (3.28 MiB); event (three dropped) NOT fired (present); date 2027-01-08 in future. No FIRED/DATE-FIRED. No `mm-gate-failures` needed. |
+
+### Project-config gates (`.forgeplan/project-config.yaml` **absent** → HARD-RULE-7 conservative defaults applied)
+
+Config source: **not found — built-in defaults applied** (`config.yaml` exists but has no `quality_gates` key).
+
+| Criterion | Threshold (default) | Observed | Result |
+|---|---|---|---|
+| Test coverage | ≥80% (`min_test_coverage`) | **not measured** (tester reported 782/798 pass counts, not %) | ⚠️ unverifiable (informational — the load-bearing sync contract IS tested) |
+| Critical findings | ≤0 (`max_findings_critical`) | 0 | ✅ |
+| High findings | ≤3 (`max_findings_high`) | 2 (both closed; 0 unresolved) | ✅ |
+| Medium findings | ≤10 (`max_findings_medium`) | 1 (closed; 0 unresolved) | ✅ |
+| Validate pass | required (`require_validate_pass`) | 3/3 PASS | ✅ |
+| Audit pass (≥1 Profile B EVID with body-verdict PASS) | required (`require_audit_pass`) | **0 PASS** (all 3 CONCERNS) | ⚠️ **CONCERNS** |
+| Evidence chain | required for prd/rfc/adr | 3 EVIDs linked (but 2 reviewer classes missing — crit.2) | ⚠️ |
+
+**Gates summary: 5/7 green** (source: defaults). Not-green: **audit-pass** (no terminal PASS EVID) and **coverage** (unmeasured). The BMAD-discipline "zero-PASS → BLOCKER" row is **not** applied — this is a SPARC feature gate on an existing system, not a BMAD greenfield sub-cycle; the general `require_audit_pass → CONCERNS` interpretation governs, consistent with this project's own precedent (EVID-086 issued CONCERNS + fast-follow for a comparable render-proof gap, not BLOCKER).
+
+## Blast radius
+
+- **Affected scope on activation:** the read-only forgeplan-web **viewer** (client-side), Map view only. The 3D overview replaces the flat 2D minimap in the Map view's corner **only**; every other view + its 2D minimap is byte-unchanged (FR-006, verified additive by EVID-100 rule-24 grep clean). No production data path, no host mutation.
+- **Reversibility:** **fully reversible by design** — ADR-011 + RFC-036 both carry a 4–5-step rollback (drop the `IsoMapCorner` dynamic import → 2D fallback; delete widget+bus; revert cap commit `a6ef030`; drop `three`/`@threlte` deps). The prior "Force 3D" revert (`7f907dd`) proves the pattern is clean. Not a one-way door.
+- **Server / governance surface:** the new widget adds exactly **one** call site — a client `fetch()` GET to the **existing** read-only `/api/map/layers/<zone>` endpoint. **Zero** new endpoints, spawn, write, or external network in the new code. Rule-22 risk is low — but **not formally recorded in an EVID** (the gap below).
+- **Packaging:** +~808 KiB irreducible `three` chunk (lazy). Both images at 3.28 MiB, ~360 KiB margin under the raised 3.5 MiB cap. The cap is a real +0.5 MiB governance-slack widening (ADR-011 DD-5/INV-3 acknowledges it; residual editorial drift in PRD-030/rule-21 text is a tracked fix-forward, not a blocker).
+- **Downstream artifacts:** ADR-011 `informs` PRD-030's cap NFR (amends, does not supersede); RFC-036 `refines` ADR-011; the shared-drill-bus contends with PRD-038's onboarding-tour camera (RFC-036 R-6 / PRD-039 Q4 — flagged **unresolved**, tracked, not silently assumed).
+- **Threshold check:** actual blast radius (additive, read-only, Map-view-scoped, reversible) **matches** the artifacts' stated claims — no scope broadening. This criterion does not itself downgrade the verdict.
+
+## Why CONCERNS, not PASS (the three unmet gaps — all cheap to close)
+
+1. **No terminal PASS EVIDENCE (`require_audit_pass` unmet).** All 3 EVIDs are CONCERNS. The closures were confirmed by EVID-101 (itself CONCERNS due to the then-open RFC drift, now closed by the 10:31 edit), but **no fresh Profile B EVID recorded a clean PASS after the final closure**.
+2. **AC-5 governance half never verified (rule-22 / NFR-006).** PRD-039 makes "rule-22 greps report 0 new endpoints and 0 spawn/write/network call sites" a ship-gate. No security/governance EVID exists. My blast-radius spot-check suggests low real risk (1 read-only GET), but a **recorded** rule-22 pass over the server `/api/*` + `shared/server` surface is required to close AC-5 honestly.
+3. **AC-1/AC-3 + FR-005 dynamic browser render-proof never captured.** Map-view-only render (AC-1), depth control/toggle (AC-3), and the on-demand-load network trace (chunk absent on non-Map view / fetched on Map-open — NFR-002) rest on **one manual dev observation** (EVID-100, explicitly recorded as "manual, NOT a regression guard") + structural chunk analysis. `memory_recall` surfaced the directly-relevant precedent: **EVID-086** (prior guardian pass on this same composed-map arc) named the missing browser render-proof the single "load-bearing Phase-1 gate" and would not waive it. Waiving it here is the "drift accepted as good enough" failure guardian exists to prevent.
+
+## Orchestrator instructions
+
+**CONCERNS → do NOT activate yet. Dispatch the following, land their EVIDENCE, then re-run `guardian`:**
+
+1. **Dispatch `agents-pro:security-expert`** (or a rule-22 grep pass) to verify PRD-039 AC-5 / NFR-006: 0 new `/api/*` endpoints, 0 spawn/write/network call sites, the overview reads only existing GET-only `/api/map` + `/api/map/layers/<zone>`. → record as a Profile B EVID (`informs` PRD-039). *(Expected clean — my spot-check found 1 read-only GET — but it must be recorded, not inferred.)*
+2. **Dispatch `agents-core:tester`** for a Playwright/browser render-proof capturing PRD-039 AC-1 (Map-view-only 3D render; every other view's 2D minimap unchanged), AC-3 (depth 1/2/3 + ascend + show/hide toggle), and FR-005/NFR-002 (network/asset trace: 3D chunk **absent** on non-Map view load, **fetched** only on Map-view open). → record as a Profile B EVID (`informs` PRD-039).
+3. **Optional but recommended (closes `require_audit_pass`):** a short Profile B re-review recording a clean **PASS** now that #1–#4 are all closed and RFC-036 is reconciled — this converts the chain from all-CONCERNS to having a terminal PASS.
+4. **Then re-run `guardian`.** With items 1–2 (and ideally 3) landed, the chain has no remaining gaps and is activatable.
+
+**Incremental option (secondary, orchestrator's call):** **ADR-011** alone is evidence-sufficient for its own decision — its cap bump (3 → 3.5 MiB) is empirically verified (build 3.28 MiB < 3.5, SSR three-free, lazy chunk, R_eff 0.70, ADI F+G+R=20, no revisit trigger fired), and EVID-099 itself states its measurements "can support activating ADR-011 specifically." If the orchestrator wants to unblock the cap decision (already applied in code as `a6ef030`) ahead of the UI work, ADR-011 could be activated first, with **PRD-039 + RFC-036 held in draft** pending items 1–2. Cleaner path is to close 1–2 and activate all three together.
+
+## Notes
+
+- `mm-gate-failures` mental model: **not present (HTTP 404)** — recorded honestly per HARD RULE 6; `memory_recall` still surfaced the load-bearing precedent (EVID-086 render-proof gate; EVID-082/083 zero-coverage silent-miss) which directly informed gap #3.
+- No project-config.yaml → conservative defaults (HARD RULE 7). No claim collision: only PRD-038 held a (stale, expired 2026-07-06) claim — not on this chain.
+- Residual tracked risks the orchestrator should carry even after activation: PRD-039 Q4 / RFC-036 R-6 (focus-chain vs PRD-038 onboarding-camera hand-off, unresolved); the load-bearing draco/basis vite stub (RFC-036 R-4, `TODO(iso-draco-basis)`); PRD-030/rule-21 editorial cap-text drift (3 → 3.5 MiB fix-forward).
+
+## References
+
+- Artifacts under review: PRD-039, ADR-011, RFC-036
+- EVIDENCE chain: EVID-099, EVID-100, EVID-101
+- Mental models consulted: `mm-gate-failures` (absent — 404); memory_recall surfaced EVID-086 / EVID-082 / EVID-083
+- Independent runs: `npx vitest run shared-drill-bus iso-view-state.render` (16/16 pass); code greps of `iso-view-state.svelte.ts` / `IsoMapCorner.svelte` / `shared-drill-bus.svelte.ts`; `find dist* -stat` size sum
+
+## Structured Fields
+
+verdict: supports
+congruence_level: 3
+evidence_type: audit
+
+
+
+
diff --git a/.forgeplan/evidence/EVID-103-browser-render-proof-on-demand-load-evidence-for-prd-039-3d-iso-map-supports.md b/.forgeplan/evidence/EVID-103-browser-render-proof-on-demand-load-evidence-for-prd-039-3d-iso-map-supports.md
new file mode 100644
index 0000000..93667ad
--- /dev/null
+++ b/.forgeplan/evidence/EVID-103-browser-render-proof-on-demand-load-evidence-for-prd-039-3d-iso-map-supports.md
@@ -0,0 +1,163 @@
+---
+depth: standard
+id: EVID-103
+kind: evidence
+last_modified_at: 2026-07-08T10:59:39.935784+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: PRD-039
+  relation: informs
+status: draft
+title: 'Browser render-proof + on-demand-load evidence for PRD-039 3D iso-map: supports'
+---
+
+## Verdict
+
+**PASS** | **SUPPORTS** (assigned by orchestrator — see note below on partial AC coverage)
+
+One-line summary: Live dev-server Playwright capture confirms the 3D isometric minimap renders in the Map view's corner alongside the unchanged 2D composed-map (AC-1, render half), confirms bidirectional 3D↔2D drill sync in both directions (AC-2/FR-003), and confirms the 3D render chunk loads strictly on-demand after the main app, triggered by the Map-view mount (FR-005/NFR-002) — with zero iso-feature console errors. This capture does **not** demonstrate PRD-039's AC-3 (depth-control 1/2/3 + ascend + show/hide-toggle *interaction*) or the "every other view's 2D minimap is unchanged" half of AC-1 — both remain open gaps, flagged below rather than silently claimed closed.
+
+Assigned verdict fields (per orchestrator directive): `verdict: supports`, `congruence_level: 3`, `evidence_type: test` — recorded faithfully in Structured Fields below. This EVID does not itself judge PRD-039's overall readiness; it records what this specific capture did and did not demonstrate, for the guardian re-run EVID-102 called for.
+
+## Ground-truth verification
+
+- Base..head: `54a905c862b542f14a2c5929aa44f450c63ffd21..3e948dd6785c0eaa366395c062366f14e045a9e3` (source: `git merge-base feat/idef0-3d-iso-view develop` .. `git rev-parse HEAD` on branch `feat/idef0-3d-iso-view`)
+- Diff probe: `git diff --stat 54a905c8..3e948dd6`
+- Diff state: **DELTA=PRESENT** (232 files changed, 58048 insertions(+), 260 deletions(-))
+- Expected delta token: the iso-map widget source tree + its on-demand dynamic-import wiring (claim under test: "the 3D minimap widget exists and loads on demand")
+- Token probe 1: `git diff --stat 54a905c8..3e948dd6 | grep widgets/iso-map` → **FOUND** — `IsoMinimap.svelte` (219 lines), `IsoScene.svelte`, `IsoPlane.svelte` (154), `IsoFrustum.svelte`, `IsoZoneFrame.svelte` (82), `IsoControls.svelte` (63), `IsoNodeBox.svelte`, `IsoNodeCard.svelte`, `iso-view-state.svelte.ts` (678), `iso-view-state.render.test.ts` (160), `leader-line.ts`, `motion.ts`, plus `vite.config.ts` (+62/-?) and `vite/stubs/three-loaders.ts` (20) for the build-time code-split wiring.
+- Token probe 2: `grep -n "import('@/widgets/iso-map')" template/src/widgets/dependency-graph/ui/IsoMapCorner.svelte` → **FOUND** at line 22: `const isoMapModule = browser ? import('@/widgets/iso-map') : null;` — a browser-guarded dynamic `import()`, the literal on-demand-load mechanism FR-005 claims.
+- Verdict floor from ground-truth gate: **PASS-eligible** (delta present, expected tokens found — the feature branch's code backs the observed behavior; this is not a vacuous-green claim).
+
+```
+$ git rev-parse HEAD
+3e948dd6785c0eaa366395c062366f14e045a9e3
+
+$ git merge-base feat/idef0-3d-iso-view develop
+54a905c862b542f14a2c5929aa44f450c63ffd21
+
+$ git diff --stat 54a905c8..3e948dd6   (relevant lines only, full stat: 232 files, +58048/-260)
+ template/src/widgets/iso-map/lib/leader-line.ts    |   36 +
+ template/src/widgets/iso-map/lib/motion.ts         |   14 +
+ .../iso-map/model/iso-view-state.render.test.ts    |  160 +
+ .../widgets/iso-map/model/iso-view-state.svelte.ts |  678 +++
+ template/src/widgets/iso-map/ui/IsoA11yProxy.svelte     |   76 +
+ template/src/widgets/iso-map/ui/IsoControls.svelte      |   63 +
+ template/src/widgets/iso-map/ui/IsoDeeperMarker.svelte  |   52 +
+ template/src/widgets/iso-map/ui/IsoFrustum.svelte       |   43 +
+ template/src/widgets/iso-map/ui/IsoIcomArrows.svelte    |   61 +
+ template/src/widgets/iso-map/ui/IsoLayerCard.svelte     |   97 +
+ template/src/widgets/iso-map/ui/IsoLeaderLine.svelte    |  129 +
+ template/src/widgets/iso-map/ui/IsoMinimap.svelte       |  219 +
+ template/src/widgets/iso-map/ui/IsoNodeBox.svelte       |   60 +
+ template/src/widgets/iso-map/ui/IsoNodeCard.svelte      |  138 +
+ template/src/widgets/iso-map/ui/IsoPlane.svelte         |  154 +
+ template/src/widgets/iso-map/ui/IsoSliverPlane.svelte   |   26 +
+ template/src/widgets/iso-map/ui/IsoZoneFrame.svelte     |   82 +
+ template/vite.config.ts                            |   62 +-
+ template/vite/stubs/three-loaders.ts               |   20 +
+
+$ grep -n "import('@/widgets/iso-map')" template/src/widgets/dependency-graph/ui/IsoMapCorner.svelte
+22:  const isoMapModule = browser ? import('@/widgets/iso-map') : null;
+```
+
+## Evidence type
+
+🧪 Manual QA
+
+(One-shot Playwright browser capture against the dev server — explicitly NOT an automated regression guard, per the environment caveat below.)
+
+## Raw input provenance
+
+- Source: orchestrator-performed live Playwright capture against the dev server (`FORGEPLAN_CWD=<repo>`, port 5174, Map view = default 9th graph view), branch `feat/idef0-3d-iso-view` @ `3e948dd6785c0eaa366395c062366f14e045a9e3`. Handed to this agent as orchestrator-inline text (OBSERVED section of the dispatch prompt) plus 4 screenshot artifacts on disk.
+- Screenshots (fingerprinted directly by this agent via `shasum -a 256` + `file`, not taken on the orchestrator's word):
+
+| File | Size | SHA-256 | Format | mtime |
+|---|---|---|---|---|
+| `render-proof-map-corner.png` | 127,025 B | `dc320b457892b7f00ea2173943b0cea44eabdd903f33abfc1b3429de6374bd8` | PNG 1400×1000 RGB | 2026-07-08 13:45 |
+| `sync-before.png` | 158,957 B | `f783b9ce4d2ce5ebbf78ca77ad55b52af21e7e4d6d1367a88673916f28d10c9` | PNG 1400×1000 RGB | 2026-07-08 03:47 |
+| `sync-after-3dclick.png` | 128,952 B | `54506411ba252cbdc6ede60f33139c480f08564eafbbdeaf470555775d7be5c` | PNG 1400×1000 RGB | 2026-07-08 03:48 |
+| `sync-2d-reset.png` | 160,548 B | `3401e5c840652a3b821a5510629b6a946463e7443bb291ea25a921a70bf896` | PNG 1400×1000 RGB | 2026-07-08 03:49 |
+
+All 4 paths resolved and read directly from `/Users/explosovebit/Work/ForgePlanWeb/` — none missing, none zero-byte, all valid PNG per `file`(1).
+- Network trace: reported verbatim by the orchestrator as request-order positions (#491–518 of ~518 total) — this agent did **not** independently re-run the capture (out of scope for a recording pass; the trace is consistent with the code-level on-demand `import()` wiring confirmed above, which *is* independently verified).
+- Captured at: 2026-07-08 (dev-server session; screenshot mtimes above span 03:47–13:45 UTC-adjacent local time, i.e. two capture passes — an earlier sync-proof pass and a later corner-render-proof pass, both same-day, same branch head-adjacent).
+- Captured by: orchestrator (live Playwright browser driving), relayed to this agent (evidence-recorder) for structuring per HARD RULE ("orchestrator performed the live capture; you structure it faithfully").
+
+## Raw input (orchestrator's OBSERVED dispatch text, truncated to ≤2000 chars)
+
+```
+Render: the Map view shows the 2D composed-map UNCHANGED plus the 3D isometric minimap
+rendering in the bottom-right corner (stacked isometric planes, node boxes, orange zone
+frames, the depth control "1/2/3 + ascend" + a "⋯" show/hide toggle). Screenshot:
+render-proof-map-corner.png. Prior-capture screenshots also on disk proving the 3D<->2D
+bidirectional sync live: sync-before.png (root), sync-after-3dclick.png (a 3D corner
+zone-click descended the 2D map into "Decision Trail", 2D breadcrumb "All > Decision
+Trail"), sync-2d-reset.png (clicking 2D "All" reset the 3D corner to root) -- both sync
+directions confirmed with 0 iso-feature console errors.
+
+On-demand load (FR-005), network trace verbatim -- the iso widget + 3D libs load LATE
+(requests #491-518 of ~518, i.e. after the main app, triggered by the Map-view mount, NOT
+in the initial page load): GET /src/widgets/iso-map/index.ts (#491), GET
+/src/widgets/iso-map/ui/IsoMinimap.svelte (#493), GET
+/node_modules/.vite/deps/@threlte_core.js (#494), GET
+/node_modules/.vite/deps/three.module-*.js (#502), GET
+/node_modules/.vite/deps/@threlte_extras.js (#503), GET
+/node_modules/.vite/deps/three.js (#518), plus all IsoScene/IsoPlane/IsoFrustum/etc.
+component + lib modules (#495-517) -- all 200 OK, all in that late on-demand burst. This
+is the dev-mode manifestation of the production lazy code-split (the built 808 KiB three
+chunk EVID-099 measured).
+
+Console: the ONLY error observed was GET /api/score 400 -- a test-environment artifact of
+the orchestrator's score-cascade suppression guard (unrelated to the iso feature; the
+dashboard's score-poll, not iso code). NO iso-feature / WebGL / three error.
+
+Environment caveat: this is a DEV-server manual capture, a one-shot render-proof (not an
+automated regression guard); production code-split size is separately measured in
+EVID-099.
+```
+
+## Structured findings
+
+**🧪 Manual QA scenario table:**
+
+| # | Scenario | Steps | Observed | Expected | Pass/fail |
+|---|---|---|---|---|---|
+| 1 | Map-view 3D-corner render (AC-1, render half) | Open dev server; navigate to Map view (default 9th graph view) | 2D composed-map renders unchanged; 3D isometric minimap renders in bottom-right corner — stacked isometric planes, node boxes, orange zone frames, depth control "1/2/3 + ascend", "⋯" show/hide toggle. Screenshot `render-proof-map-corner.png` (sha256 above) | 3D overview appears in the Map-view corner, 2D map unaffected (FR-001/FR-002) | **PASS** |
+| 2 | 3D-corner click → 2D descend sync (AC-2, FR-003) | From root (`sync-before.png`), click a zone in the 3D corner minimap | 2D map descended into "Decision Trail"; 2D breadcrumb reads "All › Decision Trail". Screenshot `sync-after-3dclick.png` | Clicking the 3D overview drives the flat 2D map to the same focus | **PASS** |
+| 3 | 2D "All" click → 3D reset sync (AC-2, FR-003) | Click the 2D breadcrumb "All" | 3D corner reset to root focus. Screenshot `sync-2d-reset.png` | Ascending/resetting in the flat 2D map drives the 3D overview to match | **PASS** |
+| 4 | On-demand chunk load (FR-005 / NFR-002) | Capture full network request log across dev-server page load + Map-view mount | iso-map widget + `@threlte`/`three` deps requested at #491–518 of ~518 total — strictly after the main app load, triggered by Map-view mount, absent from the initial bundle. All 200 OK. | 3D chunk fetched only on Map-view open, not at initial page load | **PASS** |
+| 5 | Console cleanliness during scenarios 1–4 | Observe browser console throughout | Only `GET /api/score 400` (known score-cascade-suppression test artifact, unrelated to iso feature — the dashboard's own score-poll). Zero iso-feature/WebGL/three errors. | No iso-feature console errors | **PASS** |
+| 6 | AC-3 — depth control (1/2/3) + ascend + show/hide toggle *interaction* | **NOT PERFORMED** in this capture | Depth control and toggle are visibly present in the render-proof screenshot (scenario 1) but were not clicked/exercised; no before/after screenshot or state change was captured for switching depth levels, the ascend action, or hiding/showing the overview | Selecting depth 1/2/3 changes visible level count; ascend climbs one level on both surfaces; toggle hides then restores the overview (PRD-039 AC-3 / FR-004) | **NOT TESTED — gap, not a failure** |
+| 7 | AC-1 — "every other view's 2D minimap unchanged" half | **NOT PERFORMED** in this capture | Only the Map view was visited in this session; no other view id (list/graph/tree/timeline/etc.) was opened to confirm its 2D minimap is byte-unchanged | Every non-Map view's 2D minimap renders identically to the base branch (FR-001 second clause) | **NOT TESTED — gap, not a failure** |
+
+**Coverage vs PRD-039 acceptance criteria (reconciling the dispatch prompt's AC labels against the actual PRD-039 body, fetched directly via `forgeplan_get` for this EVID):**
+
+- **AC-1 (render, Map-view-only; FR-001/FR-002)** — **PARTIALLY closed.** The Map-view-corner-render half is demonstrated (scenario 1). The "every other view's 2D minimap unchanged" half is **not** exercised in this capture (scenario 7).
+- **AC-2 (bidirectional drill sync; FR-003)** — **closed** by scenarios 2–3 (both directions demonstrated, screenshots on disk, 0 console errors). Note: the orchestrator's dispatch prompt labeled this coverage "AC-3 (sync interaction)" — the actual PRD-039 body (re-read directly for this EVID) assigns bidirectional sync to **AC-2**, and reserves **AC-3** for the depth-control/toggle requirement (FR-004). This EVID records the **correct** AC number against the real artifact text rather than propagating the dispatch prompt's label, per the "record what was observed against the actual artifact" mandate.
+- **AC-3 (depth control 1/2/3 + ascend + show/hide toggle; FR-004)** — **NOT closed by this capture.** The controls are visibly rendered (scenario 1 screenshot shows "1/2/3 + ascend" and a "⋯" toggle) but no interaction with them was captured. This is exactly what guardian's prior pass (EVID-102, item 2 of its orchestrator instructions) asked to be captured — it remains open.
+- **FR-005 / NFR-002 (on-demand load)** — **closed** by scenario 4 (network trace) plus the independent code-level confirmation in Ground-truth verification above (the `browser ? import('@/widgets/iso-map') : null` dynamic import).
+- **NFR-003 (non-regression)** — not assessed by this capture beyond the Map view itself (see AC-1 gap above); `svelte-check`/`vitest` CI status is out of scope for a browser render-proof pass (covered separately by EVID-099/100/101).
+
+**Environment caveat (recorded honestly, not smoothed over):** this is a **dev-server manual capture** — a one-shot render-proof, not an automated regression guard. Production packaged-chunk size is separately measured in EVID-099 (3.28–3.29 MiB per image, under the 3.5 MiB ADR-011 cap). Re-running this exact scenario is not guarded by CI; a regression here would only be caught by another manual pass or a future Playwright test suite (none exists yet for the iso-map widget beyond the unit-level `iso-view-state.render.test.ts` / `shared-drill-bus.svelte.test.ts` referenced in EVID-100/101).
+
+## Recommended next steps
+
+- Dispatch a follow-up manual/Playwright pass (or this same agent-class) to capture **AC-3's actual interaction**: click each of depth 1/2/3, exercise ascend, and toggle show/hide — with before/after screenshots or DOM-state assertions, not just a static render showing the controls exist.
+- Capture the missing **AC-1 second half**: visit at least one non-Map view (e.g. `list` or `graph`) in the same session and confirm its 2D minimap is byte-identical to the base branch (screenshot or DOM diff).
+- Once both gaps close, re-run `guardian` on the PRD-039/ADR-011/RFC-036 chain (EVID-102's own instruction) — this EVID plus a landed rule-22/NFR-006 governance EVID (tracked separately, claimed in-flight by `claude-code/2.1.204/security-expert-task-prd039-nfr006` at the time this EVID was recorded) are the two items EVID-102 named before re-review.
+- Do **not** treat this EVID alone as sufficient to claim full AC-1/AC-3 closure in the guardian re-run — it closes AC-2 and FR-005/NFR-002 cleanly, and half of AC-1, but leaves AC-3 and AC-1's second half open.
+
+## References
+
+- Parent: `PRD-039`
+- Related EVIDENCE: `EVID-099` (build/cap/svelte-check/SSR measurement), `EVID-100` / `EVID-101` (code review + re-review of the sync/WebGL/test-gap findings), `EVID-102` (guardian gate CONCERNS — the artifact that named this exact render-proof gap as the "load-bearing" item, citing `EVID-086` as precedent on the PRD-036 arc)
+- Related ADR: `ADR-011` (lazy three.js/Threlte chunk, dist-cap raise 3→3.5 MiB — informed by, not by, this EVID)
+- Related RFC: `RFC-036` (lazy 3D iso-map widget, shared-drill-bus)
+
+## Structured Fields
+
+verdict: supports
+congruence_level: 3
+evidence_type: test
+
diff --git a/.forgeplan/evidence/EVID-104-security-governance-review-of-prd-039-3d-iso-map-ac-5-nfr-006-pass-rule-22-holds-0-new-server-network-surface.md b/.forgeplan/evidence/EVID-104-security-governance-review-of-prd-039-3d-iso-map-ac-5-nfr-006-pass-rule-22-holds-0-new-server-network-surface.md
new file mode 100644
index 0000000..50e8064
--- /dev/null
+++ b/.forgeplan/evidence/EVID-104-security-governance-review-of-prd-039-3d-iso-map-ac-5-nfr-006-pass-rule-22-holds-0-new-server-network-surface.md
@@ -0,0 +1,163 @@
+---
+depth: standard
+id: EVID-104
+kind: evidence
+last_modified_at: 2026-07-08T15:14:32.244286+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: PRD-039
+  relation: informs
+status: draft
+title: 'Security/governance review of PRD-039 (3D iso-map AC-5/NFR-006): PASS — rule-22 holds, 0 new server/network surface'
+---
+
+## Verdict
+
+**PASS**
+
+- **PASS** — no findings at or above Low attributable to this feature; PRD-039 AC-5 / NFR-006 (rule-22 read-only-proxy governance half) is satisfied on the security axis. Safe to activate on this axis.
+- CONCERNS — *(not this)*
+- BLOCKER — *(not this)*
+
+One-line justification: the 3D isometric map minimap is a purely client-side render of already-existing read-only map data — it touches **zero** server route / `shared/server` files, adds **zero** new endpoints, **zero** spawn/write/mutation call sites, and its only network access is one same-origin read-only **GET** to the pre-existing, already-rule-22-amended `/api/map/layers/<zone>` endpoint. `three.js`/`@threlte` are a client-only lazy chunk that never reaches the server. This EVID closes the AC-5 governance half that guardian gate **EVID-102** flagged as "recorded nowhere" (its orchestrator instruction #1).
+
+## Measurement (exactly what was checked)
+
+**Claim under test:** the 3D-iso-map feature adds NO new server or network attack surface; rule-22 (`/api/*` is a read-only forgeplan proxy) holds.
+
+**M1 — Did the iso feature touch any server route or `shared/server`?** (iso-scoped diff `f0ffeb7..HEAD`)
+```
+$ git diff --name-status f0ffeb7..3e948dd -- template/src/routes/api/ template/src/shared/server/
+(no output — EMPTY)
+
+$ git log --oneline 54a905c..HEAD -- template/src/routes/api/map/ template/src/shared/server/map.ts
+e9c21b5 feat(idef0): E3 seam — render map-pack generated layers on descend
+b64fd09 feat(idef0): composed-map Phase-1 core — entity, validator, layout, API
+```
+→ The iso feature touched **no** server file. `/api/map`, `/api/map/layers/[zone]`, and `shared/server/map.ts` were added by the **earlier** composed-map commits `b64fd09` / `e9c21b5` (PRD-036 / PRD-038 FR-002) and are already rule-22-amended in `.claude/rules/22-readonly-proxy.md`.
+
+**M2 — Rule-22 sink grep over the new client widget + shared bus** (the exact grep the dispatch asked for):
+```
+$ grep -RInE "spawn|execFile|fetch\(|writeFileSync|POST|PUT|DELETE" \
+      template/src/widgets/iso-map/ \
+      template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts
+iso-map/model/iso-view-state.render.test.ts:50: // ...no per-zone layer `fetch()` is   (test comment)
+iso-map/model/iso-view-state.svelte.ts:367:   const res = await fetch(`/api/map/layers/${encodeURIComponent(zoneId)}`);
+```
+→ Exactly **one** production sink: a `fetch()` **GET** (no `method`/body/headers/credentials override → default GET) to the existing read-only `/api/map/layers/<zone>` endpoint, with `encodeURIComponent` on the id. No `spawn`, `execFile`, `writeFileSync`, `POST`, `PUT`, `DELETE`.
+
+**M3 — Injection / remote-code / alternate-transport sweep over the whole iso feature:**
+```
+$ grep -RInE "eval\(|new Function|document.write|innerHTML|importScripts|XMLHttpRequest|WebSocket|EventSource|sendBeacon|new Worker" template/src/widgets/iso-map/
+(no output — NONE)
+```
+→ Zero `eval` / `new Function` / DOM-sink / alternate network transport. The only dynamic import is `IsoMapCorner.svelte:22` `browser ? import('@/widgets/iso-map') : null` — a **static local module specifier** (Vite `@/` alias → `template/src/`), `browser`-guarded and `<svelte:boundary>`-wrapped. No user input reaches the import path; no remote script.
+
+**M4 — The consumed endpoint is GET-only, read-only, path-traversal-defended** (read of the actual handlers):
+- `routes/api/map/+server.ts` — exports only `GET`; delegates to `readMapFile()`.
+- `routes/api/map/layers/[zone]/+server.ts` — exports only `GET`; rejects any `zone` failing `isValidZoneId` (`^[a-zA-Z0-9._-]+$` **and** explicit `!zone.includes("..")`) with HTTP 400 *before* filesystem access.
+- `shared/server/map.ts` — `readMapFile` / `readMapLayerFile` use only `existsSync` + `readFileSync` from `node:fs`. No `spawn`, no write, no forgeplan invocation, no network.
+
+**M5 — Dependency audit (`three`/`@threlte` at pinned versions):**
+```
+$ npm audit --audit-level=low --json   # in template/
+vuln totals: {info:0, low:0, moderate:3, high:3, critical:0, total:6}
+three/@threlte/draco/ktx advisories: []   ← none
+```
+→ Pinned `three ^0.185.1`, `@threlte/core ^8.5.16`, `@threlte/extras ^9.21.0`, `@types/three ^0.185.0` (dev) introduce **0** advisories. `three` is bundled into a **client-only lazy chunk** (verified by EVID-099/100: absent from the SSR `dist/index.js` and from eager entry chunks) — it never reaches the server runtime.
+
+**M6 — vite draco/basis stub is a build-only, no-execution module:** `vite/stubs/three-loaders.ts` exports only empty declarations (`class DRACOLoader {}`, `class KTX2Loader {}`, `const DRACO_GLTF_CONFIG = {}`), referenced **only** from `vite.config.ts` `resolve.alias` onto exact deep specifiers (never the bare `three` package). It *removes* ~1.2 MB of unused WASM loader code — it reduces attack surface. `dist/` never executes `vite.config.ts` (rule 21).
+
+## Result (concrete counts)
+
+- **0** new spawn / execFile sites.
+- **0** new mutating endpoints (`POST`/`PUT`/`DELETE`/`PATCH`) — the two map endpoints are `GET`-only.
+- **0** new server route files added by the iso feature (`git diff` over `routes/api/` + `shared/server/` = empty).
+- **0** filesystem write / mutation call sites (no `writeFileSync`/`mkdirSync`/`renameSync`/`unlink`).
+- **0** new external-network egress (no external host; no XHR/WebSocket/EventSource/sendBeacon/Worker).
+- **1** new server touchpoint total: a client `fetch()` **GET** to the already-allow-listed read-only `/api/map/layers/<zone>` (rule-22 amendment PRD-038 FR-002) — path-traversal-defended by `isValidZoneId`.
+- **0** `eval`/`new Function`/remote-script/dynamic-remote-import sites.
+- **0** new dependency advisories from `three`/`@threlte` (6 pre-existing advisories are all in the unrelated SvelteKit/Svelte/vite/ws/dompurify/devalue toolchain — see Residual risks).
+- **STRIDE / OWASP:** no new surface in any category — Tampering (no browser→server mutation), Info-disclosure (traversal blocked; no external egress), Elevation (no new endpoint/spawn), A01/A03/A05/A06/A10 all clear.
+
+## Interpretation (what it means for AC-5 / NFR-006)
+
+PRD-039 **NFR-006** requires "**0** new server endpoints, **0** browser-initiated forgeplan mutations, and **0** spawn/write/network call sites; it reads only the existing GET-only `/api/map` + `/api/map/layers/<zone>` responses." Every one of those thresholds is met and independently verified against frozen git ground truth and the actual shipped source. **AC-5's governance half is satisfied → rule-22 holds → PASS** on the security/governance axis. (AC-5's *bundle-size-cap* half and AC-1/AC-3/FR-005 *browser render-proof* remain separate gates owned by ADR-011 and a tester EVID respectively — see next steps; they are outside this security audit's scope.)
+
+## Congruence Level Justification (CL3)
+
+**CL3 — same context.** This audit was run directly against the **actual shipped source** the PRD governs, on the exact review branch (`feat/idef0-3d-iso-view` @ `3e948dd`): the real route handlers, the real widget code, the real `package.json` pins, and `npm audit` against the real installed dependency tree — not a proxy, model, staging analogue, or prose summary. The measured artefact (the feature's server/network surface) *is* the artefact NFR-006 constrains, and the measurement method (git-diff scoping + rule-22 greps + handler reads + dependency audit) is exactly the "rule-22 verification greps" NFR-006 names as its own Measurement. Same system, same branch, same acceptance criterion → CL3 (penalty 0.0).
+
+## Ground-truth verification
+
+- Base..head: `54a905c..3e948dd` (merge-base with `develop` .. `HEAD`). The branch stacks the whole idef0 arc off an old develop base, so the merge-base diff carries ~100 unrelated already-shipped commits; the **iso-specific** delta is `f0ffeb7..3e948dd` (the range EVID-100 established; `f0ffeb7` present via `git cat-file -t`).
+- Diff probe: `git diff --quiet 54a905c..3e948dd` → **DELTA=PRESENT** (232 files, 58048 insertions).
+- Expected delta token: `widgets/iso-map` + `shared-drill-bus` + `IsoMapCorner` (source: PRD-039 FR-001/FR-003). Token probe: `find template/src/widgets/iso-map -type f` → **FOUND** (21 files); `shared-drill-bus.svelte.ts` **FOUND**; `IsoMapCorner.svelte` **FOUND**.
+- Verdict floor from ground-truth gate: **PASS-eligible** (DELTA=PRESENT, tokens FOUND — the change genuinely landed; server-surface diff empty).
+
+## Scope
+
+### Reviewed
+- `template/src/widgets/iso-map/**` (21 files) — the new 3D widget; primary new client surface.
+- `template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts` — shared focus-chain bridge (FR-003).
+- `template/src/widgets/dependency-graph/ui/IsoMapCorner.svelte` — Map-view-only mount + lazy dynamic import (FR-005) + honest-fallback boundary (FR-007).
+- `template/src/routes/api/map/+server.ts`, `routes/api/map/layers/[zone]/+server.ts`, `shared/server/map.ts` — the read-only endpoints consumed (GET-only + read-only + traversal-defended; verified untouched by iso).
+- `template/vite.config.ts` + `template/vite/stubs/three-loaders.ts` — build-only stub alias.
+- `template/package.json` — the added deps; `npm audit` over the installed tree.
+- PRD-039 (AC-5 / NFR-006), EVID-102 (requesting gate), EVID-100 (iso-scoped base).
+
+### Not reviewed (out of scope)
+- Functional correctness of the 3D↔2D sync, WebGL rendering, test coverage — covered by EVID-099/100/101/102.
+- `routes/api/score/+server.ts` (Modified in the develop-base diff) + map-chat agent client — earlier composed-map/chat work, not the iso feature.
+- Bundle-size-cap resolution (ADR-011) and browser render-proof (tester EVID) — separate AC gates.
+- Deployed-environment DAST / `dist/` adapter-node runtime — static/source review only.
+
+## Methodology
+
+| Step | Detail |
+|---|---|
+| STRIDE | Tampering, Information disclosure (traversal / egress), Elevation (new endpoint/spawn) — none present |
+| OWASP Top 10 | A01 Broken Access Control (traversal on `/layers/<zone>`), A03 Injection (eval/remote import/URL interp), A05 Misconfiguration (rule-22 boundary), A06 Vulnerable Components (three/@threlte), A10 SSRF (server outbound) — walked |
+| Threat model depth | Facet walk over the actual attack surface (client render + one read-only GET); no DREAD (no Critical/High) |
+| Scanners | see table |
+
+### Scanners
+
+| Tool | Command | Status | Exit | Summary |
+|---|---|---|---|---|
+| npm audit | `npm audit --audit-level=low --json` (`template/`) | executed | 1 | 6 advisories (3 mod / 3 high / 0 crit); **0** in three/@threlte/draco/ktx |
+| git ground-truth | `git diff f0ffeb7..HEAD -- routes/api shared/server` | executed | 0 | empty — iso touched no server surface |
+| rule-22 grep | `grep -RInE "spawn\|execFile\|fetch\(\|writeFileSync\|POST\|PUT\|DELETE" widgets/iso-map/ shared-drill-bus.svelte.ts` | executed | 0 | 1 read-only GET (+1 test comment); no mutation verb |
+| injection sweep | `grep -RInE "eval\(\|new Function\|document.write\|innerHTML\|importScripts\|XMLHttpRequest\|WebSocket\|EventSource\|sendBeacon\|new Worker" widgets/iso-map/` | executed | 0 | NONE |
+| semgrep / gitleaks / trivy | — | skipped (not installed) | — | not on PATH; targeted greps + manual reads cover the rule-22 surface |
+
+## Findings
+
+None at or above Low severity **attributable to this feature**. This is not a bare "no findings": each falsifiable NFR-006 threshold (0 endpoints / 0 mutations / 0 spawn-write-network) was checked against frozen git ground truth and the actual source and affirmatively verified (see Measurement M1–M6 and Result). The single new server touchpoint is a read-only GET already covered by rule-22's `/api/map/layers/<zone>` amendment; injection sinks, alternate transports, and new dependency advisories are all zero.
+
+## Residual risks
+
+- **Pre-existing toolchain advisories (out of scope — NOT introduced by this feature).** `npm audit` reports 6 advisories in the existing template stack: `@sveltejs/kit` (mod, `query.batch` cross-talk), `svelte` (mod, SSR XSS / DOM-clobbering), `dompurify` (mod, `IN_PLACE` XSS), `devalue` (high, sparse-array DoS), `vite` (high, `server.fs.deny` bypass / launch-editor NTLM — dev-server only), `ws` (high, memory-disclosure/DoS — dev transport). None involve `three`/`@threlte`. Recommend a separate `npm audit` remediation pass, tracked apart from this feature.
+- **Dev-only `server.fs.strict: false` in `vite.config.ts`** — Vite dev-server setting, pre-existing, not shipped in the pre-built `dist/` (adapter-node bundle, never runs vite). Not a runtime exposure of the published app.
+- **`isValidZoneId` MVP scope** — single-segment top-level zone ids only; nested `<ancestor>/<zone>` paths are a documented follow-up (PRD-038 out of scope). Current guard correctly rejects nested/traversal input; re-review the guard when nesting is added.
+- **Static/source review only** — no DAST against a live instance; read-only nature verified from source.
+
+## Recommended next steps
+
+- [→ guardian] Re-run the pre-activation gate: this EVID closes EVID-102 orchestrator-instruction #1 (AC-5 rule-22 governance half). Instruction #2 (browser render-proof / on-demand-load network trace — AC-1/AC-3/FR-005) remains for a `tester` EVID before activating PRD-039.
+- [→ orchestrator] The rule-22 axis is clear; hold PRD-039 in draft only pending the render-proof EVID, then re-gate + activate PRD-039 / ADR-011 / RFC-036 together.
+- [→ orchestrator, separate track] Schedule an `npm audit` remediation pass for the 6 pre-existing template-toolchain advisories (unrelated to this feature).
+
+## References
+
+- Artifact under review: PRD-039 (AC-5 / NFR-006)
+- Requesting gate: EVID-102 (guardian CONCERNS — instruction #1 = "dispatch security-expert for rule-22 pass"); prior chain EVID-099 (tester), EVID-100 / EVID-101 (code-review); EVID-105 (guardian re-gate that flagged this EVID's earlier stub state)
+- Iso-scoped diff base: `f0ffeb7..3e948dd` (per EVID-100); develop merge-base `54a905c`
+- Independent runs: `git diff f0ffeb7..HEAD -- routes/api shared/server` (empty); rule-22 + injection greps over `widgets/iso-map/`; reads of both `/api/map*` handlers + `shared/server/map.ts` + `IsoMapCorner.svelte` + `iso-view-state.svelte.ts:362-381` + `vite.config.ts` + `vite/stubs/three-loaders.ts`; `npm audit --json` in `template/`
+
+## Structured Fields
+
+verdict: supports
+congruence_level: 3
+evidence_type: measurement
+
diff --git a/.forgeplan/evidence/EVID-105-guardian-re-gate-of-prd-039-adr-011-rfc-036-3d-iso-map-chain-concerns-evid-104-governance-is-an-empty-stub-ac-3-untested.md b/.forgeplan/evidence/EVID-105-guardian-re-gate-of-prd-039-adr-011-rfc-036-3d-iso-map-chain-concerns-evid-104-governance-is-an-empty-stub-ac-3-untested.md
new file mode 100644
index 0000000..ceaebe2
--- /dev/null
+++ b/.forgeplan/evidence/EVID-105-guardian-re-gate-of-prd-039-adr-011-rfc-036-3d-iso-map-chain-concerns-evid-104-governance-is-an-empty-stub-ac-3-untested.md
@@ -0,0 +1,146 @@
+---
+depth: standard
+id: EVID-105
+kind: evidence
+last_modified_at: 2026-07-08T15:02:50.237744+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: PRD-039
+  relation: informs
+status: draft
+title: 'Guardian re-gate of PRD-039/ADR-011/RFC-036 (3D iso-map chain): CONCERNS — EVID-104 governance is an empty stub, AC-3 untested'
+---
+
+## Verdict
+
+**CONCERNS**
+
+- **PASS** — orchestrator may activate. *(NOT this — two of PRD-039's own ship-gate ACs are not honestly closed.)*
+- **CONCERNS** — orchestrator must dispatch the named fixers/reviewers, land their EVIDENCE, then re-run `guardian` before activation. **(THIS VERDICT)**
+- **BLOCKER** — halt. *(NOT this — nothing is broken; the foundation is sound, both HIGH bugs are genuinely fixed, all MUST validation is green, R_eff > 0 on all three, the ADR revisit triggers are clean, and the design is fully reversible.)*
+
+One-line justification: independent verification **contradicts the dispatch prose's claim that "both EVID-102 gaps are closed"** — the AC-5 governance EVID (**EVID-104**) is an **abandoned, unfilled template stub** (rule-11-forbidden: zero measurement, zero rule-22 grep output, raw `{placeholder}` braces) whose title falsely claims PASS, and the render-proof (**EVID-103**) is itself scrupulously explicit that **AC-3 (depth control 1/2/3 + ascend + show/hide toggle *interaction*) and AC-1's second half (every other view's 2D minimap byte-unchanged) were NOT tested**. The prior-guardian gaps are therefore only *partially* closed; the chain is not yet activatable.
+
+## Methodology
+
+- **Re-run** of the pre-activation gate on the 3D-iso chain (supersedes-in-spirit **EVID-102** CONCERNS). Generator≠verifier applied: I read every artifact + every linked EVID body directly, independently re-ran the code/test/link checks, and did NOT trust the dispatch prompt's prose (which overstated EVID-103/EVID-104 closure).
+- **project-config:** `.forgeplan/project-config.yaml` **not found** (only `.forgeplan/config.yaml` exists, with no `quality_gates:` key) → **HARD RULE 7 conservative defaults applied** (`min_test_coverage=80`, `max_findings_critical=0`, `max_findings_high=3`, `max_findings_medium=10`, `require_validate_pass=true`, `require_audit_pass=true`, `require_evidence_chain=[prd,rfc,adr,spec]`).
+- **`mm-gate-failures` mental model: ABSENT (HTTP 404)** — recorded honestly (HARD RULE 6). `memory_recall` returned no new gate-failure regrets beyond the score-cascade-lock note; `mental_model_list` returned `[]` (no living pages in this bank).
+- **`forgeplan_reason` gate:** the chain's ADI was run *manually* in the artifact bodies because workspace-MCP `forgeplan_reason` returns "LLM provider unavailable" (a documented infra gap across PRD-037/038/039). All three artifacts are `standard` depth (ADI recommended, not required) and carry thorough manual ADI (PRD-039: 3 cycles; ADR-011: 3 options F+G+R=20≥14; RFC-036: 3 options). Consistent with EVID-102, this is treated as satisfied-in-spirit, not a BLOCKER.
+
+## Artifacts under review
+
+| ID | Kind | Status | R_eff (live) | Title |
+|---|---|---|---|---|
+| `PRD-039` | prd | draft | **0.30** | 3D isometric layered overview minimap for the composed-map view |
+| `ADR-011` | adr | draft | **0.70** | Ship three.js + Threlte lazy client chunk; raise per-image dist cap 3 → 3.5 MiB |
+| `RFC-036` | rfc | draft | **0.30** | Lazy 3D iso-map widget, 2D-synced via a three-free shared-drill-bus |
+
+- Parent lineage: `PRD-039 --based_on--> PRD-036` (**active**, R_eff 0.80) → EPIC-001 T4. `RFC-036 --based_on--> PRD-039`; `ADR-011 --informs--> PRD-039` (and `informs` PRD-030). Parent-active activation policy is satisfied.
+- All three R_eff values are **fresh and > 0** (this run's `forgeplan_get` returned 0.30/0.70/0.30, not the stale 0.0 EVID-102 saw) — rule-11 / Red-Line-3 "no activate at R_eff==0" is **not** tripped.
+
+## EVIDENCE chain inspected (chronological, all `informs`-linked, verified via `forgeplan graph`)
+
+| EVID | Body verdict | Structured (R_eff) | Source role | Critical finding (one-line) |
+|---|---|---|---|---|
+| `EVID-099` | CONCERNS | supports · CL3 · measurement | tester | Build PASS 3.29 MiB < 3.5 cap (both images); svelte-check 0; vitest 782/782; SSR three-free; 808 KiB lazy chunk. Flagged AC-1/AC-3 UI + AC-5 governance **not run**. |
+| `EVID-100` | CONCERNS (weakens) | weakens · CL3 · audit | code-reviewer | 7 findings incl. #1 HIGH sync-drop race, #2 HIGH zero-tests, #3 MED WebGL-init, #4–7 doc drift. *(historical — pre-fix)* |
+| `EVID-101` | CONCERNS (weakens) | weakens · CL3 · audit | code-reviewer (re-review) | #1/#2/#3 CLOSED non-vacuously; #4 doc drift 3/4 closed, RFC Function-Signatures open *at time of writing*. *(historical)* |
+| `EVID-102` | CONCERNS | supports · CL3 · audit | guardian (prior) | Held on two gaps: AC-5 rule-22 governance + AC-1/AC-3/FR-005 render-proof. Instructed: land both EVIDs then re-run guardian. |
+| `EVID-103` | **PASS** (partial) | supports · CL3 · test | evidence-recorder (Playwright) | Closes AC-2 (bidirectional sync, both dirs), FR-005/NFR-002 (on-demand load), AC-1 render-half. **Own scenario table marks AC-3 + AC-1 second-half "NOT TESTED — gap."** |
+| `EVID-104` | *titled* PASS | supports · CL3 · measurement | security-expert (governance) | **HOLLOW STUB — body is an unfilled template (`{placeholder}` braces, `ADR-<id>`), zero rule-22 grep, zero findings. Never validated past `shape`. Does NOT close AC-5.** |
+
+**Chain state: 6 EVIDs — 0 BLOCKER, 4 CONCERNS, 1 PASS (partial), 1 hollow-stub-PASS.** No superseding EVID resolves the two open gaps.
+
+## Independent verification (generator≠verifier — I checked code/tests/links, not the prose)
+
+| Claim under test | Method | Result |
+|---|---|---|
+| EVID-100 #1 sync-drop race fixed | `grep pendingExternal / $effect.root` in `iso-view-state.svelte.ts` | ✅ CLOSED — `pendingExternal` slot (l.127) + `$effect.root` watcher re-applying on `animationKind` settle (l.132-137); `applyExternalFocusChain` records instead of dropping |
+| EVID-100 #3 WebGL boundary fixed | read `IsoMapCorner.svelte` | ✅ CLOSED — `<svelte:boundary>` + `{#snippet failed()}` (l.39-44); browser-guarded dynamic `import()` (l.22) |
+| EVID-100 #2 test-gap fixed | `ls` + case count + prior runs | ✅ CLOSED — `shared-drill-bus.svelte.test.ts` (13 cases) + `iso-view-state.render.test.ts` (3 cases) = 16; EVID-101/102 ran 16/16 + full 798/798, non-vacuous |
+| EVID-100/101 #4 RFC↔code drift closed | `grep export` in bus + read RFC-036 body | ✅ CLOSED — bus exports **exactly** `sharedFocusChain`/`chainsEqual`/`focusTo` (l.47/51/72); no stale `descend/ascend/setDepth/toggleVisible/setSharedFocusChain` (the one grep hit at l.32 is an explanatory *comment*). RFC-036 Function-Signatures now matches. |
+| R_eff > 0 (rule 11) on all three | `forgeplan_get` r_eff_score | ✅ 0.30 / 0.70 / 0.30 — all > 0 (fresh) |
+| MUST validation | `forgeplan_validate` ×3 | ✅ PRD-039 PASS (0/0); ADR-011 PASS (0 MUST, 1 SHOULD intentional-TODO); RFC-036 PASS (0 MUST, 1 SHOULD intentional-TODO) |
+| ADR-011 revisit triggers | parse ADR-011 Compliance section | ✅ metric (image>3.5MiB) NOT fired (3.29 MiB); event (three dropped) NOT fired; date 2027-01-08 future. **No `[x]`, no DATE-FIRED.** F+G+R=20≥14, ADR created today (<30d) — no decay. |
+| **EVID-104 substance** | `forgeplan_get` + raw markdown | ❌ **STUB** — body is unfilled template: `{Что измерено...}`, `{Конкретный результат с числами}`, `ADR-<id>`; **zero** rule-22 grep output, **zero** findings. Title claims "PASS — rule-22 holds" with no supporting content. |
+| rule-22 spot-check (blast-radius only, NOT a substitute for the missing EVID) | grep new iso widget for spawn/write/fetch | iso widget's only server touch = `fetch('/api/map/layers/${encodeURIComponent(zoneId)}')` — one **GET** to the already-allow-listed read-only endpoint; **0** spawn/execFile/writeFile/createServer in new code. Actual posture *likely* clean — but **unrecorded**. |
+
+## Gate criteria
+
+| # | Criterion | Status | Notes |
+|---|---|---|---|
+| 1 | Artifact MUST validation (×3) | ✅ | 0 MUST errors each; SHOULD warnings are the intentional `TODO(iso-adr)`/`TODO(iso-promote)`/`TODO(iso-draco-basis)` code-marker refs, not stubs |
+| 2 | Required reviewer EVIDENCE linked | ⚠️ | tester + code-review + re-review + render-proof present; **the governance/security EVID (EVID-104) exists in name but is an EMPTY STUB** — the AC-5 rule-22 review was never actually recorded |
+| 3 | No BLOCKER in chain | ✅ | 0 BLOCKER verdicts; all HIGH/MED findings independently verified CLOSED |
+| 4 | Unresolved HIGH-severity CONCERNS | ✅ (0) | #1/#2 HIGH → CLOSED; #3 MED → CLOSED; #4 doc → CLOSED |
+| 5 | Activation policy satisfied | ❌ | **PRD-039's own AC-3 and AC-5 ship-gates are not honestly closed** (see below); R_eff>0 ✅, ADI sound ✅, parent PRD-036 active ✅ |
+| 6 | Project-specific gates | ✅ | build/cap/svelte-check/SSR-exclusion independently green (EVID-099 + this run) |
+| 7 | Blast radius within stated threshold | ✅ | additive, read-only, Map-view-scoped, reversible — matches artifacts' claims (see Blast radius) |
+| 4b | Linked-ADR revisit triggers | ✅ | ADR-011 metric/event/date triggers all UNfired; F+G+R=20, <30d old — no decay |
+
+### Project-config gates (`.forgeplan/project-config.yaml` **absent** → HARD-RULE-7 defaults)
+
+Config source: **not found — conservative defaults applied**.
+
+| Criterion | Threshold (default) | Observed | Result |
+|---|---|---|---|
+| Test coverage | ≥80% (`min_test_coverage`) | **not measured as %** (tester reported pass counts) | ⚠️ unverifiable (informational — the load-bearing sync contract IS covered by 16 tests + full suite 798/798) |
+| Critical findings | ≤0 | 0 | ✅ |
+| High findings | ≤3 | 2 (both CLOSED; 0 unresolved) | ✅ |
+| Medium findings | ≤10 | 1 (CLOSED; 0 unresolved) | ✅ |
+| Validate pass | required | 3/3 PASS | ✅ |
+| Audit pass (≥1 Profile B EVID with body-verdict PASS) | required | EVID-103 body-verdict PASS present | ✅ (met by EVID-103) — but see EVID-104 caveat |
+| Evidence chain | required for prd/rfc/adr | 6 EVIDs linked | ✅ present (but a required governance review is hollow — crit. 2) |
+
+**Gates summary: 6/7 green** (source: defaults; only test-coverage unverifiable). **The CONCERNS verdict is driven by criterion 5 (activation policy) + criterion 2 (the hollow governance EVID), NOT by the project-config table.** Additionally the thin-PASS modifier fires: EVID-104 carries a PASS-shaped `verdict: supports` with **zero `## Findings`** → CONCERNS.
+
+## Why CONCERNS, not PASS — the two EVID-102 gaps are NOT both closed
+
+**Gap A — AC-5 rule-22 / NFR-006 governance: NOT closed. EVID-104 is an abandoned template stub.**
+PRD-039 AC-5 makes "rule-22 greps report 0 new server endpoints and 0 spawn/write/network call sites" a ship-gate. EVID-104 was created to record it (by `security-expert-task-prd039-nfr006`, per EVID-103's note) but its body was **never filled** — it is the raw evidence template (`{Что измерено...}`, `{Конкретный результат с числами}`, `ADR-<id>`), never validated past `shape` phase. Its `verdict: supports` / CL3 structured fields dangerously prop up R_eff while recording **no actual verification** — a rule-11-forbidden "empty artifact stub abandoned." My own spot-check *suggests* the real posture is clean (1 read-only GET, 0 new spawn/write/network in the iso widget), **but a guardian must not certify a ship-gate on an inferred-but-unrecorded check** — that is the exact "drift accepted as good enough" failure this gate exists to prevent, and the prior guardian (EVID-102) explicitly refused to waive it (citing the EVID-086 render-proof precedent).
+
+**Gap B — AC-1/AC-3 + FR-005 render-proof: PARTIALLY closed. EVID-103 leaves AC-3 and AC-1's second half open.**
+EVID-103 genuinely closes **AC-2** (bidirectional 3D↔2D sync, both directions, screenshots on disk, 0 iso console errors), **FR-005/NFR-002** (on-demand-load network trace #491-518 + code-verified `browser ? import('@/widgets/iso-map') : null`), and the **render half of AC-1** (3D corner renders on the Map view). But its own scenario table (rows 6 & 7) marks **NOT TESTED**: **AC-3** (depth control 1/2/3, ascend, show/hide toggle were rendered but never *exercised* — no interaction/before-after), and **AC-1's second clause** (no non-Map view was visited to confirm its 2D minimap is byte-unchanged). AC-3 is a PRD-039 `must` ship-gate ("verified by a manual pass before the arc PR merges"). The dispatch prose's "closes AC-1/AC-3/FR-005" **overstates** what EVID-103 records.
+
+## Blast radius
+
+- **Affected scope on activation:** the read-only forgeplan-web **viewer** (client-side), **Map view only**. The 3D overview replaces the flat 2D minimap in the Map-view corner only; every other view + its 2D minimap is byte-unchanged (FR-006, verified additive). No production data path, no host mutation.
+- **Reversibility:** **fully reversible by design** — ADR-011 + RFC-036 both carry a 4–5-step rollback (drop `IsoMapCorner` dynamic import → 2D fallback; delete widget + bus; revert cap commit `a6ef030`; drop `three`/`@threlte` deps). The prior "Force 3D" revert (`7f907dd`) proves the pattern is clean. **Not a one-way door.**
+- **Server / governance surface:** the new widget adds exactly **one** call site — a client `fetch()` GET to the **existing** read-only `/api/map/layers/<zone>` endpoint. **0** new endpoints/spawn/write/external-network in the new iso code (my spot-check). Rule-22 risk is low — **but not formally recorded** (Gap A).
+- **Packaging:** +~808 KiB irreducible lazy `three` chunk. Both images **3.29 MiB**, ~220 KiB margin under the raised **3.5 MiB** cap. Cap bump is a real +0.5 MiB governance-slack widening (ADR-011 DD-5/INV-3 acknowledges it); residual PRD-030/rule-21 cap-text editorial drift is a tracked fix-forward, not a blocker.
+- **Downstream:** ADR-011 `informs` PRD-030's cap NFR (amends, not supersedes); RFC-036 `refines` ADR-011; the shared-drill-bus contends with PRD-038's onboarding-tour camera (RFC-036 R-6 / PRD-039 Q4 — flagged **unresolved**, tracked).
+- **Detection time if wrong:** viewer-only, no prod data path → a regression is caught only by the next manual pass or a future Playwright suite (none exists for the iso widget beyond the unit-level tests).
+- **Threshold check:** actual blast radius (additive, read-only, Map-view-scoped, reversible) **matches** the artifacts' stated claims — no scope broadening. This criterion does **not** itself downgrade the verdict; the downgrade is from the unmet ACs above.
+
+## Orchestrator instructions
+
+**CONCERNS → do NOT activate the chain yet. Dispatch the following, land their EVIDENCE, then re-run `guardian`:**
+
+1. **Re-dispatch `agents-pro:security-expert`** to ACTUALLY perform and RECORD the PRD-039 AC-5 / NFR-006 rule-22 governance verification — fill EVID-104's empty body (or supersede it with a fresh EVID) with the real grep output: **0** new `/api/*` endpoints, **0** spawn/write/network call sites in the iso diff, and the single `fetch` is a GET to the already-allow-listed read-only `/api/map/layers/<zone>`. Assign a real verdict, `informs` PRD-039, and `forgeplan_validate` it past `shape`. **The current EVID-104 is a rule-11-forbidden abandoned stub and MUST NOT be counted as closing AC-5.**
+2. **Dispatch `agents-core:tester`** (Playwright/manual) to close the two remaining render-proof gaps: **AC-3** — exercise the depth control (click depth 1/2/3), the ascend action, and the show/hide toggle, with before/after screenshots or DOM-state assertions (not just a static render showing the controls exist); and **AC-1's second clause** — visit ≥1 non-Map view (e.g. `list`/`graph`) and confirm its 2D minimap is byte-identical to base. Record as a Profile B EVID `informs` PRD-039.
+3. **Then re-run `guardian`.** With items 1–2 landed and validated, the chain has no remaining gaps and is activatable — the HIGH bugs, tests, RFC drift, cap decision, SSR exclusion, R_eff>0, and ADR triggers are all already green.
+
+**Incremental option (secondary — orchestrator's call):** **ADR-011 alone is evidence-sufficient for its own cap decision** (empirically verified: build 3.29 MiB < 3.5 cap, SSR three-free, ~808 KiB lazy chunk, R_eff 0.70, ADI F+G+R=20≥14, no revisit trigger fired; EVID-099 states its measurements "can support activating ADR-011 specifically"). If the orchestrator wants to unblock the already-applied cap bump (`a6ef030`) ahead of the UI closures, **ADR-011 could be activated independently now, with PRD-039 + RFC-036 held in draft** pending items 1–2. Cleaner path is to close 1–2 and activate all three together.
+
+## Notes
+
+- Residual tracked risks the orchestrator should carry even after eventual activation: PRD-039 Q4 / RFC-036 R-6 (shared-focus-chain vs PRD-038 onboarding-camera hand-off — **unresolved**); the load-bearing draco/basis vite stub (RFC-036 R-4, `TODO(iso-draco-basis)`); PRD-030 NFR-001/SC-4 + rule-21 cap-text editorial drift (3 → 3.5 MiB fix-forward); ADR-011's own metric revisit trigger (any image > 3.5 MiB).
+- Minor (non-blocking) heuristic note: ADR-011/RFC-036 discuss ≥3 modules (iso-map / composed-map / dependency-graph) with no `docs/c4/ADR-011.md` and no inline C4/flowchart mermaid — the module topology is instead carried in RFC-036's prose Component Diagram. Not a driver of this verdict; optional `/c4-diagram` follow-up if the orchestrator wants a rendered L1/L2.
+- No claim collision on the chain. `mm-gate-failures` absent (404) recorded honestly. Score cascade / `.forgeplan/.lock` was free this run (no `forgeplan score --all` contention).
+
+## References
+
+- Artifacts under review: `PRD-039`, `ADR-011`, `RFC-036`
+- EVIDENCE chain: `EVID-099`, `EVID-100`, `EVID-101`, `EVID-102` (prior guardian), `EVID-103`, `EVID-104` (hollow stub)
+- Parent: `PRD-036` (active, R_eff 0.80)
+- Independent runs this gate: `forgeplan_validate` ×4; `forgeplan graph` (link verify); `git`/`grep` code spot-checks (`pendingExternal`, `svelte:boundary`, bus exports, test-file counts, rule-22 fetch/spawn scan); EVID-104 raw-markdown read
+- Mental models consulted: `mm-gate-failures` (absent — 404); `memory_recall` (score-cascade-lock + smith/guardian-activation-separation notes)
+
+## Structured Fields
+
+verdict: supports
+congruence_level: 3
+evidence_type: audit
+
+
diff --git a/.forgeplan/evidence/EVID-106-browser-interaction-proof-for-prd-039-ac-3-depth-ascend-toggle-ac-1-clause-2-non-map-2d-minimap-unchanged-pass.md b/.forgeplan/evidence/EVID-106-browser-interaction-proof-for-prd-039-ac-3-depth-ascend-toggle-ac-1-clause-2-non-map-2d-minimap-unchanged-pass.md
new file mode 100644
index 0000000..a85ce95
--- /dev/null
+++ b/.forgeplan/evidence/EVID-106-browser-interaction-proof-for-prd-039-ac-3-depth-ascend-toggle-ac-1-clause-2-non-map-2d-minimap-unchanged-pass.md
@@ -0,0 +1,127 @@
+---
+depth: standard
+id: EVID-106
+kind: evidence
+last_modified_at: 2026-07-08T15:20:05.693991+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: PRD-039
+  relation: informs
+status: draft
+title: 'Browser interaction-proof for PRD-039 AC-3 (depth/ascend/toggle) + AC-1 clause-2 (non-Map 2D minimap unchanged): PASS'
+---
+
+## Verdict
+
+**PASS** / **SUPPORTS**
+
+Live Playwright browser-interaction capture against the running dev server (branch `feat/idef0-3d-iso-view` @ `3e948dd6785c0eaa366395c062366f14e045a9e3`, same head EVID-103 recorded) closes the two gaps guardian's prior pass (EVID-102, echoed by EVID-103's own "Recommended next steps") explicitly left open on PRD-039: **AC-3** (depth-control 1/2/3 + ascend + show/hide-toggle *interaction*, FR-004) and **AC-1's second clause** ("every other view's 2D minimap unchanged", FR-001 clause 2). EVID-103 already closed AC-2 (bidirectional sync) + FR-005/NFR-002 (on-demand load) + AC-1's render half (Map-view 3D corner appears). Together, EVID-103 + this EVID close **AC-1 (both clauses), AC-2, AC-3, FR-001..FR-005, NFR-002** for PRD-039.
+
+Assigned verdict fields (per orchestrator directive, recorded faithfully, not re-judged by this agent): `verdict: supports`, `congruence_level: 3`, `evidence_type: test`.
+
+## Ground-truth verification
+
+- Base..head: `54a905c862b542f14a2c5929aa44f450c63ffd21..3e948dd6785c0eaa366395c062366f14e045a9e3` (source: same merge-base/HEAD pair independently re-derived by this agent via `git merge-base feat/idef0-3d-iso-view develop` and `git rev-parse HEAD` — matches the pair EVID-103 recorded, confirming this capture is against the identical code state, not a moved target).
+- Diff probe: `git diff --stat 54a905c8..3e948dd6` → DELTA=PRESENT (232 files changed, +58048/-260 — same as EVID-103; no new commits landed between the two captures).
+- Expected delta tokens for the two claims THIS EVID closes, independently probed by this agent (not taken on the dispatch prompt's word):
+  1. **AC-3 depth/ascend/toggle control exists in source** — `git ls-files template/src/widgets/iso-map | grep -iE "control|toggle"` → **FOUND**: `template/src/widgets/iso-map/ui/IsoControls.svelte`.
+  2. **AC-1 clause-2 view-conditional exists in source** — `grep -n "IsoMapCorner\|Minimap" template/src/widgets/dependency-graph/ui/DependencyGraph.svelte` → **FOUND** at lines 219-226:
+     ```
+     {#if view === 'map'}
+       <!-- Map-view-only corner: a 3D IsoMinimap replaces the 2D <Minimap> in
+            this one slot (same bottom-right position). ComposedMapView itself
+            (the main 2D map above) is untouched — see IsoMapCorner's header
+            comment for the lazy-load rationale. -->
+       <IsoMapCorner />
+     {:else}
+       <Minimap ... />
+     {/if}
+     ```
+  3. **iso-spike throwaway route (source of the unrelated console errors) is deleted and the deletion is committed** — `git ls-files template/src/routes/iso-spike | wc -l` → **0** (confirmed absent from the tracked tree at HEAD).
+- Verdict floor from ground-truth gate: **PASS-eligible** — the observed interaction behaviour traces to real, committed source (`IsoControls.svelte` backs AC-3's controls; the `{#if view==='map'}` conditional backs AC-1 clause-2; the deleted spike route explains the unrelated console noise). This is not a vacuous-green claim — code and observed DOM/console behaviour agree.
+- `.forgeplan/.lock` checked before every MCP write in this task: present but 0 bytes (unlocked marker file), never removed by this agent.
+
+## Evidence type
+
+🧪 Manual QA
+
+(A live Playwright browser-interaction session against the running dev server — DOM/aria-state snapshots + `browser_evaluate` + screenshots per step. Same capture category as EVID-103; this EVID records the continuation of that same session exercising the two previously-untested controls.)
+
+## Raw input provenance
+
+- Source: orchestrator-performed live Playwright interaction capture against the dev server (`http://127.0.0.1:5174/`, Map view = the 9th "Map" graph view), branch `feat/idef0-3d-iso-view` @ `3e948dd6785c0eaa366395c062366f14e045a9e3`. Handed to this agent as orchestrator-inline text (the "Observed facts to record" section of the dispatch prompt) plus 7 screenshot artifacts on disk. This agent did **not** re-run the browser session — per explicit instruction, the capture was already performed; this agent's job was to independently fingerprint the artifacts and structure the observations faithfully.
+- Screenshots (fingerprinted directly by this agent via `shasum -a 256` + `wc -c` + `file`, not taken on the orchestrator's word — every value below was independently reproduced and matches the orchestrator's stated sha256 prefixes and byte sizes exactly):
+
+| File | Size (B) | SHA-256 | Format |
+|---|---|---|---|
+| `ac3-01-baseline-depth2.png` | 126568 | `23ab3500938d0b37a2e23f0a5a762c32691376267d8ea2984f6f5f5e5c093e1f` | PNG 1400×1000 RGB |
+| `ac3-02-depth3.png` | 107045 | `f09064a7e6c118f847fd6c37ab1e318cc9d3eeb453af5e05dfbc3b5bc8997da5` | PNG 1400×1000 RGB |
+| `ac3-03-depth1.png` | 97552 | `4cad2adbdadb6224e820490f75eea69d752acfd5e3dc754851e7f953689c9a11` | PNG 1400×1000 RGB |
+| `ac3-04-controls-hidden.png` | 96316 | `dbbec985e20afe34e8ccc1fc56cb39717018df49b30689087a1974bd70860aef` | PNG 1400×1000 RGB |
+| `ac3-05-descended-3dclick.png` | 90427 | `d9342011dfe5457605316f3c052ac0da10470466d525e671797c0b325da2022c` | PNG 1400×1000 RGB |
+| `ac3-06-ascended-back-to-root.png` | 108917 | `0f9c1391cb2a18ac150e29b66de9a4f518dabf60e98eafdb0c492de610f9c866` | PNG 1400×1000 RGB |
+| `ac1-clause2-force-view-2d-minimap.png` | 228797 | `0951f1893aad8ffb7ff8c97a36528d9ce88b2ce66851539b6c06c5d3664a8453` | PNG 1400×1000 RGB |
+
+All 7 paths resolved and read directly from `/Users/explosovebit/Work/ForgePlanWeb/` — none missing, none zero-byte, all valid PNG per `file`(1).
+- Captured at: 2026-07-08 (same-day continuation of the EVID-103 capture session, same branch head).
+- Captured by: orchestrator (live Playwright browser driving), relayed to this agent (evidence-recorder) for structuring.
+
+## Raw input (orchestrator's observed-facts dispatch text, condensed to ≤2000 chars)
+
+```
+AC-3 depth control (1/2/3): baseline depth "2" pressed, ascend DISABLED at root (ac3-01). Clicked "3" (ac3-02). Clicked "1" -> DOM: button "1" became [active][pressed], "2"/"3" un-pressed -- pressed state moved 2->1 (ac3-03). Depth buttons are interactive; each toggles the visible-layer window.
+
+AC-3 show/hide toggle: clicked "Hide 3D controls" -> DOM: depth-control group (1/2/3+ascend) DISAPPEARED, toggle relabeled "Show 3D controls" [active] (ac3-04). Clicked "Show 3D controls" -> DOM: group RESTORED with depth state preserved, toggle relabeled "Hide 3D controls" [expanded]. Round-trip verified.
+
+AC-3 ascend: at root, ascend DISABLED. Descended via 3D-corner canvas click (.iso-map-corner canvas, 1226,831) -> DOM: depth auto-reset to "2", ascend ENABLED, 2D map followed into sub-map (breadcrumb: 4 root zones -> sub-zone labels) (ac3-05; re-confirms AC-2 sync). Clicked ascend -> DOM: 2D trail returned to root chips, ascend DISABLED again (ac3-06).
+
+AC-1 clause 2: switched view Map -> "Force". browser_evaluate: iso3dCornerPresent:false, canvasCount:0 (no WebGL canvas), minimap present (minimapClasses:["minimap svelte-15cdyrc"]) (ac1-clause2). The {#if view==='map'} IsoMapCorner {:else} Minimap {/if} conditional holds -- non-Map views keep 2D minimap unchanged, three.js never mounts there.
+
+Console: zero errors referencing widgets/iso-map, IsoMinimap, IsoMapCorner, shared-drill-bus. Errors mentioning ZONE_HIT_OPACITY/IsoScene all trace to the DELETED iso-spike route (confirmed absent on disk, deletion committed). Remaining noise: transient dev-server ERR_CONNECTION_REFUSED + 2x api/score 400 (score-suppression artifact, unrelated).
+```
+
+## Structured findings
+
+**🧪 Manual QA scenario table:**
+
+| # | Scenario | Steps | Observed | Expected | AC/FR closed | Pass/fail |
+|---|---|---|---|---|---|---|
+| 1 | Depth control — baseline | Load Map view at root | Depth button "2" pressed (default); ascend ⬆ disabled (nothing to climb at root). Screenshot `ac3-01-baseline-depth2.png` | Default depth state renders with ascend correctly disabled at root | AC-3 / FR-004 | **PASS** |
+| 2 | Depth control — select "3" | Click depth button "3" | View updates to 3-level visible window. Screenshot `ac3-02-depth3.png` | Selecting depth 3 shows 3 levels of the stack | AC-3 / FR-004 | **PASS** |
+| 3 | Depth control — select "1" | Click depth button "1" | DOM snapshot: button "1" became `[active][pressed]`, "2"/"3" un-pressed — pressed state moved 2→1. Screenshot `ac3-03-depth1.png` | Selecting depth 1 shows exactly 1 level; state moves correctly between buttons | AC-3 / FR-004 | **PASS** |
+| 4 | Show/hide toggle — hide | Click "Hide 3D controls" (⋯) | DOM: the depth-control group (1/2/3 + ascend) disappeared from the panel; toggle relabeled "Show 3D controls" `[active]`. Screenshot `ac3-04-controls-hidden.png` | Toggling off hides the whole control panel | AC-3 / FR-004 | **PASS** |
+| 5 | Show/hide toggle — show (round-trip) | Click "Show 3D controls" | DOM: depth-control group restored (buttons 1/2/3 + ascend back, depth state preserved), toggle relabeled "Hide 3D controls" `[expanded]` | Toggling on restores the panel without disturbing depth state — round-trip verified | AC-3 / FR-004 | **PASS** |
+| 6 | Ascend — descend first (setup) | At root (ascend disabled), click a zone in the 3D corner canvas (`.iso-map-corner canvas`, 1226,831) | DOM: depth auto-reset to "2" (auto-grows to focusChain.length+1); ascend ⬆ became enabled; 2D composed-map followed into the zone's sub-map (breadcrumb changed from 4 root zones to sub-zone labels). Screenshot `ac3-05-descended-3dclick.png` | Descend enables ascend and re-syncs both surfaces (also re-confirms AC-2, already closed by EVID-103) | AC-3 / FR-004 (+ re-confirms AC-2 / FR-003) | **PASS** |
+| 7 | Ascend — climb back to root | Click ascend ⬆ | DOM: 2D trail returned to the root flow chips ("All / Request path / Render / Entry points / Decision trail / Init / Start / Map API"); ascend ⬆ became disabled again. Screenshot `ac3-06-ascended-back-to-root.png` | Ascend climbs exactly one focus level on both surfaces and correctly re-disables at root | AC-3 / FR-004 | **PASS** |
+| 8 | AC-1 clause 2 — non-Map view 2D minimap unchanged | Switch graph view Map → "Force" via "Change graph view" dropdown; run `browser_evaluate` | `iso3dCornerPresent: false` (`.iso-map-corner` not rendered); `canvasCount: 0` (no WebGL canvas mounted — three.js not loaded outside Map); 2D minimap present (`minimapClasses: ["minimap svelte-15cdyrc"]`). Screenshot `ac1-clause2-force-view-2d-minimap.png` | Non-Map views keep the 2D minimap unchanged; three.js never mounts there (also re-confirms FR-005 lazy load) | AC-1 clause 2 / FR-001 clause 2 (+ re-confirms FR-005) | **PASS** |
+| 9 | Console cleanliness across scenarios 1–8 | Observe browser console throughout the session | Zero errors referencing `widgets/iso-map`, `IsoMinimap`, `IsoMapCorner`, `shared-drill-bus`. All `IsoScene`/`ZONE_HIT_OPACITY` errors trace to the deleted `src/routes/iso-spike/IsoScene.svelte` throwaway spike route (confirmed absent from the tracked tree: `git ls-files template/src/routes/iso-spike` → 0 files). Remaining noise: transient `api/instances`/`api/log`/`api/map`/`api/list` `ERR_CONNECTION_REFUSED` during dev-server restart + 2× `api/score` 400 (score-suppression test artifact) | No iso-feature console errors from current shipped code | (supports all rows above) | **PASS** |
+
+**Coverage vs PRD-039 acceptance criteria — closing the gaps EVID-103 named:**
+
+- **AC-3 (depth control 1/2/3 + ascend + show/hide toggle; FR-004)** — **CLOSED** by scenarios 1–7. Every element of FR-004's three acceptance-criteria bullets (depth selection changes visible level count; ascend climbs one level on both surfaces; toggle hides then restores without disturbing 2D map state) is now demonstrated with DOM/aria-state evidence, not just a static screenshot showing the controls exist (which is all EVID-103 had).
+- **AC-1 clause 2 ("every other view's 2D minimap unchanged"; FR-001 second bullet)** — **CLOSED** by scenario 8. The Force view was visited and its 2D minimap confirmed present and unmodified, with the 3D corner element and WebGL canvas confirmed absent — the `{#if view === 'map'}` conditional in `DependencyGraph.svelte` (lines 219-226, grepped directly by this agent) is the source-level mechanism backing this observation.
+- **Combined with EVID-103** (AC-2 bidirectional sync, FR-005/NFR-002 on-demand load, AC-1 render half): **this EVID + EVID-103 together close AC-1 (both clauses), AC-2, AC-3, FR-001, FR-002, FR-003, FR-004, FR-005, and NFR-002 for PRD-039.**
+- Scenario 6 additionally **re-confirms** AC-2/FR-003 (bidirectional sync) via a fresh interaction path (3D-corner click descending the 2D map), independent corroboration rather than new coverage.
+- Not addressed by this EVID (unchanged from EVID-103's scope): NFR-001 (bundle-size cap, owned by the companion ADR + EVID-099), NFR-003/NFR-004/NFR-005/NFR-006 (non-regression/idempotency/a11y/governance — covered by other EVIDs in the chain, not this browser-interaction pass), AC-4/AC-5/AC-6 (on-demand network trace beyond what EVID-103 captured, governance greps, quality-gate CI status).
+
+**Environment caveat (recorded honestly, matching EVID-103's disclosure):** this is a **dev-server manual capture** — a one-shot interaction-proof, not an automated regression guard. No Playwright test suite exists yet for the iso-map widget's depth/ascend/toggle interactions beyond unit-level tests (`iso-view-state.render.test.ts`, `shared-drill-bus.svelte.test.ts` referenced in EVID-100/101); a future regression in this exact interaction path would only be caught by another manual pass or a new automated test.
+
+## Recommended next steps
+
+- Re-run `guardian` on the PRD-039 / ADR-011 / RFC-036 chain — both gaps guardian's EVID-102 named (AC-3 interaction, AC-1 clause-2) are now closed by this EVID + EVID-103 together.
+- Consider promoting scenarios 1–8 above into a Playwright regression test for the iso-map widget's depth/ascend/toggle + view-swap behaviour, so this coverage is not solely a one-shot manual capture (per the environment caveat).
+- No further browser-interaction capture is needed for AC-1/AC-2/AC-3/FR-001..FR-005/NFR-002 on this PRD — remaining open items are NFR-001 (dist-size cap, ADR-gated) and the non-regression/governance/quality-gate EVIDs already tracked separately in the chain (EVID-099/100/101).
+
+## References
+
+- Parent: `PRD-039`
+- Related EVIDENCE: `EVID-103` (render-proof + on-demand-load + AC-2 sync — the sibling capture this EVID completes), `EVID-099` (build/cap/svelte-check/SSR measurement), `EVID-100` / `EVID-101` (code review + re-review), `EVID-102` (guardian gate CONCERNS — named the two gaps this EVID closes)
+- Related ADR: `ADR-011` (lazy three.js/Threlte chunk, dist-cap raise 3→3.5 MiB)
+- Related RFC: `RFC-036` (lazy 3D iso-map widget, shared-drill-bus)
+
+## Structured Fields
+
+verdict: supports
+congruence_level: 3
+evidence_type: test
+
diff --git a/.forgeplan/evidence/EVID-107-guardian-re-gate-2nd-of-prd-039-adr-011-rfc-036-3d-iso-map-chain-pass-both-evid-105-gaps-closed-verified-in-source.md b/.forgeplan/evidence/EVID-107-guardian-re-gate-2nd-of-prd-039-adr-011-rfc-036-3d-iso-map-chain-pass-both-evid-105-gaps-closed-verified-in-source.md
new file mode 100644
index 0000000..241173a
--- /dev/null
+++ b/.forgeplan/evidence/EVID-107-guardian-re-gate-2nd-of-prd-039-adr-011-rfc-036-3d-iso-map-chain-pass-both-evid-105-gaps-closed-verified-in-source.md
@@ -0,0 +1,173 @@
+---
+depth: standard
+id: EVID-107
+kind: evidence
+last_modified_at: 2026-07-08T15:31:04.150285+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: PRD-039
+  relation: informs
+- target: RFC-036
+  relation: informs
+- target: ADR-011
+  relation: informs
+status: draft
+title: 'Guardian re-gate (2nd) of PRD-039/ADR-011/RFC-036 (3D iso-map chain): PASS — both EVID-105 gaps closed, verified in source'
+---
+
+## Verdict
+
+**PASS**
+
+- **PASS** — orchestrator may activate the chain via `forgeplan_activate`. **(THIS VERDICT)**
+- CONCERNS — *(not this — both gaps EVID-105 held open are now genuinely closed with real, independently-verified evidence.)*
+- BLOCKER — *(not this — zero BLOCKER anywhere in the chain; foundation sound, all HIGH/MED findings closed, all MUST validation green, R_eff > 0 on all three, ADR-011 revisit triggers unfired, fully reversible.)*
+
+One-line justification: this is the 2nd guardian re-gate; it supersedes-in-spirit **EVID-105** (CONCERNS). Independent verification confirms the exact two items EVID-105 held open are now closed with substance, not prose — **EVID-104** is now a fully-filled rule-22 governance audit (no longer the placeholder-brace stub, validates 0/0 clean, PASS · supports · CL3 · measurement, M1–M6 re-verified by me against source), and **EVID-106** is a real Playwright interaction proof (PASS · supports · CL3 · test, 7 fingerprinted screenshots, AC-3 + AC-1-clause-2 exercised with DOM-state assertions, backing source tokens re-verified). No BLOCKER in the chain; no unresolved HIGH CONCERNS; all activation-policy criteria met.
+
+## Methodology
+
+- **Re-run (2nd)** of the pre-activation gate on the 3D-iso chain. Generator≠verifier applied strictly: I read every artifact + every linked EVID body directly, and **independently re-ran the code/regex/link checks against commit `3e948dd` in the working tree** rather than trusting the dispatch prose. Working tree confirmed on `feat/idef0-3d-iso-view` @ `3e948dd6785c0eaa366395c062366f14e045a9e3` (`git branch --show-current` + `git rev-parse HEAD`) — matching every EVID's recorded head.
+- **project-config:** `.forgeplan/project-config.yaml` **not found** (confirmed by `ls`; only `.forgeplan/config.yaml` exists, no `quality_gates:` key) → **HARD RULE 7 conservative defaults applied** (`min_test_coverage=80`, `max_findings_critical=0`, `max_findings_high=3`, `max_findings_medium=10`, `require_validate_pass=true`, `require_audit_pass=true`, `require_evidence_chain=[prd,rfc,adr,spec]`).
+- **`mm-gate-failures` mental model: ABSENT (HTTP 404)** — recorded honestly (HARD RULE 6). `memory_recall` (mid budget) returned no gate-failure regret contradicting a PASS; it reinforced two relevant facts: [mem-13] an EVID's own r_eff is always 0 — R_eff is a property of the *decision* (parent), so EVID-104/105/106 showing r_eff 0.0 is normal, and the parents' 0.30/0.70/0.30 are what rule-11 reads; [mem-7] guardian never calls `forgeplan_activate` (I do not).
+- **`forgeplan_reason` gate:** all three artifacts are `standard` depth (ADI recommended, not required, per CLAUDE.md routing). Workspace-MCP `forgeplan_reason` returns "LLM provider unavailable" (documented infra gap across PRD-037/038/039). ADI was run manually in-body and is substantive (PRD-039: 3 cycles, 3 hypotheses each; ADR-011: 3 options, Trust Calculus F+G+R=20≥14; RFC-036: 3 options). Treated satisfied-in-spirit — consistent with both prior guardian passes (EVID-102, EVID-105).
+- **Ship gates (Step 4):** `package.json#scripts["check:ready-to-ship"]` absent; `Makefile` absent → recorded `skipped (not present)`, not fabricated. `forgeplan` CLI on PATH. Build/quality gate not re-run here — it is the tester's recorded job: EVID-099 measured `npm run build` exit 0 (both images 3.29 MiB < 3.5 cap), `svelte-check` 0 errors, `vitest` 782/782; EVID-102 re-ran 798/798. Re-running would duplicate a recorded reviewer, not add signal.
+
+## Artifacts under review
+
+| ID | Kind | Status | R_eff (live) | Title |
+|---|---|---|---|---|
+| `PRD-039` | prd | draft | **0.30** | 3D isometric layered overview minimap for the composed-map view |
+| `ADR-011` | adr | draft | **0.70** | Ship three.js + Threlte lazy client chunk; raise per-image dist cap 3 → 3.5 MiB |
+| `RFC-036` | rfc | draft | **0.30** | Lazy 3D iso-map widget, 2D-synced via a three-free shared-drill-bus |
+
+- The 0.30 on PRD-039/RFC-036 is the **structural CL-penalty floor** from the `based_on` chain to the active parent PRD-036, **not** weak feature evidence (as the dispatch and EVID-105 both note). All three R_eff are fresh and **> 0** — rule-11 / Red-Line-3 "no activate at R_eff==0" is **not** tripped.
+- Parent lineage: `PRD-039 --based_on--> PRD-036` (**active**); `RFC-036 --based_on--> PRD-039`, `--refines--> ADR-011`, `--informs--> SPEC-006`; `ADR-011 --based_on--> PRD-036`, `--informs--> PRD-039` and `--informs--> PRD-030`. Parent-active activation policy satisfied (verified via `forgeplan_graph`).
+
+## EVIDENCE chain inspected (chronological, all `informs`-linked, verified via `forgeplan_graph`)
+
+| EVID | Body verdict | Structured (v·CL·type) | Source role | Critical finding (one-line) |
+|---|---|---|---|---|
+| `EVID-099` | CONCERNS | supports · CL3 · measurement | tester | Build PASS 3.29 MiB < 3.5 cap (both images); svelte-check 0; vitest 782/782; SSR three-free (0 markers in `dist/index.js`); 808 KiB lazy chunk. Flagged AC-1/AC-3 UI + AC-5 governance not run. *(gaps now closed downstream)* |
+| `EVID-100` | CONCERNS | weakens · CL3 · audit | code-reviewer | 7 findings incl. #1 HIGH sync-drop race, #2 HIGH zero-tests, #3 MED WebGL-init, #4–7 doc drift. *(historical — pre-fix)* |
+| `EVID-101` | CONCERNS | weakens · CL3 · audit | code-reviewer (re-review) | #1/#2/#3 CLOSED non-vacuously; #4 doc drift 3/4 closed, RFC Function-Signatures then-open (since closed by RFC edit). *(historical)* |
+| `EVID-102` | CONCERNS | supports · CL3 · audit | **guardian (1st gate)** | Held on: AC-5 rule-22 governance + AC-1/AC-3/FR-005 render-proof. Instructed: land both EVIDs, then re-run guardian. |
+| `EVID-103` | **PASS** (partial) | supports · CL3 · test | evidence-recorder (Playwright) | Closes AC-2 (bidirectional sync, both dirs), FR-005/NFR-002 (on-demand load), AC-1 render-half. Own table marks AC-3 + AC-1-clause-2 "NOT TESTED". |
+| `EVID-104` | **PASS** | supports · CL3 · measurement | security-expert (governance) | **NOW FILLED** — real rule-22 audit: 0 new server files, 1 read-only GET, isValidZoneId traversal-guard, 0 injection sinks, 0 three/@threlte advisories. Closes AC-5 governance half. |
+| `EVID-105` | CONCERNS | supports · CL3 · audit | **guardian (1st re-gate)** | Held on: (A) EVID-104 was then an empty template stub; (B) AC-3 + AC-1-clause-2 untested. **Both now closed — this EVID.** |
+| `EVID-106` | **PASS** | supports · CL3 · test | evidence-recorder (Playwright) | **NEW** — interaction proof: AC-3 depth 1/2/3 + toggle round-trip + ascend enable/disable; AC-1-clause-2 Force-view (iso3dCornerPresent=false, canvasCount=0, 2D minimap present). Closes both EVID-105 gaps. |
+
+**Chain state: 8 EVIDs — 0 BLOCKER, 5 CONCERNS (all historical / prior-guardian, each superseded-in-spirit by closure), 3 PASS.** No unresolved BLOCKER; every CONCERNS traces to an item now verified closed.
+
+## Independent verification (generator≠verifier — I checked source at `3e948dd`, not the prose)
+
+### Gap A closure — EVID-104 is now a real rule-22 audit (was an empty stub in EVID-105)
+
+| EVID-104 claim | My independent method | Result |
+|---|---|---|
+| EVID-104 no longer a placeholder stub | `forgeplan_validate EVID-104` | ✅ PASS **0 errors / 0 warnings** — the `{placeholder}` braces EVID-105 caught would fail `no-placeholders`; they are gone. Body is fully filled (M1–M6, ground-truth, STRIDE/OWASP walk). |
+| M1: iso feature touched no server surface | `git diff --name-status f0ffeb7..3e948dd -- template/src/routes/api/ template/src/shared/server/` | ✅ **EMPTY** — no server file in the iso range. |
+| M2: exactly one client sink, a GET | `grep -RInE "spawn\|execFile\|fetch(\|writeFileSync\|POST\|PUT\|DELETE" widgets/iso-map/ + shared-drill-bus` | ✅ **1 production sink**: `iso-view-state.svelte.ts:367 fetch(\`/api/map/layers/${encodeURIComponent(zoneId)}\`)` — default GET, no method/body override. Other hits = 1 test comment + a `Map.delete()` (not HTTP DELETE). |
+| M3: no injection / alt-transport | `grep -RInE "eval(\|new Function\|innerHTML\|XMLHttpRequest\|WebSocket\|EventSource\|sendBeacon\|new Worker\|importScripts" widgets/iso-map/` | ✅ **NONE (clean)**. |
+| M4: `[zone]` endpoint GET-only + traversal-guarded | read `routes/api/map/layers/[zone]/+server.ts` + `shared/server/map.ts` | ✅ exports **only** `GET`; rejects `!isValidZoneId(zone)` with `error(400)` **before** fs access; `isValidZoneId = ZONE_ID_RE.test(zone) && !zone.includes("..")` where `ZONE_ID_RE = /^[a-zA-Z0-9._-]+$/`; unit tests confirm `../../etc/passwd`, `a/b`, `z..decisions`, `..` all → false. |
+
+**Gap A verdict: CLOSED.** EVID-104 is substantive and its load-bearing claims reproduce exactly against source. For a rule-22 "prove **zero** new attack surface" governance audit, zero enumerated findings is the *correct* PASS outcome — a finding would mean NFR-006 failed. The adversarial depth is the affirmative falsification of each threshold (M1–M6) + disclosed residual risks (6 pre-existing toolchain advisories, dev-only `server.fs.strict`, `isValidZoneId` MVP scope, static-only review). The "thin-PASS/zero-findings → CONCERNS" modifier is a false positive here and does **not** fire.
+
+### Gap B closure — EVID-106 exercises AC-3 + AC-1-clause-2 (was untested in EVID-105)
+
+| EVID-106 claim | My independent method | Result |
+|---|---|---|
+| AC-3 controls exist in source | `git ls-tree -r 3e948dd \| grep IsoControls` | ✅ `widgets/iso-map/ui/IsoControls.svelte` present. |
+| AC-1-clause-2 view-conditional exists | read `widgets/dependency-graph/ui/DependencyGraph.svelte` lines 219-226 | ✅ verbatim `{#if view === 'map'} <IsoMapCorner /> {:else} <Minimap … /> {/if}` — three mounts on Map view only; non-Map views keep the 2D `<Minimap>`. |
+| Lazy load + honest fallback backing FR-005/FR-007 | read `IsoMapCorner.svelte` | ✅ `browser ? import('@/widgets/iso-map') : null` (l.22, browser-guarded dynamic import) + `<svelte:boundary>` `{#snippet failed()}` (l.39-44). |
+| iso-spike route deleted (source of the unrelated console noise) | `git ls-tree -r 3e948dd \| grep -c routes/iso-spike` | ✅ **0 files** — the `IsoScene/ZONE_HIT_OPACITY` console errors EVID-106 saw cannot be current code; deletion committed, as claimed. |
+| Screenshots real | (recorded by EVID-106) 7 files sha256+byte fingerprinted | ✅ recorded in EVID-106 with a DOM-state scenario table (depth 2→1 pressed-state move; toggle hide/show round-trip; ascend disabled@root → enabled after 3D-corner descend → disabled after climb; Force-view `browser_evaluate` iso3dCornerPresent=false / canvasCount=0 / minimap present). |
+
+**Gap B verdict: CLOSED.** AC-3 (FR-004: depth 1/2/3 + ascend + show/hide toggle) and AC-1 second clause (non-Map minimap unchanged, three never mounts off-Map) are demonstrated with DOM assertions + fingerprinted screenshots, and the backing source mechanisms reproduce exactly.
+
+### Still-true from EVID-105 (re-confirmed)
+
+| Claim | Method | Result |
+|---|---|---|
+| EVID-100 #1 sync-drop race fixed | verified by EVID-101/102/105 (`pendingExternal` + `$effect.root` settle-retry in `iso-view-state.svelte.ts`) | ✅ CLOSED |
+| EVID-100 #3 WebGL boundary fixed | `IsoMapCorner.svelte` `<svelte:boundary>`+`failed()` (l.39-44, re-read this run) | ✅ CLOSED |
+| EVID-100 #2 zero-tests fixed | `shared-drill-bus.svelte.test.ts` + `iso-view-state.render.test.ts` present at commit; 16 cases; full suite 782–798 green | ✅ CLOSED |
+| RFC↔code drift (#4) | RFC-036 Function-Signatures == shipped bus exports (`sharedFocusChain`/`focusTo`/`chainsEqual`) | ✅ CLOSED |
+| R_eff > 0 (rule 11) | `forgeplan_get` r_eff | ✅ 0.30 / 0.70 / 0.30 |
+| MUST validation | `forgeplan_validate` ×5 | ✅ PRD-039 0/0; RFC-036 0 MUST (1 SHOULD = intentional `TODO(iso-*)`); ADR-011 0 MUST (1 SHOULD same); EVID-104 0/0; EVID-106 0/0 |
+| ADR-011 revisit triggers | parse `## Compliance / Revisit Trigger` | ✅ metric (image>3.5MiB) NOT fired (3.29 MiB); event (three dropped) NOT fired; date 2027-01-08 future. No `[x]`, no DATE-FIRED. F+G+R=20≥14, ADR <30d old → no decay. |
+
+## Gate criteria
+
+| # | Criterion | Status | Notes |
+|---|---|---|---|
+| 1 | Artifact MUST validation (×3 + 2 new EVIDs) | ✅ | 0 MUST errors each; SHOULD warnings on RFC/ADR are the intentional `TODO(iso-adr/iso-promote/iso-draco-basis)` code-marker refs, not stubs; EVID-104 now 0/0 (stub gone) |
+| 2 | Required reviewer EVIDENCE linked | ✅ | tester (099) + code-review (100/101) + guardian (102/105) + render-proof (103/106) + **governance (104, now real)** — the gap crit-2 flagged in EVID-105 is closed |
+| 3 | No BLOCKER in chain | ✅ | 0 BLOCKER verdicts; all HIGH/MED findings independently verified CLOSED |
+| 4 | Unresolved HIGH-severity CONCERNS | ✅ (0) | #1/#2 HIGH → CLOSED; #3 MED → CLOSED; #4 doc → CLOSED; EVID-105's two gaps → CLOSED |
+| 5 | Activation policy satisfied | ✅ | PRD-039 AC-1..AC-6 now honestly closed; R_eff>0 ✅; ADI sound ✅; parent PRD-036 active ✅ |
+| 6 | Project-specific gates | ✅ / N/A | build/cap/svelte-check/SSR-exclusion green (EVID-099); `check:ready-to-ship`/`Makefile` = skipped (not present) |
+| 7 | Blast radius within stated threshold | ✅ | additive, read-only, Map-view-scoped, reversible — matches artifact claims |
+| 4b | Linked-ADR revisit triggers | ✅ | ADR-011 metric/event/date triggers all UNfired; F+G+R=20, <30d — no decay |
+
+### Project-config gates (`.forgeplan/project-config.yaml` **absent** → HARD-RULE-7 defaults)
+
+Config source: **not found — conservative defaults applied**.
+
+| Criterion | Threshold (default) | Observed | Result |
+|---|---|---|---|
+| Test coverage | ≥80% (`min_test_coverage`) | not reported as % (tester gave pass counts 782/782, 798/798; load-bearing bus + iso-view-state have 16 dedicated unit tests) | ⚠️ unverifiable (informational — no measured value *below* floor; critical path is covered) |
+| Critical findings | ≤0 | 0 | ✅ |
+| High findings | ≤3 | 2 (both CLOSED; 0 unresolved) | ✅ |
+| Medium findings | ≤10 | 1 (CLOSED; 0 unresolved) | ✅ |
+| Validate pass | required | 5/5 PASS | ✅ |
+| Audit pass (≥1 Profile B EVID body-verdict PASS) | required | EVID-103, **EVID-104**, EVID-106 all body-verdict PASS | ✅ |
+| Evidence chain | required for prd/rfc/adr | 8 EVIDs; governance EVID now substantive | ✅ |
+
+**Gates summary: 7/7 green** (source: defaults; only coverage-% unverifiable, informational — not a measured breach). No project-config signal forces CONCERNS or BLOCKER.
+
+## Blast radius
+
+- **Affected scope on activation:** the read-only forgeplan-web **viewer** (client-side), **Map view only**. The 3D overview replaces the flat 2D minimap in the Map-view corner only; every other view + its 2D minimap is byte-unchanged (FR-006, and now interaction-verified for the Force view by EVID-106). No production data path, no host mutation.
+- **Reversibility:** **fully reversible by design** — ADR-011 + RFC-036 both carry a 4–5-step rollback (drop `IsoMapCorner` dynamic import → 2D fallback; delete widget + bus; revert cap commit `a6ef030`; drop `three`/`@threlte`). Prior "Force 3D" revert (`7f907dd`) proves the pattern clean. **Not a one-way door.**
+- **Server / governance surface:** exactly **one** new call site — a client `fetch()` GET to the **existing** read-only `/api/map/layers/<zone>` (traversal-guarded by `isValidZoneId`). **0** new endpoints / spawn / write / external-network in the iso code — now **formally recorded** in EVID-104 (was only my spot-check in EVID-105). rule-22 holds.
+- **Packaging:** +~808 KiB irreducible lazy `three` chunk; both images **3.29 MiB**, ~220 KiB margin under the raised **3.5 MiB** cap. Cap bump is a real +0.5 MiB governance-slack widening (ADR-011 DD-5/INV-3 acknowledges it; residual PRD-030/rule-21 cap-text editorial drift is a tracked fix-forward, not a blocker).
+- **Downstream:** ADR-011 `informs` PRD-030's cap NFR (amends, not supersedes); RFC-036 `refines` ADR-011; shared-drill-bus contends with PRD-038's onboarding-tour camera (RFC-036 R-6 / PRD-039 Q4 — flagged **unresolved**, tracked, not silently assumed).
+- **Detection time if wrong:** viewer-only, no prod data path → a regression is caught by the next manual pass or a future Playwright suite (only unit-level tests + one-shot manual captures exist for the iso widget today).
+- **Threshold check:** actual blast radius (additive, read-only, Map-view-scoped, reversible) **matches** the artifacts' stated claims — no scope broadening. Does not downgrade the verdict.
+
+## Orchestrator instructions
+
+**PASS → the orchestrator MAY activate the chain.** Recommended activation order (dependency-respecting): **`forgeplan_activate PRD-039` → `forgeplan_activate RFC-036` → `forgeplan_activate ADR-011`** (PRD first as the product parent; RFC realizes it; ADR is the companion decision — order among them is not load-bearing since all three parents are draft and mutually consistent, but activate PRD-039 no later than RFC-036 which is `based_on` it). No further reviewer dispatch is required before activation — both EVID-105 gaps are closed, all HIGH/MED findings are closed, all five artifacts validate clean, R_eff>0 on all three, ADR-011 triggers are unfired, and the design is reversible.
+
+Immediately before each `forgeplan_activate`, re-confirm `forgeplan_score <id> > 0` (get/list can serve a stale r_eff until reindex — mem-13). This EVID recorded live scores 0.30/0.70/0.30.
+
+**Post-activation (non-blocking fix-forward, do NOT hold activation for these):**
+1. Editorial drift: update PRD-030 NFR-001/SC-4 text, `.claude/rules/21-template-purity.md` cap text (3 → 3.5 MiB), and the `a6ef030` code comment's mis-cited "NFR-005" → "NFR-001 per ADR-011" (ADR-011 Open-Questions tracks this).
+2. Unresolved product question: PRD-039 Q4 / RFC-036 R-6 — shared-focus-chain vs PRD-038 onboarding-tour camera hand-off. Carry as tracked risk.
+3. Optional hardening: promote EVID-106's manual interaction capture into a Playwright regression test for the iso-widget depth/ascend/toggle + view-swap path (the coverage is currently a one-shot manual capture).
+
+## Notes
+
+- This verdict **supersedes-in-spirit EVID-105** (and EVID-102): the specific remediation items each named are now closed and re-verified. This is the designed "re-run guardian after fixes land" flow, not a waiver of a prior CONCERNS.
+- **C4-diagram heuristic (informational, NOT a verdict driver):** ADR-011/RFC-036 discuss ≥3 modules (iso-map / composed-map / dependency-graph) with no `docs/c4/ADR-011.md` and no inline `mermaid` C4/flowchart. Read literally, the generic C4 modifier would raise CONCERNS — but this repo's **house rule is a prose Component Diagram** (RFC-036 states "no drawn diagram per house rule"), which RFC-036 satisfies with a detailed prose topology + Data Flow + Data-direction line, and the "modules" are internal FSD widget folders, not distinct services. EVID-105's independent guardian reached the same non-blocking conclusion. Surfaced for an optional `/c4-diagram` follow-up; **does not downgrade the binary verdict.**
+- **FPF ADI discipline:** this workspace has no `adi`/`hypotheses` artifact kind and `forgeplan_reason` is infra-unavailable; the ≥3-hypothesis discipline is satisfied via substantive manual ADI in each body (PRD-039 3 cycles; ADR-011 F+G+R=20≥14; RFC-036 3 options). Standard depth = ADI recommended, not required. Satisfied-in-spirit, consistent with EVID-102/105 — not a BLOCKER.
+- No `supersedes` link on any of the three → OpenSpec delta-spec modifier does not apply. No claim collision on the chain (claims=0 at dispatch; I hold only PRD-039). `mm-gate-failures` absent (404) recorded honestly. `.forgeplan/.lock` was free this run.
+
+## References
+
+- Artifacts under review: `PRD-039`, `ADR-011`, `RFC-036`
+- EVIDENCE chain: `EVID-099`, `EVID-100`, `EVID-101`, `EVID-102` (guardian 1st), `EVID-103`, `EVID-104` (governance — now substantive), `EVID-105` (guardian re-gate — superseded-in-spirit by this), `EVID-106` (interaction proof)
+- Parent: `PRD-036` (active)
+- Prior guardian EVIDs for this chain: `EVID-102`, `EVID-105`
+- Independent runs this gate: `git branch/rev-parse` (head = 3e948dd); `git ls-tree 3e948dd` (iso-map 21 files, IsoControls present, iso-spike 0 files); `git diff f0ffeb7..3e948dd -- routes/api shared/server` (empty); rule-22 + injection greps over `widgets/iso-map/`; reads of `[zone]/+server.ts`, `shared/server/map.ts` (isValidZoneId + ZONE_ID_RE), `DependencyGraph.svelte` (view conditional l.219-226), `IsoMapCorner.svelte` (lazy import + boundary); `forgeplan_validate` ×5; `forgeplan_graph` (link verify)
+- Mental models consulted: `mm-gate-failures` (absent — 404); `memory_recall` (mid) — EVID-r_eff-always-0, guardian-never-activates
+
+## Structured Fields
+
+verdict: supports
+congruence_level: 3
+evidence_type: audit
+
+
+
diff --git a/.forgeplan/prds/PRD-039-3d-isometric-layered-overview-minimap-for-the-composed-map-view.md b/.forgeplan/prds/PRD-039-3d-isometric-layered-overview-minimap-for-the-composed-map-view.md
new file mode 100644
index 0000000..1ca381c
--- /dev/null
+++ b/.forgeplan/prds/PRD-039-3d-isometric-layered-overview-minimap-for-the-composed-map-view.md
@@ -0,0 +1,436 @@
+---
+depth: standard
+id: PRD-039
+kind: prd
+last_modified_at: 2026-07-08T01:27:46.769244+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: PRD-036
+  relation: based_on
+status: active
+title: 3D isometric layered overview minimap for the composed-map view
+---
+
+# PRD-039: 3D isometric layered overview minimap for the composed-map view
+
+> **Shaping note (SPARC Specification phase).** This is the SHAPE step for the 3D isometric
+> layered overview built this session on branch `feat/idef0-3d-iso-view`. Functional requirements
+> are phrased as observable capability; the rendering technique is stated as a capability ("3D
+> isometric rendering", "on-demand-loaded render chunk") and **no library or framework is named**
+> per rule 11 (no implementation leakage in FRs). Author leaves this `draft` — activation belongs
+> to the orchestrator + guardian after an EvidencePack (rule 11, R_eff > 0).
+>
+> **ADI note (HARD RULE 2).** `forgeplan_reason PRD-036` was invoked on the lineage parent and
+> returned *"LLM provider unavailable or not configured"* — the same workspace-MCP reasoning gap
+> PRD-037 / PRD-038 recorded. The Abduction → Deduction → Induction cycle was therefore run
+> **manually** over the three genuinely contested design surfaces before finalising the acceptance
+> criteria; it is recorded in **§ ADI reasoning (manual)** below and folded into the FRs, Open
+> Questions, and Constraints.
+
+## Problem
+
+The composed-map view (PRD-036, the 9th graph view) renders the project as a **single flat plane**:
+zones, node cards, edges, flows. Phase 2 (PRD-037 / RFC-031) made deeper levels reachable by
+drill-down (descend / climb / breadcrumb), but the altitude a user is *at* and the altitudes
+*above and below* it are never visible **at the same time**. A newcomer landing on a large
+multi-level map cannot see the shape of the whole layered system — "this is a 3-level project,
+here is the top, here is where I am, here is what is underneath" — from the flat view; they only
+ever see one slice, and the corner navigation minimap (the reused host `Minimap`, bottom-right on
+the Map view) is itself only a flat thumbnail of the current slice.
+
+This is a **comprehension-at-altitude** gap, adjacent to the Phase-3 onboarding work (PRD-038) but
+distinct: PRD-038 walks a newcomer *through* one plane over time; this feature lets them *see the
+stack of planes* at once and jump between altitudes directly from the overview. Parent lineage:
+**EPIC-001 T4** → **PRD-036** (Phase-1 render-proof, `based_on`), reusing the Phase-2 drill-down
+seam (PRD-037 / RFC-031).
+
+Trigger: the Phase-1/2 composed map and its drill-down have landed and map-pack v0.7.1 now emits
+multi-level material (per-zone `.forgeplan/map/layers/<zone>.json`), so a layered overview finally
+has real depth to depict; the arc branch `feat/idef0-3d-iso-view` stacks on that work.
+
+## Goals
+
+Observable outcomes, not implementation:
+
+- **Goal 1 — See the whole layered stack at a glance.** On the Map view, a user sees a 3D
+  isometric "exploded pyramid" overview in the bottom-right corner (in place of the flat 2D
+  navigation minimap **on that view only**): the top level plus deeper levels exploded downward,
+  ancestor levels receding to faint frame outlines and the focused level shown in full detail.
+- **Goal 2 — Navigate altitudes from the overview.** Clicking a zone or layer in the 3D overview
+  descends into it, and the flat 2D map follows into the same zone; conversely, drilling or
+  climbing in the flat 2D map moves and re-focuses the 3D overview — both surfaces stay locked to
+  one shared focus.
+- **Goal 3 — Control how deep the overview shows.** A small control sets the visible depth to 1, 2,
+  or 3 levels and offers an ascend action, and the whole 3D overview can be hidden or shown by a
+  toggle.
+- **Goal 4 — Pay the 3D cost only when it is used.** The 3D rendering loads on demand only when the
+  Map view is opened; the other views carry no cold-start cost from it.
+- **Goal 5 — No regression, no new trust surface.** The flat 2D composed map is unchanged; every
+  other view (and its own 2D minimap) is unchanged; the feature adds no browser-initiated mutation
+  and reads only the same read-only map data the flat view already reads.
+
+## Non-Goals / Out of scope
+
+- **Out of scope — replacing the flat 2D composed map.** The 3D overview is a **minimap-scale
+  navigation aid**, not a replacement for the flat 2D map. The main flat composed-map canvas
+  (zones/cards/edges/flows, click-to-detail, drill-down) stays the primary reading surface and is
+  **unchanged**.
+- **Out of scope — any view other than the Map view.** The 3D overview replaces the corner 2D
+  minimap **only on the Map (composed-map) view**. Every other graph view that renders the 2D
+  navigation minimap keeps it byte-identical; no other view gains a 3D surface. (Informatively, the
+  2D minimap continues to render on the other graph views that showed it — this feature touches
+  none of them.)
+- **Out of scope — any change to the map document or layer schema.** The 3D overview reads the
+  fields map-pack already emits (`forgeplan.map/v1` + per-zone layers); it introduces no schema
+  change and no new emitter output.
+- **Out of scope — any browser-initiated forgeplan mutation or new server surface.** The overview
+  reuses the existing GET-only read-only endpoints (`/api/map`, `/api/map/layers/<zone>`); rule 22
+  is untouched — no new endpoint, no spawn, no write, no network.
+- **Out of scope — deciding the packaged-image size-cap outcome.** The added 3D render chunk raises
+  the packaged image size and presses against PRD-030's per-image dist-size cap; **this PRD states
+  that constraint only.** The cap decision (stretch the cap / split / exclude the chunk) is
+  recorded in a **companion ADR** and is explicitly **not decided here**.
+- **Out of scope — motion polish** beyond "works + honors reduced-motion": easing curves,
+  fly-in of a revealed sub-level, and camera-orbit affordances are deferred.
+- **Out of scope — spawning any agent / model call.** The overview is a pure client-side render of
+  read-only data; it invokes no model and no subprocess.
+
+## Target users / actors
+
+- **Newcomer** on a large, multi-level forgeplan-instrumented workspace — primary consumer; needs
+  to see the shape of the whole layered system and jump into an altitude directly from the
+  overview.
+- **Returning maintainer** — uses the 3D overview to move quickly between altitudes without losing
+  the sense of where a level sits in the stack.
+- **The composed-map view (system actor)** — hosts the 3D overview in its bottom-right minimap slot
+  (Map view only) and owns the single shared focus-chain that keeps 3D and 2D locked together.
+- **The on-demand render chunk (system actor)** — the 3D rendering, loaded lazily only when the Map
+  view opens; absent from the initial load of every other view.
+- **The read-only web server process (system actor)** — serves the same map document + emitted
+  per-zone layers read-only; it is unaware the 3D overview exists.
+- **Reviewer / guardian agents** — verify Map-view-only scope, on-demand load, rule-22 read-only
+  compliance, no-regression of the flat map and other views, and the packaged-size delta against
+  the PRD-030 cap.
+
+## Functional Requirements
+
+Capability language only; component/file mapping is informative and lives in
+Constraints → Affected surfaces. Priorities: `must` / `should` / `could`.
+
+### FR-001 — 3D isometric layered overview in the Map view's minimap corner (Map-view only)
+- **Description**: On the composed-map (Map) view, the system shall render a 3D isometric layered
+  overview in the bottom-right minimap corner **in place of** the flat 2D navigation minimap. This
+  replacement shall apply to the Map view **only**; on every other view the 2D navigation minimap
+  shall render unchanged.
+- **Priority**: must
+- **Acceptance criteria**:
+  - Given the Map view is selected, when it renders, then the bottom-right corner shows the 3D
+    isometric layered overview and not the flat 2D minimap.
+  - Given any non-Map view that renders the 2D minimap, when it is selected, then its minimap is
+    identical to the base branch (no 3D surface appears).
+
+### FR-002 — Layered planes rendered from the same read-only map data
+- **Description**: The overview shall render the **same** data the flat 2D view reads — the
+  read-only composed-map document plus its per-zone emitted layers — as **stacked isometric
+  planes**: the top level plus deeper levels exploded downward. Ancestor levels (above the focused
+  level) shall recede to **faint frame outlines**; the **focused** level shall be shown in full
+  detail.
+- **Priority**: must
+- **Acceptance criteria**:
+  - Given a multi-level map, when the overview renders, then the focused level appears in full
+    detail and each ancestor level appears as a faint frame outline offset in the isometric stack.
+  - Given the same document the flat 2D view is rendering, when the overview reads it, then the
+    overview depicts the same zones/levels the flat view is showing (no divergent data source).
+
+### FR-003 — Bidirectional drill synchronization via a shared focus-chain
+- **Description**: Clicking a zone or layer in **either** the 3D overview **or** the flat 2D map
+  shall descend **both** surfaces into that zone; ascending or collapsing in **either** shall drive
+  the other; and the 3D overview shall highlight and expand to the flat 2D map's current focus.
+  Both surfaces shall be driven by a **single shared focus-chain** (one source of truth), so they
+  can never show divergent foci.
+- **Priority**: must
+- **Acceptance criteria**:
+  - Given a zone visible in the 3D overview, when the user clicks it, then the flat 2D map descends
+    into that zone and the 3D overview highlights/expands to it — both reflecting the same focus.
+  - Given the user drills or climbs in the flat 2D map, when the focus changes, then the 3D
+    overview moves and re-focuses to match, with no manual re-sync.
+  - Given a descend followed by an ascend on either surface, when it completes, then both surfaces
+    return to the same prior focus (the sync is stable — no runaway loop, no drift).
+
+### FR-004 — Depth control (visible levels + ascend) and a show/hide toggle
+- **Description**: The overview shall provide a small control that sets the visible depth to 1, 2,
+  or 3 levels and offers an **ascend** action, and a separate toggle that **hides or shows** the
+  whole 3D overview.
+- **Priority**: must
+- **Acceptance criteria**:
+  - Given the depth control, when the user selects a visible depth of 1, 2, or 3, then the overview
+    shows exactly that count of levels of the stack.
+  - Given the ascend action, when activated, then the shared focus climbs one level and both
+    surfaces reflect it (FR-003).
+  - Given the show/hide toggle, when toggled off then on, then the 3D overview is hidden then
+    restored without disturbing the flat 2D map's state.
+
+### FR-005 — On-demand loading of the 3D render chunk
+- **Description**: The 3D rendering shall be loaded **on demand only when the Map view is opened**.
+  Opening any other view shall **not** load the 3D render chunk, so no other view pays a cold-start
+  cost for it.
+- **Priority**: must
+- **Acceptance criteria**:
+  - Given the app is opened on any non-Map view, when it loads, then the 3D render chunk is not
+    fetched (verifiable from a network/asset trace).
+  - Given the user then opens the Map view, when it renders, then the 3D render chunk is fetched at
+    that point and the overview appears.
+
+### FR-006 — Additive, zero-regression integration
+- **Description**: The feature shall be **additive**: the flat 2D composed map (zones, cards, edges,
+  flows, click-to-detail, drill-down) and all other views (including their own 2D minimaps) shall
+  render and behave exactly as on the base branch. The overview shall own its own render surface and
+  never share render state with the flat views beyond the shared focus-chain.
+- **Priority**: must
+- **Acceptance criteria**:
+  - Given the flat 2D composed map, when rendered with the overview present, then its zones/cards/
+    edges/flows/click-to-detail/drill-down behave identically to the base branch.
+  - Given each of the other view ids, when selected, then rendering (including any 2D minimap) is
+    identical to the base branch.
+
+### FR-007 — Honest fallback when the 3D surface is unavailable
+- **Description**: When the environment cannot provide a 3D render surface, the Map view shall
+  degrade honestly — either falling back to the flat 2D navigation minimap or showing an explicit
+  "3D overview unavailable" state — and shall **never** break the flat 2D composed map or leave the
+  corner in a broken state.
+- **Priority**: should
+- **Acceptance criteria**:
+  - Given a Map view where the 3D render surface cannot initialise, when it loads, then the flat 2D
+    map still renders fully and the corner shows either the 2D minimap fallback or an explicit
+    unavailable state (no crash, no blank/broken corner).
+
+## Non-Functional Requirements
+
+### NFR-001 — Shipped-bundle-size impact vs the active per-image dist-size cap
+- **Category**: performance / packaging
+- **Threshold**: The on-demand 3D render chunk raised the packaged image size. It shall be tracked
+  against the **active per-image dist-size cap** — PRD-030 **NFR-001 / SC-4** and rule 21: *each
+  emitted `dist*/` image directory ≤ 3 MB, asserted in `scripts/build.mjs`*. The measured packaged
+  size delta of the 3D chunk is **TBD** (measured at prove-phase, never invented). **This PRD does
+  not decide the cap outcome**: whether the added chunk fits within the ≤ 3 MB cap, requires the cap
+  to stretch, or requires the chunk to be split/excluded is recorded in a **companion ADR** — the
+  PRD states the constraint; the ADR decides. On-demand loading (FR-005) defers the chunk's
+  *runtime* cost off non-Map views but does **not** remove its *packaged* cost, which still counts
+  against the per-image cap.
+- **Measurement**: `du -sb dist*/` (the existing build-pipeline assertion) before publish, plus the
+  measured 3D-chunk size delta recorded in the prove-phase EvidencePack; the cap resolution is
+  verified against the companion ADR before activation.
+
+### NFR-002 — On-demand load / no cold-start cost on non-Map views
+- **Category**: performance
+- **Threshold**: Opening any non-Map view incurs **zero** load or initialisation cost from the 3D
+  render chunk (it is not fetched, parsed, or initialised until the Map view opens). Map-view first
+  render of the overview on the reference machine within **TBD ms** (budget set from the measured
+  baseline in the RFC, not guessed).
+- **Measurement**: network/asset trace showing the chunk absent on non-Map view load; manual timing
+  of Map-view overview first render recorded in the EvidencePack.
+
+### NFR-003 — Non-regression
+- **Category**: reliability
+- **Threshold**: All pre-existing template static checks and tests stay green; the flat 2D composed
+  map, the Phase-2 drill-down, every other view, and every other view's 2D minimap behave unchanged
+  (FR-006).
+- **Measurement**: CI `svelte-check` (0 errors) + unit suite (`vitest`, 0 failures); manual smoke
+  across all view ids + the drill-down path.
+
+### NFR-004 — Focus-chain synchronization consistency
+- **Category**: reliability
+- **Threshold**: The bidirectional 3D↔2D sync is driven by a single shared focus-chain and is
+  **idempotent**: a click/descend/ascend on one surface reconciles the other without a feedback
+  loop, without drift, and without divergent foci; the same interaction sequence yields the same
+  final focus on both surfaces every time.
+- **Measurement**: unit tests over the shared focus-chain reducer (same interaction sequence → same
+  final focus; a descend then ascend returns to the prior focus; no re-entrant emit loop).
+
+### NFR-005 — Theming, accessibility, motion
+- **Category**: accessibility
+- **Threshold**: Zero raw color literals in the new overview components (token-only, dual-theme
+  correct with no caller intervention, neutral chrome §16 preserved); the depth control, ascend
+  action, and show/hide toggle are keyboard-reachable; a **reduced-motion** preference snaps the
+  explode/camera motion with **0 ms** animation.
+- **Measurement**: grep for hex/rgb literals in the new components; manual keyboard + reduced-motion
+  pass on the Map view; dual-theme check.
+
+### NFR-006 — Governance (rule 22, read-only)
+- **Category**: security
+- **Threshold**: The feature adds **0** new server endpoints, **0** browser-initiated forgeplan
+  mutations, and **0** spawn/write/network call sites; it reads only the existing GET-only
+  `/api/map` + `/api/map/layers/<zone>` responses.
+- **Measurement**: rule-22 verification greps (spawn/execFile/fetch/write scans over route +
+  `shared/server` files); reviewer diff check before merge.
+
+## Constraints
+
+### Technical
+- **Rule 22 (read-only proxy).** No new server surface: the overview consumes the existing GET-only
+  `/api/map` and `/api/map/layers/<zone>` file mirrors; no spawn, no write, no network.
+- **Rule 11 (no implementation leakage).** FRs name the capability ("3D isometric rendering",
+  "on-demand-loaded render chunk"), never a specific library/framework/graphics API.
+- **Rule 23 (`bin/` allow-list) untouched.** The 3D overview is a `template/`/web concern; nothing
+  is added to `bin/` (still `node:*` + `citty` only).
+- **Rule 21 (template purity), rule 24 (shared/ui ownership), FSD layering** apply to all new files;
+  token-only colors from the app stylesheet; dual-theme; neutral zone chrome (§16) preserved.
+- **Reuse, don't fork.** The overview reuses the same read-only map data + emitted per-zone layers
+  the flat view reads (the RFC-031 `deriveSubDocument` / prefer-emitted-layer seam), and lives in
+  the composed-map view's existing bottom-right minimap slot (the reused host `Minimap` slot per
+  RFC-030 — replaced on the Map view only).
+- **PRD-030 per-image dist-size cap (≤ 3 MB, `scripts/build.mjs` assertion / rule 21)** is the live
+  packaging constraint the added 3D chunk pressures (NFR-001).
+
+### Affected surfaces (informative — not requirements)
+- New: an on-demand-loaded 3D overview widget under the composed-map widget (its own isometric
+  render surface + depth control + show/hide toggle), plus a shared focus-chain module driving both
+  the 3D overview and the flat 2D map's drill/select state.
+- Touched: the composed-map view's minimap slot wiring (Map-view-only swap of the 2D minimap for the
+  3D overview); the drill/select state so the flat 2D map and the 3D overview read one shared focus;
+  app stylesheet tokens for the isometric chrome; the build/lazy-load wiring for the on-demand
+  chunk; `package.json#files` / image manifests if the chunk affects packed size (per the companion
+  ADR).
+- Out of this repo: the `forgeplan-map-pack` emitter (`map.json`, per-zone layers) — unchanged.
+
+### Business
+- Additive to the T4 program; nothing here regresses PRD-036/037/038 surfaces.
+- The dist-size-cap outcome is **ADR-gated** (companion ADR), not decided in this PRD.
+- Author leaves this PRD `draft`; the orchestrator + guardian own activation after an EvidencePack
+  (rule 11, R_eff > 0).
+
+### Regulatory
+- None external. Internal bars: reduced-motion honored on the explode/camera motion; depth control
+  and toggle keyboard-reachable; neutral token-only theming.
+
+## SMART Acceptance Criteria (ship-or-not for this arc)
+
+Each is Specific, Measurable, Achievable, Relevant, and Time-bound (bound to the
+`feat/idef0-3d-iso-view` arc PR, matching the repo convention in PRD-036 / PRD-037 / PRD-038).
+
+1. **AC-1 — layered overview, Map-view only (FR-001, FR-002):** On the Map view with a multi-level
+   map loaded, the bottom-right corner shows the 3D isometric layered overview (focused level in
+   full detail, ancestor levels as faint frame outlines, deeper levels exploded downward) and **not**
+   the flat 2D minimap; on every other view the 2D minimap renders unchanged — demonstrated
+   end-to-end before the arc PR merges.
+2. **AC-2 — bidirectional drill sync (FR-003):** Clicking a zone in the 3D overview descends the
+   flat 2D map into that zone **and** the 3D expands/highlights to it; drilling or climbing in the
+   flat 2D map moves the 3D overview to match; a descend-then-ascend returns both surfaces to the
+   same prior focus (no loop, no drift) — verified end-to-end + by focus-chain unit tests before the
+   arc PR merges.
+3. **AC-3 — depth control + toggle (FR-004):** The depth control sets a visible depth of 1, 2, or 3
+   levels, the ascend action climbs one level in both surfaces, and the show/hide toggle hides then
+   restores the 3D overview without disturbing the flat 2D map — verified by a manual pass before
+   the arc PR merges.
+4. **AC-4 — on-demand load + zero regression (FR-005, FR-006):** A network/asset trace shows the 3D
+   render chunk is **not** fetched when any non-Map view is opened and **is** fetched only when the
+   Map view opens; and the flat 2D composed map, the drill-down, and all other views (with their 2D
+   minimaps) render exactly as on the base branch — verified in CI/review before the arc PR merges.
+5. **AC-5 — governance & bundle-size constraint (NFR-001, NFR-006):** rule-22 greps report 0 new
+   server endpoints and 0 spawn/write/network call sites; and the packaged per-image size is
+   measured (`du -sb dist*/`) with the 3D-chunk delta recorded in the prove-phase EvidencePack and
+   reconciled against the active ≤ 3 MB cap via the **companion ADR** (linked before activation) —
+   the PRD does not decide the cap outcome.
+6. **AC-6 — quality gate:** `svelte-check` reports 0 errors and the unit suite (`vitest`) reports 0
+   failures on the arc branch at PR time.
+
+## ADI reasoning (manual — `forgeplan_reason` unavailable)
+
+Manual Abduction → Deduction → Induction over the three genuinely contested surfaces. Hidden
+assumptions surfaced and conflicts flagged, folded into the FRs/NFRs/Open Questions.
+
+### Cycle 1 — Where the 3D overview lives
+- **Abduction.** H1: replace the flat 2D navigation minimap in the Map view's existing bottom-right
+  corner (Map-view only). H2: a separate full-screen 3D mode/route. H3: a translucent 3D overlay on
+  top of the flat 2D canvas.
+- **Deduction.** H2 duplicates navigation and competes with the Phase-3 `/onboard` surface (PRD-038);
+  H3 occludes the flat map that must stay the primary reading surface. H1 reuses the minimap slot
+  the host already renders (RFC-030 "zero new minimap code"), keeps the change Map-view-scoped, and
+  keeps the flat map fully visible.
+- **Induction.** **H1.** Hidden assumption surfaced: the minimap slot is **Map-view-specific**, so
+  every other view keeps its 2D minimap untouched — hence FR-001's Map-view-only clause and FR-006
+  zero-regression.
+
+### Cycle 2 — Drill coupling between 3D and 2D
+- **Abduction.** H1: bidirectional sync via a single shared focus-chain (either surface drives
+  both). H2: 3D is a passive follower of the 2D map only. H3: 3D navigates independently of the 2D
+  map.
+- **Deduction.** H2 loses "click the overview to navigate" — the whole point of an overview. H3
+  yields two divergent foci (the overview and the flat map disagree → confusion). H1 makes one
+  focus-chain the single source of truth that reconciles both.
+- **Induction.** **H1.** Conflict flagged (**C-2**): a naive two-way binding risks a
+  click→descend→re-render→re-emit **sync loop** — mitigated by an **idempotent** focus-chain reducer
+  (NFR-004).
+
+### Cycle 3 — Bundle cost of the 3D rendering
+- **Abduction.** H1: an on-demand render chunk loaded only when the Map view opens. H2: the 3D
+  rendering inlined into the base bundle for every image. H3: a separate opt-in image (a `dist-*`
+  track) that carries the 3D rendering.
+- **Deduction.** H2 pays a cold-start on all other views and inflates **every** image toward the
+  ≤ 3 MB cap for users who never open the Map view. H3 fragments the install UX that PRD-030 just
+  consolidated. H1 keeps the other views cold-start-free (FR-005) — but the chunk **still ships in
+  the tarball**, so it still counts against PRD-030's per-image size cap.
+- **Induction.** **H1** for load behaviour. Hidden assumption surfaced: "on-demand" defers the
+  chunk's **runtime** cost, **not** its **packaged** cost — so the cap tension is real (**C-1**) and
+  is deferred to a **companion ADR** (this PRD states the constraint only, NFR-001).
+
+### Conflicts flagged (carried into Open Questions / NFRs)
+- **C-1** (Cycle 3): PRD-030 NFR-001/SC-4 per-image ≤ 3 MB cap vs the added 3D render chunk raising
+  packaged size → deferred to the companion ADR (**Q1**); PRD states the constraint, ADR decides.
+- **C-2** (Cycle 2): 3D↔2D sync-loop risk → idempotent shared focus-chain (**NFR-004**).
+- **C-3**: reduced-motion vs the explode/camera animation → 0 ms snap (**NFR-005**).
+- **C-4**: the shared focus-chain (this feature) vs the Phase-3 onboarding tour + Tier-1
+  `show_on_map` camera (PRD-038) both wanting to move the view → hand-off unresolved (**Q4**).
+
+## Open Questions
+
+- **Q1 (dist-size-cap outcome) — companion ADR.** Does the on-demand 3D chunk fit within PRD-030's
+  per-image ≤ 3 MB cap, or must the cap stretch / the chunk be split or excluded from the packed
+  image? **Not decided in this PRD.** — owner: companion ADR.
+- **Q2 (measured packaged-size delta).** The measured size the 3D chunk adds to the packed image
+  (NFR-001 number) — measured at prove-phase, recorded in the EVID, never invented. — owner:
+  RFC / EVID.
+- **Q3 (depth-control defaults).** The default visible depth on Map-view open (1, 2, or 3 levels)
+  and whether more than 3 levels are ever addressable. — owner: RFC.
+- **Q4 (focus-chain hand-off).** When the shared focus-chain, the Phase-3 onboarding tour, and the
+  Tier-1 `show_on_map` camera (PRD-038) all want to move the view, who drives and how do they hand
+  off? — owner: RFC.
+- **Q5 (3D-unavailable fallback UX).** The exact fallback when a 3D render surface cannot initialise
+  (fall back to the 2D minimap vs an explicit unavailable state) (FR-007). — owner: RFC.
+
+## Related Artifacts
+
+- **PRD-036** (`based_on` — Phase-1 render parent): Composed-map graft + onboarding (T4). Provides
+  the 9th "map" view and the bottom-right minimap slot this feature replaces **on the Map view
+  only**; the edges-only compatibility + additive-registration + zero-regression discipline carries
+  forward (FR-006).
+- **PRD-037 / RFC-031** (Phase-2 drill-down): the recursive descend/climb + `deriveSubDocument` /
+  prefer-emitted-layer seam whose focus this feature extends into the shared bidirectional
+  focus-chain (FR-003).
+- **PRD-038** (Phase-3 onboarding + live guide): the onboarding tour + Tier-1 `show_on_map` camera
+  the shared focus-chain must hand off with (Q4).
+- **SPEC-006 / RFC-030**: the `forgeplan.map/v1` render contract + §15 nav/interaction; the layered
+  planes read the same document + emitted per-zone layers — **no schema change**.
+- **PRD-030 (NFR-001 / SC-4)** + **rule 21** (`.claude/rules/21-template-purity.md`): the active
+  per-image ≤ 3 MB dist-size cap (asserted in `scripts/build.mjs`) the added 3D chunk pressures
+  (NFR-001).
+- **Rule 22** (`.claude/rules/22-readonly-proxy.md`): the read-only proxy boundary — untouched (no
+  new server surface; reuses `/api/map` + `/api/map/layers/<zone>`).
+- **Companion ADR (planned, draft-only)** — resolves the dist-size-cap tension (Q1 / C-1); the
+  size-cap decision lives there, **not** in this PRD.
+- **EvidencePack** — prove-phase evidence (bidirectional 3D↔2D sync + on-demand load trace +
+  measured packaged-size delta + no-regression smoke), minted at prove-phase and linked `informs`
+  before any activation (rule 11, R_eff > 0).
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/.forgeplan/rfcs/RFC-036-lazy-3d-iso-map-widget-in-the-map-minimap-corner-2d-synced-via-a-three-free-shared-drill-bus-singleton.md b/.forgeplan/rfcs/RFC-036-lazy-3d-iso-map-widget-in-the-map-minimap-corner-2d-synced-via-a-three-free-shared-drill-bus-singleton.md
new file mode 100644
index 0000000..ae4d507
--- /dev/null
+++ b/.forgeplan/rfcs/RFC-036-lazy-3d-iso-map-widget-in-the-map-minimap-corner-2d-synced-via-a-three-free-shared-drill-bus-singleton.md
@@ -0,0 +1,551 @@
+---
+depth: standard
+id: RFC-036
+kind: rfc
+last_modified_at: 2026-07-08T10:31:08.754877+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: PRD-039
+  relation: based_on
+- target: ADR-011
+  relation: refines
+- target: SPEC-006
+  relation: informs
+status: active
+title: Lazy 3D iso-map widget in the Map minimap corner, 2D-synced via a three-free shared-drill-bus singleton
+---
+
+# RFC-036: Lazy 3D iso-map widget in the Map minimap corner, 2D-synced via a three-free shared-drill-bus singleton
+
+## Status
+
+draft
+
+> Author leaves this RFC in `draft`. Activation is reviewer + guardian territory and requires a linked
+> EvidencePack (rule 11, R_eff > 0) — not performed here.
+>
+> **ADI note (HARD RULE 2).** `forgeplan_reason PRD-039` was invoked for this RFC and returned
+> *"LLM provider unavailable or not configured"* — the same workspace-MCP reasoning gap PRD-037 /
+> PRD-038 / PRD-039 / ADR-011 all recorded. The gate is mandatory and was invoked; because the
+> provider is unavailable at the MCP layer (an infra gap, not a skipped gate), the
+> Abduction → Deduction → Induction cycle was run **manually** over the genuinely contested
+> render/mount surfaces and is folded into **§ Options Considered** below.
+>
+> **Doc-accuracy reconciliation (EVID-101 Finding — shared-drill-bus API drift).** The
+> Function-Signatures section and the flows around it were reconciled to the **shipped**
+> `widgets/composed-map/model/shared-drill-bus.svelte.ts`: the bus exposes exactly
+> `sharedFocusChain(): string[]` (reactive read), `focusTo(next): void` (the single content-guarded
+> write), and `chainsEqual(a,b): boolean` (the loop guard) — it holds the focus **chain only**.
+> Depth (1/2/3) and show/hide are local to the 3D view (`iso-map/model/iso-view-state` + `IsoControls`),
+> not the bus; descend/ascend are consumer-level semantics (each surface computes the next chain and
+> calls `focusTo`), not bus methods. No source code changed — this edit only aligns the documented
+> contract to reality.
+
+## Summary
+
+Realize PRD-039's 3D isometric "exploded-pyramid" layered overview as an **on-demand-loaded widget
+mounted in the Map view's bottom-right minimap corner only**, driven by a **plain-data shared
+focus-chain singleton** (`shared-drill-bus`) that keeps the flat 2D composed map and the 3D overview
+locked to one focus **bidirectionally** — while keeping `three` + `@threlte/*` out of the SSR server
+bundle and behind a single lazy client chunk.
+
+Three load-bearing design commitments:
+
+1. **Mount by gate, not by fusion.** A thin `IsoMapCorner` component sits in the minimap slot and
+   dynamic-imports the 3D widget **only when `view === 'map'`**; on every other minimap-bearing view
+   the existing flat 2D `Minimap` renders unchanged. The main 2D `ComposedMapView` is **untouched**.
+2. **A three-free shared bus is the single source of truth.** `shared-drill-bus.svelte.ts` is a
+   plain-data module singleton holding the shared focus-**chain only** (`string[]`). It imports **no**
+   `three` / `@threlte`, so the 2D + SSR render path stays three-free; both `ComposedMapView` (2D) and
+   `iso-view-state` (3D) read it via `sharedFocusChain()` and write it via `focusTo(chain)`. A
+   descend/ascend gesture on either surface computes the next focus chain locally and broadcasts it
+   with `focusTo`; the other surface reacts and the 3D highlights and expands to the shared focus.
+   Depth (1/2/3) and show/hide are the 3D view's own local state — not on the bus.
+3. **The 3D is a parallel renderer over the same drill machinery.** It reuses `computeComposedLayout`,
+   `deriveSubDocument`, `buildLevelDocuments`, and the `drill-state` seam (RFC-031) and the same
+   read-only `/api/map` + `/api/map/layers/<zone>` data (SPEC-006) — **no schema change, no new
+   server surface**.
+
+This RFC documents the design **as built** on branch `feat/idef0-3d-iso-view` (an RFC MAY name
+libraries; PRD-039 may not). The packaging decision (ship `three`+Threlte as a lazy chunk in the
+default image; raise the per-image dist cap 3 → 3.5 MiB) is **inherited from ADR-011** — this RFC
+`refines` it into a concrete render/mount architecture rather than re-deciding it.
+
+## Motivation
+
+PRD-039 identifies a **comprehension-at-altitude** gap: the flat composed-map view (PRD-036) shows a
+single altitude at a time; drill-down (PRD-037 / RFC-031) makes deeper levels *reachable* but never
+shows the altitude you are at together with the ones above and below. PRD-039 FR-001..FR-007 ask for
+a 3D isometric overview in the Map-view minimap corner that (a) shows the whole layered stack at once,
+(b) navigates altitudes bidirectionally with the flat map, (c) offers a depth control + show/hide
+toggle, (d) loads on demand only on Map-view open, and (e) regresses nothing.
+
+Those requirements pose three architecture questions the PRD deliberately left to this RFC:
+
+- **Where does the 3D surface mount** without touching the flat map or the other views? (PRD-039
+  FR-001/FR-006; Q3 depth defaults.)
+- **How do 3D and 2D share one focus** without a sync loop or divergent foci, and without dragging
+  `three` into the 2D/SSR path? (PRD-039 FR-003 / NFR-004; Q4 focus-chain hand-off.)
+- **How is the 3D render surface degraded** when WebGL is unavailable? (PRD-039 FR-007; Q5.)
+
+ADR-011 already fixed the *packaging* answer (lazy chunk in the default image, cap 3 → 3.5 MiB, `three`
+out of SSR). This RFC fixes the *render/mount* answer and the shared-focus contract, and realizes the
+ADR's invariants (INV-1 SSR-free, INV-2 lazy-only, INV-4 read-only) as concrete module boundaries.
+
+## Module Breakdown
+
+Narrow, cohesive modules. New unless marked *reused*.
+
+- **`widgets/iso-map/`** — the 3D overview widget (graduated from the throwaway `/iso-spike` route,
+  now removed). Owns the entire 3D render surface. Sub-modules:
+  - **`ui/IsoMinimap.svelte`** — container-sized host; subscribes the **shared `mapPoller`**
+    (RFC-030 SD-1, *reused*) and passes the `MapDocument` down. The 3D analogue of the flat
+    minimap host.
+  - **`IsoScene.svelte`** — Threlte composition root: the `<Canvas>`, `OrthographicCamera`,
+    `OrbitControls`, and interactivity wiring. The single place that touches the WebGL context.
+  - **`ui/*` (single-responsibility scene parts)** — `IsoPlane`, `IsoZoneFrame`, `IsoNodeBox`,
+    `IsoFrustum`, `IsoIcomArrows`, `IsoControls` (depth 1/2/3 + ascend + show/hide), `IsoSliverPlane`,
+    `IsoDeeperMarker`, `IsoA11yProxy` (keyboard-reachable proxy for the canvas controls), and
+    `IsoNodeCard` / `IsoLayerCard` / `IsoLeaderLine` (gated behind `showInfoCards=false` — present but
+    off by default).
+  - **`lib/iso-projection`** — *pure* geometry: FIPS-183 non-centered plane nesting, the dashed
+    frustum, and the ICOM arrows. No THREE object construction; coordinates only.
+  - **`lib/iso-materials`** — token → `THREE.Color`, the matte material, and per-level depth falloff
+    (ancestor planes fade to faint frames).
+  - **`lib/motion`**, **`lib/leader-line`** — explode/camera motion (reduced-motion aware) and
+    leader-line geometry.
+  - **`model/iso-view-state.svelte.ts`** — the 3D drill/animation state; **owns the depth-window
+    (1/2/3) + show/hide visibility locally (never shared)**, and reads `sharedFocusChain()` / writes
+    `focusTo(...)` for shared focus.
+- **`widgets/composed-map/model/shared-drill-bus.svelte.ts`** — **the load-bearing new contract.** A
+  **plain-data** module singleton holding **only** the shared focus-chain (`string[]`, root→focus
+  ids). Exposes exactly `sharedFocusChain()` (reactive read), `focusTo(next)` (the single
+  content-guarded write), and `chainsEqual(a,b)` (the loop guard). **Depth (1/2/3) and the show/hide
+  flag are NOT here** — they are local state in the 3D view (`iso-map/model/iso-view-state` +
+  `IsoControls`). Imports **no** `three` / `@threlte` (this exclusion is the whole point — it keeps
+  the 2D/SSR path three-free). Read and written by both the 2D and 3D surfaces.
+- **`widgets/dependency-graph/ui/IsoMapCorner.svelte`** — the **mount gate**. Dynamic-imports
+  `widgets/iso-map` and renders it in the bottom-right corner **only when `view === 'map'`**; on the
+  other minimap-bearing views (the flat 2D `Minimap`, *reused, unchanged*) it does nothing. This is
+  the sole `three`/`@threlte` reachability point in the static graph.
+- **`template/vite.config.ts`** *(touched)* — a `resolve.alias` stub for the unused
+  `@threlte/extras` draco/basis loaders (~1.5 MiB) + the `ssr=false` / browser-guard wiring that keeps
+  `three` out of `dist/index.js`.
+- **`scripts/build.mjs`** *(touched)* — `IMAGE_DIST_MAX_BYTES` raised 3 → 3.5 MiB (already applied in
+  commit `a6ef030`, per ADR-011).
+- **`template/package.json`** *(touched)* — `three` + `@threlte/*` added to `#dependencies` (runtime
+  deps of the web app, rule 21).
+- **Reused, unchanged:** `computeComposedLayout`, `deriveSubDocument`, `buildLevelDocuments`,
+  `drill-state` (RFC-031), the `mapPoller` (RFC-030 SD-1), `entities/map` transport + validator
+  (SPEC-006), and the flat `ComposedMapView` + 2D `Minimap`.
+
+## Component Diagram (prose)
+
+Topology in words (no drawn diagram per house rule):
+
+> The **`mapPoller`** (RFC-030) fetches the read-only `MapDocument` from `GET /api/map` (and per-zone
+> layers from `GET /api/map/layers/<zone>`) and publishes it. Two consumers read that document:
+> **`ComposedMapView`** (the flat 2D map, unchanged) and **`IsoMinimap`** (the 3D host).
+>
+> Both consumers read and write **one** shared object — **`shared-drill-bus`** — which holds the
+> focus-chain (root → current focus) **only** and is the single source of truth for shared focus.
+> **Visible depth (1/2/3) and the hidden flag are NOT on the bus; they are local state in the 3D
+> view's `iso-view-state` + `IsoControls`.** The bus is plain data and imports no 3D code, so it is
+> reachable from the SSR/2D graph without pulling `three`. It exposes exactly `sharedFocusChain()`
+> (read), `focusTo(next)` (write), and `chainsEqual(a,b)` (guard).
+>
+> The 3D surface is reachable **only** through **`IsoMapCorner`**, which `import()`s
+> `widgets/iso-map` lazily and browser-guarded, and renders it **only when the active view is
+> `map`**. Inside, **`IsoScene`** builds the Threlte `<Canvas>` (OrthographicCamera + OrbitControls);
+> **`iso-view-state`** reads the bus's focus-chain via `sharedFocusChain()`, calls `buildLevelDocuments` +
+> `computeComposedLayout` per level, lifts each 2D layout into an isometric plane via
+> `lib/iso-projection`, and renders the stack (focused level in full detail via `IsoPlane` /
+> `IsoNodeBox`; ancestor levels as faint `IsoZoneFrame` outlines via `iso-materials` depth falloff;
+> deeper levels exploded downward). A click on an `IsoZoneFrame` / `IsoNodeBox` computes the next
+> chain (`sharedFocusChain()` + the clicked zone id) and calls `focusTo(nextChain)` — a no-op if
+> `chainsEqual` finds the chain unchanged; both `ComposedMapView` and `iso-view-state` re-derive from
+> the new focus-chain. **Descend/ascend are consumer-level, not bus methods.** `IsoControls` mutates
+> the 3D view's **local** depth-window and visibility state (never the bus); ascend is the one control
+> that touches shared focus — it computes the parent chain and calls `focusTo(parentChain)`.
+>
+> If the WebGL context / Threlte init fails, `IsoMapCorner` catches it and renders the flat 2D
+> `Minimap` instead (FR-007) — the flat composed map is never affected.
+
+**Data direction:** `mapPoller → {ComposedMapView, IsoMinimap}`; `{ComposedMapView, iso-view-state} ↔
+shared-drill-bus` (bidirectional, via `sharedFocusChain()` read + `focusTo()` write);
+`IsoMapCorner → dynamic import → IsoScene → three/@threlte` (one-way, lazy, browser-only).
+
+## Data Flow
+
+**Primary flow — descend from the 3D overview (happy path, FR-003).**
+User clicks a zone frame in the 3D overview. `IsoScene`'s interactivity resolves the click to a real
+`zoneId`, computes the next chain (the current `sharedFocusChain()` with the clicked zone id
+appended), and calls `focusTo(nextChain)`. `focusTo` content-compares the incoming chain against the
+current one via `chainsEqual` and is a **no-op** (no new array, no reactive notification) when they
+match — the loop guard (NFR-004). Both surfaces are reactive readers via `sharedFocusChain()`:
+`ComposedMapView` re-runs its drill derivation (`deriveSubDocument` → `computeComposedLayout`) and
+descends the flat map into the zone; `iso-view-state` re-runs `buildLevelDocuments(doc,
+sharedFocusChain())`, re-projects the stack, highlights the newly-focused plane, and expands to it.
+One user action, one `focusTo` write, two reactive re-derivations — the `chainsEqual` guard plus each
+view's reconciliation `$effect` pair (OUTBOUND/INBOUND, living in `ComposedMapView.svelte` /
+`IsoMinimap.svelte`) prevents any re-emit back into the bus; a chain change that arrives
+mid-animation is held pending and retried on animation-settle, which is how the two surfaces converge
+without a loop.
+
+**Mirror flow — drill/climb from the flat 2D map.**
+User drills or climbs in `ComposedMapView`. `ComposedMapView` computes its next chain (append the
+drilled zone id to descend; drop the tip to climb) and writes it via the same `focusTo`;
+`iso-view-state` reacts through `sharedFocusChain()` and moves/re-focuses the 3D overview to match,
+with no manual re-sync. A descend-then-ascend on **either** surface returns both to the same prior
+focus (the chain is treated as a stack by the consumers — descend appends an id, ascend `focusTo`s the
+parent chain).
+
+**Depth + visibility flow (FR-004).**
+`IsoControls` sets the 3D view's **local** depth-window (1/2/3 — the overview shows exactly that many
+levels of the stack) and toggles its **local** visibility (hide/show the 3D overview) — **neither
+touches the bus**, which is precisely why they never disturb the flat map's state. Only **ascend**
+touches shared focus: it computes the parent chain and calls `focusTo(parentChain)`, and both
+surfaces reflect it.
+
+**Named failure path — 3D surface unavailable (FR-007).**
+`IsoMapCorner`'s dynamic import or `IsoScene`'s WebGL/Threlte init throws. `IsoMapCorner` catches,
+does not propagate, and renders the flat 2D `Minimap` (or an explicit "3D overview unavailable"
+state). The flat composed map and every other view are untouched; the corner is never left broken.
+
+**Cold-start exclusion (FR-005 / NFR-002).**
+On any non-Map view, `IsoMapCorner` never reaches its dynamic `import()`, so the `three`/`@threlte`
+chunk is never fetched, parsed, or initialised. On Map-view open, the import resolves and the chunk is
+fetched at that point.
+
+## Function Signatures / Component Contracts
+
+Public surface as built (Svelte 5 runes idiom; the `.svelte.ts` singleton exposes reactive `$state`
+via a getter + a single mutator + a pure guard).
+
+**The shared bus — `widgets/composed-map/model/shared-drill-bus.svelte.ts` (the new contract).** A
+plain-data singleton over `let chain = $state<string[]>([])`; the chain holds plain zone/node **ids**
+(root excluded, deepest entry last — the same shape `drill-state.ts#focusChain(levelStack)` returns),
+not objects. Exactly three exports:
+
+- `sharedFocusChain(): string[]` — reactive read of the shared chain; call from inside an `$effect` /
+  `$derived` to track changes. It is named `sharedFocusChain`, **not** a bare `focusChain`, to avoid
+  colliding with `drill-state.ts`'s unrelated `focusChain(levelStack)` (a per-view *local* chain
+  derivation) that the same call sites already import.
+- `focusTo(next: readonly string[]): void` — the **single** mutation: set the shared chain to an
+  explicit value. **Content-guarded** — a no-op (no new array, no reactive notification) when
+  `chainsEqual(current, next)`. The internal comparison read is wrapped in `untrack` so calling
+  `focusTo` from inside a reactive `$effect` (as both consuming views do) never makes that effect an
+  accidental subscriber of the bus's own state.
+- `chainsEqual(a: readonly string[], b: readonly string[]): boolean` — content-equality guard used by
+  `focusTo` and by each view's reconciliation effects to suppress redundant re-fires.
+- **Not on the bus:** depth (1/2/3) and the show/hide flag — those live in the 3D view's own local
+  state (`iso-map/model/iso-view-state.svelte.ts` + `IsoControls`), never shared. **Descend/ascend
+  are consumer-level semantics, not bus methods:** each surface computes the next chain (append the
+  target id to descend; drop the tip to ascend) and calls `focusTo(nextChain)`; the bus has no
+  per-action mutators.
+- **Invariant:** imports no `three` / `@threlte` — enforced by review + the SSR-marker test hook.
+
+**The mount gate — `widgets/dependency-graph/ui/IsoMapCorner.svelte`:**
+
+- Reads the active `view`. When `view === 'map'`: `const { default: IsoMinimap } = await
+  import('$widgets/iso-map')` (browser-guarded) → render it. Otherwise: render nothing (the flat 2D
+  `Minimap` owns the slot on other views). Catches import/init failure → 2D `Minimap` fallback
+  (FR-007).
+
+**The 3D host — `widgets/iso-map/ui/IsoMinimap.svelte`:**
+
+- Subscribes the shared `mapPoller` (RFC-030 SD-1), sizes to its container, and passes the
+  `MapDocument` to `IsoScene`. Contract mirrors the flat minimap host so the slot swap is transparent.
+
+**The composition root — `widgets/iso-map/IsoScene.svelte`:**
+
+- Props: `{ doc: MapDocument }`. Builds `<Canvas>` + `OrthographicCamera` + `OrbitControls`; reads
+  `sharedFocusChain()` for the shared focus and the 3D view's **local** depth-window for how many
+  levels to show; on click it computes the next chain and calls `focusTo(nextChain)`. The **only**
+  module that touches the WebGL context.
+
+**Pure geometry — `widgets/iso-map/lib/iso-projection`:**
+
+- `projectLevel(layout: ComposedLayout, level: number, depth: number) -> IsoPlane` — lift a 2D
+  `ComposedLayout` (SPEC-006 C3) into a stacked isometric plane (FIPS-183 non-centered nesting).
+- `buildFrustum(from: IsoPlane, to: IsoPlane) -> DashedFrustum` — the dashed connector between
+  altitudes.
+- `icomArrows(plane: IsoPlane) -> IcomArrow[]` — the ICOM arrows. All pure — no THREE, no DOM, no
+  clock; deterministic like `computeComposedLayout`.
+
+**Materials — `widgets/iso-map/lib/iso-materials`:**
+
+- `tokenToColor(token: string, theme: 'light' | 'dark') -> THREE.Color` — resolves an app style token
+  (never a raw hex) into a THREE color, dual-theme correct (NFR-005).
+- `depthFalloff(levelsFromFocus: number) -> number` — opacity/detail falloff so ancestor planes
+  recede to faint frames.
+
+**Reused, unchanged (SPEC-006 / RFC-031):**
+
+- `computeComposedLayout(canvas, composition, zones, nodes) -> ComposedLayout` — pure layout
+  (SPEC-006 C3), run per level.
+- `deriveSubDocument(doc, focus) -> MapDocument` and `buildLevelDocuments(doc, chain) ->
+  MapDocument[]` — the RFC-031 drill seam (prefer emitted `/api/map/layers/<zone>`, else derive);
+  `buildLevelDocuments` is fed the value of `sharedFocusChain()`.
+
+## Options Considered
+
+Manual Abduction → Deduction → Induction over the two genuinely contested render/mount surfaces
+(`forgeplan_reason` unavailable — see Status). The *packaging* option space (inline vs lazy chunk vs
+opt-in image, and the cap bump) was already decided in **ADR-011** and is **not re-litigated** here;
+this RFC's decision space is the **mount topology** and the **3D↔2D sync mechanism**.
+
+### Option 1 — Corner gate + three-free plain-data shared bus (CHOSEN, as built)
+
+`IsoMapCorner` dynamic-imports the 3D widget and mounts it in the minimap slot **only on the Map
+view**; a plain-data `shared-drill-bus` singleton (no `three` import) is the single source of truth
+that both the 2D `ComposedMapView` and the 3D `iso-view-state` read and write bidirectionally.
+
+- **Pros:**
+  - Keeps the mount **Map-view-scoped and additive** — `ComposedMapView` and every other view's 2D
+    minimap are byte-untouched (FR-006). The slot swap is invisible to the flat map.
+  - The **three-free bus** is what makes ADR-011 INV-1 (0 `three` markers in `dist/index.js`)
+    achievable at the *module* level: the 2D/SSR reader of shared focus never transitively imports 3D
+    code.
+  - One source of truth ⇒ the two surfaces **cannot show divergent foci** (FR-003); the
+    **content-guarded `focusTo`** (via `chainsEqual`) guards the click→re-render→re-emit loop
+    (NFR-004).
+  - `IsoMapCorner` is the single reachability chokepoint for `three`/`@threlte`, so the lazy boundary
+    (FR-005) and the honest fallback (FR-007) live in exactly one place.
+- **Cons:**
+  - Introduces a **widget → widget import** (`iso-map` reads `composed-map/model/shared-drill-bus`) —
+    an FSD lateral dependency (see Risks R-3); marked `// TODO(iso-promote)`.
+  - Two reactive readers of one mutable singleton demand disciplined content-equality guarding
+    (`chainsEqual` on both the write and the reconciliation effects) or the loop returns.
+
+### Option 2 — Mount the 3D inside `ComposedMapView`, sync via its existing drill-state
+
+Render the 3D surface as a child of `ComposedMapView` and reuse that component's own drill/select
+state as the shared focus, with no separate bus.
+
+- **Pros:** no new module; one component owns both surfaces; no widget→widget lateral import.
+- **Cons:** `ComposedMapView`'s import graph would then transitively reach `three`/`@threlte`, and
+  keeping that out of the SSR bundle becomes far more fragile — **directly threatens ADR-011 INV-1**.
+  It also violates FR-006's "flat 2D `ComposedMapView` unchanged" and couples the flat map's lifecycle
+  to WebGL availability, endangering the FR-007 fallback. **Rejected.**
+
+### Option 3 — 3D as a one-way follower of the 2D map (no shared writable bus)
+
+The 3D overview passively mirrors the flat map's focus (props-drilled copy); clicks in the 3D surface
+do not navigate.
+
+- **Pros:** trivially loop-free (data flows one way); simplest sync.
+- **Cons:** loses "click the overview to navigate" — the entire point of an **overview** (FR-003 AC-1
+  fails). A props-drilled copy also risks two foci drifting if the copy lags. **Rejected.**
+
+### Chosen
+
+**Option 1.** The manual ADI synthesis: only Option 1 satisfies the full FR set at once —
+Map-view-scoped additive mount (FR-001/FR-006), true bidirectional navigation from one source of
+truth (FR-003), a single chokepoint that makes lazy-load (FR-005) + honest fallback (FR-007) local,
+and — decisively — a **three-free shared bus** that keeps ADR-011 INV-1 (SSR three-free) reachable at
+the module level, which Option 2 structurally endangers. The one real cost (the widget→widget import,
+R-3) is bounded and carries an explicit promote-later TODO. This matches the as-built branch
+`feat/idef0-3d-iso-view`.
+
+## Proposed Direction
+
+### Mount + sync (the chosen architecture)
+
+Adopt Option 1 exactly as built: the `IsoMapCorner` gate, the `widgets/iso-map/` widget, and the
+plain-data `shared-drill-bus` singleton as the single source of truth for a bidirectionally-synced
+**focus-chain** (`sharedFocusChain()` read / `focusTo(next)` write / `chainsEqual` guard). Depth
+control (1/2/3 + ascend) and the hide/show toggle live in the 3D view's own local state
+(`iso-view-state` + `IsoControls`), not the bus — only ascend touches shared focus, via
+`focusTo(parentChain)`. The 3D is a **parallel renderer over the same drill machinery**
+(`computeComposedLayout`, `deriveSubDocument`, `buildLevelDocuments`, `drill-state`, `mapPoller`) —
+**no schema change** (SPEC-006 `forgeplan.map/v1` consumed as-is).
+
+### Lazy-chunk boundary (the hexagonal port) + SSR-exclusion invariant
+
+`three` + `@threlte/*` form a **separate async client chunk** reachable **only** through the
+browser-guarded dynamic `import()` inside `IsoMapCorner`. The static import graph of `ComposedMapView`,
+the 2D `Minimap`, the `entities/map` poller/validator, and the `shared-drill-bus` contains **zero**
+`three`/`@threlte` references — that exclusion is what keeps the SSR server bundle
+(`dist/index.js`) three-free. The invariants are restated in **§ Invariants** below.
+
+`template/vite.config.ts` stubs the unused `@threlte/extras` draco/basis loaders (~1.5 MiB) via a
+`resolve.alias` to an empty module. **This alias is load-bearing** (Risk R-4): if a future
+`@threlte/extras` feature needs the real loaders, the stub silently breaks it —
+`// TODO(iso-draco-basis)` guards it.
+
+### Cap / bundle change (inherited from ADR-011)
+
+`scripts/build.mjs` `IMAGE_DIST_MAX_BYTES` is 3 → 3.5 MiB (already applied in commit `a6ef030`). This
+RFC does not re-decide it — it `refines` ADR-011. Measured this session: draco/basis stub −~1.5 MiB,
+`three` excluded from SSR, `three`+Threlte as a ~808 KiB lazy chunk, `dist/` **6.0 → ~3.4 MiB**. The
+**authoritative packaged-size delta is TBD** — measured at prove-phase (`du -sb dist*/`) and recorded
+in the EvidencePack (PRD-039 Q2 / AC-5), never invented here. The raised cap is **3.5 MiB, not a blank
+check** (ADR-011 INV-3): the build assertion still fires above 3.5 MiB.
+
+### Accessibility / theming / motion
+
+`iso-materials` resolves colors from app style tokens only (0 raw hex/rgb in new components,
+dual-theme). `IsoA11yProxy` + `IsoControls` keep the depth control, ascend, and show/hide toggle
+keyboard-reachable. A reduced-motion preference snaps the explode/camera motion to **0 ms**
+(NFR-005). The `showInfoCards=false` gate keeps `IsoNodeCard` / `IsoLayerCard` / `IsoLeaderLine`
+present-but-off by default.
+
+## Invariants
+
+What this design must NEVER violate (mirrors + extends ADR-011 INV-1..INV-4 at the module level):
+
+- **INV-A (= ADR-011 INV-1) — SSR three-free.** `dist/index.js` carries **0** `three` markers.
+  `three`/`@threlte` are reachable only via `IsoMapCorner`'s SSR-guarded (`ssr=false` + browser guard)
+  dynamic `import()`; `shared-drill-bus`, `ComposedMapView`, the 2D `Minimap`, and `entities/map`
+  import no 3D code.
+- **INV-B (= ADR-011 INV-2) — lazy-only.** The 3D rendering stays a **separate lazy client chunk**
+  loaded only on Map-view open — never inlined into the base bundle.
+- **INV-C — three-free shared bus.** `shared-drill-bus.svelte.ts` imports **no** `three`/`@threlte`
+  and is the single source of truth for shared focus — the focus-**chain** only
+  (`sharedFocusChain()` / `focusTo` / `chainsEqual`); depth and visibility are the 3D view's local
+  state, not shared. (This is what makes INV-A achievable at the module level.)
+- **INV-D — additive, flat-map untouched.** `ComposedMapView` and every non-Map view's 2D `Minimap`
+  render byte-identically to base (FR-006); the 3D swap is Map-view-scoped.
+- **INV-E — guarded sync.** The shared focus-chain reconciles both surfaces without a feedback loop,
+  drift, or divergent foci; `focusTo(currentChain)` is a content-guarded no-op via `chainsEqual` — no
+  new array, no reactive notification (NFR-004).
+- **INV-F (= ADR-011 INV-4) — read-only.** The overview is a pure client render of the existing
+  read-only `/api/map` + `/api/map/layers/<zone>` data — no new server surface, no spawn, no network
+  (rule 22).
+- **INV-G — cap is a bound, not a blank check.** No emitted image exceeds 3.5 MiB
+  (`IMAGE_DIST_MAX_BYTES`); the build assertion still fires above it (ADR-011 INV-3).
+
+## Implementation Phases
+
+The code exists as built on `feat/idef0-3d-iso-view`; these phases are the review/prove ordering the
+downstream pipeline should target, each independently verifiable.
+
+1. **Phase 1 — Shared contract + mount gate.** Land `shared-drill-bus.svelte.ts` (plain-data, three-
+   free) and `IsoMapCorner.svelte` (gate + dynamic import + 2D fallback). Verify: `ComposedMapView`
+   and all non-Map minimaps byte-unchanged (FR-006); bus unit tests (`focusTo` content-guard via
+   `chainsEqual`, `sharedFocusChain()` reactivity, consumer-computed descend/ascend chain math, no
+   re-entrant loop — NFR-004).
+2. **Phase 2 — 3D widget over the drill machinery.** Land `widgets/iso-map/` (`IsoMinimap`,
+   `IsoScene`, `ui/*`, `lib/*`, `iso-view-state`) reading the shared bus and reusing
+   `buildLevelDocuments` / `computeComposedLayout` / `deriveSubDocument`. Verify: bidirectional sync
+   end-to-end (click 3D → 2D descends + 3D expands; drill 2D → 3D re-focuses); depth control + toggle
+   (FR-003/FR-004).
+3. **Phase 3 — Lazy boundary + SSR exclusion.** Land the `vite.config.ts` draco/basis stub +
+   `ssr=false`/browser-guard wiring; add `three`+`@threlte/*` to `template/package.json#dependencies`.
+   Verify: 0 `three` markers in `dist/index.js` (INV-A); asset trace shows the chunk absent on non-Map
+   view load, present on Map open (FR-005/NFR-002).
+4. **Phase 4 — Cap + packaging proof.** Confirm `IMAGE_DIST_MAX_BYTES = 3.5 MiB` (`a6ef030`); build
+   passes the assertion; measure `du -sb dist*/` and record the 3D-chunk delta in the prove-phase
+   EvidencePack (PRD-039 AC-5; ADR-011 reconciliation).
+5. **Phase 5 — Fallback, a11y, motion.** Verify FR-007 honest fallback (force WebGL-init failure → 2D
+   `Minimap`, flat map intact); reduced-motion 0 ms snap; token-only theming grep; keyboard reach; the
+   full `svelte-check` (0) + `vitest` (0) gate (NFR-003).
+
+## Rollback Plan
+
+Backout mirrors ADR-011's rollback plan (the earlier "Force 3D" revert `7f907dd` proves it is clean);
+if the design fails (unacceptable size slack, `three` maintenance/security burden, or the 3D minimap
+is dropped), reverse in this order:
+
+1. **Drop the mount.** Remove `widgets/dependency-graph/ui/IsoMapCorner.svelte`'s dynamic import (or
+   the component) so nothing reaches the 3D chunk; the Map view falls back to the flat 2D `Minimap`
+   (FR-007 already specifies the honest 2D fallback) — the flat composed map is unaffected.
+2. **Remove the widget + bus.** Delete `widgets/iso-map/` and
+   `widgets/composed-map/model/shared-drill-bus.svelte.ts`; `ComposedMapView`'s own drill-state is
+   already self-sufficient, so removing the bus does not regress 2D drill-down.
+3. **Revert the cap bump.** Revert commit `a6ef030` so `IMAGE_DIST_MAX_BYTES` returns to 3 MiB.
+4. **Drop the deps + alias.** Remove `three` + `@threlte/*` from `template/package.json#dependencies`
+   and the `vite.config.ts` draco/basis stub alias (it goes with them).
+5. **Rebuild + verify.** `npm run build` must re-pass the restored 3 MiB assertion; `npm run smoke`
+   green on the `stable` image; `svelte-check` + `vitest` green.
+
+Because the shared bus is three-free and the mount is a single gated component, steps 1–2 alone
+already restore the pre-feature UX without touching the flat 2D map or the other 8 views.
+
+## Risks & Mitigations
+
+| Risk | Likelihood | Impact | Mitigation |
+|---|---|---|---|
+| **R-1 Sync loop** — click→descend→re-render→re-emit runaway between 2D and 3D | med | high | One writable source of truth; **content-guarded `focusTo`** (`chainsEqual`: writing the chain's current value = no-op, no new array / no notification); the view reconciliation effects also compare via `chainsEqual` before firing, and a mid-animation change is held pending + retried on settle; reactive readers never write back on read; covered by bus unit tests (NFR-004 / INV-E) |
+| **R-2 SSR leak** — a static import accidentally pulls `three` into `dist/index.js` | med | high | `three`/`@threlte` reachable only via `IsoMapCorner`'s browser-guarded dynamic import; `shared-drill-bus` is three-free by contract; SSR-marker grep test hook (INV-A / ADR-011 INV-1) |
+| **R-3 FSD widget→widget import** — `iso-map` imports `composed-map/model/shared-drill-bus` (lateral) | high (present) | low–med | Documented + `// TODO(iso-promote)`: promote the shared drill logic to `entities/` on a later pass; does not re-skin primitives (rule 24) or invert FSD *direction*, it is a lateral widget coupling only |
+| **R-4 draco/basis stub is load-bearing** — future `@threlte/extras` loader use silently breaks against the vite alias | low | med | `// TODO(iso-draco-basis)` on the alias; ADR-011 revisit trigger; any real-loader need re-opens the stub decision |
+| **R-5 Bundle regression hides under the raised cap** — +0.5 MiB slack lets future growth pass unnoticed | med | med | Cap is 3.5 MiB **not** blank check (INV-G / ADR-011 INV-3); `scripts/build.mjs` assertion still fires > 3.5 MiB; ADR-011 metric revisit trigger on any image > 3.5 MiB |
+| **R-6 Focus-chain contention** — the shared bus vs the PRD-038 onboarding tour + Tier-1 `show_on_map` camera all want to move the view | med | med | Bus is the single writer of shared focus; precedence/hand-off with PRD-038 is **unresolved** (PRD-039 Q4) — flagged as an Open Question, not silently assumed |
+| **R-7 WebGL unavailable** — headless / no-GPU / context-loss leaves the corner broken | med | med | `IsoMapCorner` catches import/init failure → flat 2D `Minimap` fallback (FR-007); flat map never coupled to WebGL availability |
+| **R-8 Packaged-size delta unknown** — the real on-disk cost is not yet measured | high | low | Stated **TBD**; measured `du -sb dist*/` recorded in prove-phase EVID (never invented) — PRD-039 AC-5 / Q2 |
+
+## Test Strategy Hooks
+
+Targets for the downstream `tester` / reviewer agents (hooks, not full cases):
+
+- **Build-under-cap assertion** — `scripts/build.mjs` `du -sb dist*/` ≤ `IMAGE_DIST_MAX_BYTES`
+  (3.5 MiB) for every emitted image (NFR-001; ADR-011 metric trigger). Record the 3D-chunk delta in
+  the EVID (TBD → EVID).
+- **SSR-exclusion assertion** — grep `dist/index.js` for `three` markers → **0** (INV-A / ADR-011
+  INV-1). Property test on the module graph: `shared-drill-bus`, `ComposedMapView`, 2D `Minimap`,
+  `entities/map` import no `three`/`@threlte`.
+- **Lazy-load asset trace** — network/asset trace shows the `three`/`@threlte` chunk **absent** on any
+  non-Map view load and **present** only after Map-view open (FR-005 / NFR-002; first-render budget
+  **TBD ms** → EVID).
+- **shared-drill-bus properties** (the load-bearing new contract, NFR-004 / INV-E) — `focusTo(nextChain)`
+  then `focusTo(parentChain)` returns to the prior focus; `focusTo(currentChain)` is a no-op
+  (`chainsEqual` guard — no new array, no notification); `sharedFocusChain()` reflects the last
+  `focusTo`; the consumer-computed descend/ascend chain math is tested at the view level; no
+  re-entrant emit loop across the outbound/inbound effect pair.
+- **Bidirectional-sync contract test at the `ComposedMapView` ↔ `iso-view-state` bus boundary** —
+  click zone in 3D ⇒ 2D descends + 3D expands/highlights; drill/climb in 2D ⇒ 3D re-focuses; the 3D
+  view's local depth control shows exactly N levels; the local toggle hides/restores without
+  disturbing the flat map (FR-003 / FR-004).
+- **Honest-fallback failure injection** — force `IsoScene` WebGL/Threlte init failure ⇒ flat 2D
+  `Minimap` renders, flat composed map intact, corner not broken (FR-007).
+- **No-regression gate** — `svelte-check` 0 errors + `vitest` 0 failures; manual smoke across all view
+  ids + the drill-down path; each non-Map minimap byte-identical to base (NFR-003 / FR-006 / INV-D).
+- **Theming / a11y / motion** — grep for hex/rgb literals in new `iso-map` components → 0 (token-only,
+  NFR-005); `iso-materials.tokenToColor` dual-theme resolution; keyboard reach of `IsoControls` via
+  `IsoA11yProxy`; reduced-motion ⇒ 0 ms explode/camera.
+- **Governance (rule 22)** — spawn/execFile/fetch/write greps over new route + `shared/server` files
+  → 0 new endpoints / 0 mutation call sites; the overview reads only existing GET-only `/api/map` +
+  `/api/map/layers/<zone>` (NFR-006 / INV-F).
+
+## Related Artifacts
+
+- **PRD-039** — parent product spec (3D isometric layered overview minimap). This RFC is `based_on`
+  it and realizes FR-001..FR-007 / NFR-001..NFR-006; it answers the PRD's deferred Q3 (depth control),
+  Q4 (focus-chain hand-off — flagged unresolved, R-6), Q5 (fallback — FR-007).
+- **ADR-011** — companion decision (ship `three`+Threlte as a lazy client chunk in the default image;
+  raise per-image dist cap 3 → 3.5 MiB). This RFC `refines` it into the concrete render/mount
+  architecture and realizes its INV-1..INV-4 as module boundaries (INV-A..INV-G above).
+- **SPEC-006 / RFC-030** — the `forgeplan.map/v1` render contract, the `computeComposedLayout` pure
+  function (C3), the read-only `/api/map` endpoint (C5), and the `mapPoller` (SD-1). Consumed as-is —
+  **no new SPEC, no schema change**; the 3D reads the same document the 2D view reads.
+- **PRD-037 / RFC-031** — the recursive drill-down seam (`deriveSubDocument`, `buildLevelDocuments`,
+  `drill-state`, prefer-emitted-layer) the 3D is a parallel renderer over.
+- **PRD-038** — Phase-3 onboarding + Tier-1 `show_on_map` camera the shared focus-chain must hand off
+  with (R-6 / PRD-039 Q4).
+- **PRD-030 / rule 21** — the per-image dist-size cap ADR-011 amends (3 → 3.5 MiB); rule 22 — the
+  read-only proxy boundary (untouched).
+- **EVID-101** — the re-review finding that surfaced the shared-drill-bus API drift this RFC's
+  Function-Signatures + flows were reconciled against (see Status).
+- **EvidencePack (PRD-039 prove-phase)** — measured `du -sb dist*/` delta + on-demand-load trace +
+  bidirectional-sync + no-regression smoke; linked `informs` before activation (rule 11, R_eff > 0).
+
+## References
+
+- Branch `feat/idef0-3d-iso-view` — the as-built implementation this RFC documents.
+- `widgets/iso-map/` (widget), `widgets/composed-map/model/shared-drill-bus.svelte.ts` (bus — exports
+  `sharedFocusChain` / `focusTo` / `chainsEqual`),
+  `widgets/iso-map/model/iso-view-state.svelte.ts` (local depth/visibility + shared-focus read/write),
+  `widgets/dependency-graph/ui/IsoMapCorner.svelte` (mount gate), `template/vite.config.ts` (draco/
+  basis stub + SSR guard), `scripts/build.mjs` (`IMAGE_DIST_MAX_BYTES`), `template/package.json`
+  (`three` + `@threlte/*`).
+- commit `a6ef030` — "build(idef0): raise dist cap 3M -> 3.5M for lazy 3D Map minimap" (`TODO(iso-adr)`
+  closed by ADR-011).
+- commit `7f907dd` / `dffbe25` (#103 / #104) — the reverted "Force 3D" Threlte view mode (reversibility
+  precedent cited by ADR-011).
+- Threlte (`@threlte/core`, `@threlte/extras`) + three.js — the WebGL runtime named per RFC latitude
+  (an RFC MAY name libraries; PRD-039 may not).
+
+
+
diff --git a/scripts/build.mjs b/scripts/build.mjs
index ab0b759..39abd97 100644
--- a/scripts/build.mjs
+++ b/scripts/build.mjs
@@ -25,7 +25,11 @@ const PKG_FILE = join(ROOT, "package.json");
 // PRD-030 / RFC-026 / ADR-005: every emitted image directory is bound by the
 // same size cap. The bundle alone is ~600K-1M; keeping headroom for client/
 // + future small additions, while alarming on accidental bloat.
-const IMAGE_DIST_MAX_BYTES = 3 * 1024 * 1024;
+// Raised 3M -> 3.5M to accommodate the lazy-loaded 3D Map minimap
+// (three.js + Threlte, ~808K client chunk, loaded only when the Map view
+// opens). Deliberate amendment of PRD-030 NFR-001 / SC-4 / rule 21,
+// recorded in ADR-011 (ship three.js+Threlte lazy chunk; cap 3->3.5 MiB).
+const IMAGE_DIST_MAX_BYTES = 3.5 * 1024 * 1024;
 
 // Lifecycle policy (PRD-030 NFR-005, RFC-026 Phase 1): a flag's expiresIn
 // must not be more than this many minor versions past addedIn (within the
@@ -123,7 +127,9 @@ function validateConfig({ images, features, currentVersion }) {
       continue;
     }
     if (typeof feat.id !== "string" || feat.id.length === 0) {
-      errors.push("config/features.json: feature `id` must be a non-empty string");
+      errors.push(
+        "config/features.json: feature `id` must be a non-empty string",
+      );
       continue;
     }
     if (featureById.has(feat.id)) {
@@ -146,7 +152,7 @@ function validateConfig({ images, features, currentVersion }) {
       );
       continue;
     }
-    if (!semverGTE(expires, added) || (expires.raw === added.raw)) {
+    if (!semverGTE(expires, added) || expires.raw === added.raw) {
       errors.push(
         `config/features.json: feature "${feat.id}" has expiresIn (${expires.raw}) <= addedIn (${added.raw})`,
       );
diff --git a/template/package-lock.json b/template/package-lock.json
index d21a80d..445f085 100644
--- a/template/package-lock.json
+++ b/template/package-lock.json
@@ -11,6 +11,8 @@
         "@lucide/svelte": "^1.14.0",
         "@neodrag/svelte": "3.0.0-next.8",
         "@sveltejs/kit": "^2.59.0",
+        "@threlte/core": "^8.5.16",
+        "@threlte/extras": "^9.21.0",
         "bits-ui": "^2.18.1",
         "d3-force": "^3.0.0",
         "d3-hierarchy": "^3.1.2",
@@ -23,7 +25,8 @@
         "rehype-highlight": "^7.0.2",
         "svelte": "^5.55.5",
         "svelte-exmarkdown": "^5.0.2",
-        "svelte-sonner": "^1.1.1"
+        "svelte-sonner": "^1.1.1",
+        "three": "^0.185.1"
       },
       "devDependencies": {
         "@sveltejs/adapter-node": "^5.5.4",
@@ -37,6 +40,7 @@
         "@types/d3-zoom": "^3.0.8",
         "@types/dompurify": "^3.0.5",
         "@types/node": "^20.17.0",
+        "@types/three": "^0.185.0",
         "happy-dom": "^20.9.0",
         "svelte-check": "^4.4.7",
         "typescript": "^6.0.3",
@@ -47,6 +51,12 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
+    "node_modules/@dimforge/rapier3d-compat": {
+      "version": "0.12.0",
+      "resolved": "https://registry.npmjs.org/@dimforge/rapier3d-compat/-/rapier3d-compat-0.12.0.tgz",
+      "integrity": "sha512-uekIGetywIgopfD97oDL5PfeezkFpNhwlzlaEYNOA0N6ghdsOvh/HYjSMek5Q2O1PYvRSDFcqFVJl4r4ZBwOow==",
+      "license": "Apache-2.0"
+    },
     "node_modules/@emnapi/core": {
       "version": "1.10.0",
       "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
@@ -1012,6 +1022,55 @@
         "tslib": "^2.8.0"
       }
     },
+    "node_modules/@threejs-kit/instanced-sprite-mesh": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@threejs-kit/instanced-sprite-mesh/-/instanced-sprite-mesh-2.5.1.tgz",
+      "integrity": "sha512-pmt1ALRhbHhCJQTj2FuthH6PeLIeaM4hOuS2JO3kWSwlnvx/9xuUkjFR3JOi/myMqsH7pSsLIROSaBxDfttjeA==",
+      "dependencies": {
+        "diet-sprite": "^0.0.1",
+        "earcut": "^2.2.4",
+        "maath": "^0.10.7",
+        "three-instanced-uniforms-mesh": "^0.52.4",
+        "troika-three-utils": "^0.52.4"
+      },
+      "peerDependencies": {
+        "three": ">=0.170.0"
+      }
+    },
+    "node_modules/@threlte/core": {
+      "version": "8.5.16",
+      "resolved": "https://registry.npmjs.org/@threlte/core/-/core-8.5.16.tgz",
+      "integrity": "sha512-+aa9Zgz0/Qat82H0hTm1pTEtS2BIP1Nfu7pKaei+3+TvDqER0YnZ4hdgI9fYU9Z5r1lrzY3JxMyrdISp4B0kfw==",
+      "license": "MIT",
+      "peerDependencies": {
+        "svelte": ">=5",
+        "three": ">=0.160"
+      }
+    },
+    "node_modules/@threlte/extras": {
+      "version": "9.21.0",
+      "resolved": "https://registry.npmjs.org/@threlte/extras/-/extras-9.21.0.tgz",
+      "integrity": "sha512-ZkBx4IH+7vcxVM09Rex9XJNMKKbQt4JZ5J/3TnBd/Fge8IzSgl0ydgn70riDf/8tDLMDID6VdZPPrlr5vCHHJA==",
+      "license": "MIT",
+      "dependencies": {
+        "@threejs-kit/instanced-sprite-mesh": "^2.5.1",
+        "camera-controls": "^3.1.2",
+        "three-mesh-bvh": "^0.9.1",
+        "three-perf": "^1.0.11",
+        "three-viewport-gizmo": "^2.2.0",
+        "troika-three-text": "^0.52.4"
+      },
+      "peerDependencies": {
+        "svelte": ">=5",
+        "three": ">=0.160"
+      }
+    },
+    "node_modules/@tweenjs/tween.js": {
+      "version": "23.1.3",
+      "resolved": "https://registry.npmjs.org/@tweenjs/tween.js/-/tween.js-23.1.3.tgz",
+      "integrity": "sha512-vJmvvwFxYuGnF2axRtPYocag6Clbb5YS7kLL+SO/TeVFzHqDIWrNKYtcsPMibjDx9O+bu+psAy9NKfWklassUA==",
+      "license": "MIT"
+    },
     "node_modules/@tybys/wasm-util": {
       "version": "0.10.2",
       "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.2.tgz",
@@ -1215,6 +1274,26 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/stats.js": {
+      "version": "0.17.4",
+      "resolved": "https://registry.npmjs.org/@types/stats.js/-/stats.js-0.17.4.tgz",
+      "integrity": "sha512-jIBvWWShCvlBqBNIZt0KAshWpvSjhkwkEu4ZUcASoAvhmrgAUI2t1dXrjSL4xXVLB4FznPrIsX3nKXFl/Dt4vA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/three": {
+      "version": "0.185.0",
+      "resolved": "https://registry.npmjs.org/@types/three/-/three-0.185.0.tgz",
+      "integrity": "sha512-O2Uy8Cj4Nonr8dWUUbifMdPe8B0Mq7EdOHb89S4+kjUw/KhbjTZrUuYlrQ1bpUKG+EP9QJnN7qNxbHGlGoLHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "@dimforge/rapier3d-compat": "~0.12.0",
+        "@tweenjs/tween.js": "~23.1.3",
+        "@types/stats.js": "*",
+        "@types/webxr": ">=0.5.17",
+        "fflate": "~0.8.2",
+        "meshoptimizer": "~1.1.1"
+      }
+    },
     "node_modules/@types/trusted-types": {
       "version": "2.0.7",
       "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
@@ -1227,6 +1306,12 @@
       "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
       "license": "MIT"
     },
+    "node_modules/@types/webxr": {
+      "version": "0.5.24",
+      "resolved": "https://registry.npmjs.org/@types/webxr/-/webxr-0.5.24.tgz",
+      "integrity": "sha512-h8fgEd/DpoS9CBrjEQXR+dIDraopAEfu4wYVNY2tEPwk60stPWhvZMf4Foo5FakuQ7HFZoa8WceaWFervK2Ovg==",
+      "license": "MIT"
+    },
     "node_modules/@types/whatwg-mimetype": {
       "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/@types/whatwg-mimetype/-/whatwg-mimetype-3.0.2.tgz",
@@ -1423,6 +1508,15 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/bidi-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",
+      "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==",
+      "license": "MIT",
+      "dependencies": {
+        "require-from-string": "^2.0.2"
+      }
+    },
     "node_modules/bits-ui": {
       "version": "2.18.1",
       "resolved": "https://registry.npmjs.org/bits-ui/-/bits-ui-2.18.1.tgz",
@@ -1447,6 +1541,19 @@
         "svelte": "^5.33.0"
       }
     },
+    "node_modules/camera-controls": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/camera-controls/-/camera-controls-3.1.2.tgz",
+      "integrity": "sha512-xkxfpG2ECZ6Ww5/9+kf4mfg1VEYAoe9aDSY+IwF0UEs7qEzwy0aVRfs2grImIECs/PoBtWFrh7RXsQkwG922JA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=22.0.0",
+        "npm": ">=10.5.1"
+      },
+      "peerDependencies": {
+        "three": ">=0.126.1"
+      }
+    },
     "node_modules/ccount": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
@@ -1797,6 +1904,12 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/diet-sprite": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/diet-sprite/-/diet-sprite-0.0.1.tgz",
+      "integrity": "sha512-zSHI2WDAn1wJqJYxcmjWfJv3Iw8oL9reQIbEyx2x2/EZ4/qmUTIo8/5qOCurnAcq61EwtJJaZ0XTy2NRYqpB5A==",
+      "license": "ISC"
+    },
     "node_modules/dompurify": {
       "version": "3.4.2",
       "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.4.2.tgz",
@@ -1806,6 +1919,12 @@
         "@types/trusted-types": "^2.0.7"
       }
     },
+    "node_modules/earcut": {
+      "version": "2.2.4",
+      "resolved": "https://registry.npmjs.org/earcut/-/earcut-2.2.4.tgz",
+      "integrity": "sha512-/pjZsA1b4RPHbeWZQn66SWS8nZZWLQQ23oE3Eam7aroEFGEvwKAsJfZ9ytiEMycfzXWpca4FA9QIOehf7PocBQ==",
+      "license": "ISC"
+    },
     "node_modules/entities": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
@@ -1911,6 +2030,12 @@
         }
       }
     },
+    "node_modules/fflate": {
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.3.tgz",
+      "integrity": "sha512-tbZNuJrLwGUp3zshBtdy4W+ORxZuIh8a5ilyIEQDC5rY1f3U20JMry0Ll3WBzU58EZKsEuJFXhb5gwv8CsPvgA==",
+      "license": "MIT"
+    },
     "node_modules/fsevents": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -2359,6 +2484,16 @@
         "lz-string": "bin/bin.js"
       }
     },
+    "node_modules/maath": {
+      "version": "0.10.8",
+      "resolved": "https://registry.npmjs.org/maath/-/maath-0.10.8.tgz",
+      "integrity": "sha512-tRvbDF0Pgqz+9XUa4jjfgAQ8/aPKmQdWXilFu2tMy4GWj4NOsx99HlULO4IeREfbO3a0sA145DZYyvXPkybm0g==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/three": ">=0.134.0",
+        "three": ">=0.134.0"
+      }
+    },
     "node_modules/magic-string": {
       "version": "0.30.21",
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
@@ -2600,6 +2735,12 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/meshoptimizer": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/meshoptimizer/-/meshoptimizer-1.1.1.tgz",
+      "integrity": "sha512-oRFNWJRDA/WTrVj7NWvqa5HqE1t9MYDj2VaWirQCzCCrAd2GHrqR/sQezCxiWATPNlKTcRaPRHPJwIRoPBAp5g==",
+      "license": "MIT"
+    },
     "node_modules/micromark": {
       "version": "4.0.2",
       "resolved": "https://registry.npmjs.org/micromark/-/micromark-4.0.2.tgz",
@@ -3373,6 +3514,15 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/resolve": {
       "version": "1.22.12",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
@@ -3711,6 +3861,55 @@
       "integrity": "sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==",
       "license": "MIT"
     },
+    "node_modules/three": {
+      "version": "0.185.1",
+      "resolved": "https://registry.npmjs.org/three/-/three-0.185.1.tgz",
+      "integrity": "sha512-5aojFCXKwnjBRZvUnt3WFfEcvUJgkN5LlijRFN95hMy8WVkG4I0QNcJE+OuWvuJ0bOdStrbfXn0pkd6/QyiAlg==",
+      "license": "MIT"
+    },
+    "node_modules/three-instanced-uniforms-mesh": {
+      "version": "0.52.4",
+      "resolved": "https://registry.npmjs.org/three-instanced-uniforms-mesh/-/three-instanced-uniforms-mesh-0.52.4.tgz",
+      "integrity": "sha512-YwDBy05hfKZQtU+Rp0KyDf9yH4GxfhxMbVt9OYruxdgLfPwmDG5oAbGoW0DrKtKZSM3BfFcCiejiOHCjFBTeng==",
+      "license": "MIT",
+      "dependencies": {
+        "troika-three-utils": "^0.52.4"
+      },
+      "peerDependencies": {
+        "three": ">=0.125.0"
+      }
+    },
+    "node_modules/three-mesh-bvh": {
+      "version": "0.9.10",
+      "resolved": "https://registry.npmjs.org/three-mesh-bvh/-/three-mesh-bvh-0.9.10.tgz",
+      "integrity": "sha512-UOlTgPIeqUURcwaG8knxvBaruwZlC4X3/WSHEFO7rYvMVv/YNUrkfFEszvfj36pXV88dCHoHNnIp0PifkirnTQ==",
+      "license": "MIT",
+      "peerDependencies": {
+        "three": ">= 0.159.0"
+      }
+    },
+    "node_modules/three-perf": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/three-perf/-/three-perf-1.0.11.tgz",
+      "integrity": "sha512-OgBpZjwL+csQKGKZjpkH/QHdbGFMxqngMbSEJeSnVNfXDYd6On7WHNv/GhUZH4YxIpNMwMahBWrNnsJvnbSJHQ==",
+      "license": "MIT",
+      "dependencies": {
+        "troika-three-text": "^0.52.0",
+        "tweakpane": "^3.1.10"
+      },
+      "peerDependencies": {
+        "three": ">=0.170"
+      }
+    },
+    "node_modules/three-viewport-gizmo": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/three-viewport-gizmo/-/three-viewport-gizmo-2.2.0.tgz",
+      "integrity": "sha512-Jo9Liur1rUmdKk75FZumLU/+hbF+RtJHi1qsKZpntjKlCYScK6tjbYoqvJ9M+IJphrlQJF5oReFW7Sambh0N4Q==",
+      "license": "MIT",
+      "peerDependencies": {
+        "three": ">=0.162.0 <1.0.0"
+      }
+    },
     "node_modules/tinybench": {
       "version": "2.9.0",
       "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
@@ -3773,6 +3972,36 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/troika-three-text": {
+      "version": "0.52.4",
+      "resolved": "https://registry.npmjs.org/troika-three-text/-/troika-three-text-0.52.4.tgz",
+      "integrity": "sha512-V50EwcYGruV5rUZ9F4aNsrytGdKcXKALjEtQXIOBfhVoZU9VAqZNIoGQ3TMiooVqFAbR1w15T+f+8gkzoFzawg==",
+      "license": "MIT",
+      "dependencies": {
+        "bidi-js": "^1.0.2",
+        "troika-three-utils": "^0.52.4",
+        "troika-worker-utils": "^0.52.0",
+        "webgl-sdf-generator": "1.1.1"
+      },
+      "peerDependencies": {
+        "three": ">=0.125.0"
+      }
+    },
+    "node_modules/troika-three-utils": {
+      "version": "0.52.4",
+      "resolved": "https://registry.npmjs.org/troika-three-utils/-/troika-three-utils-0.52.4.tgz",
+      "integrity": "sha512-NORAStSVa/BDiG52Mfudk4j1FG4jC4ILutB3foPnfGbOeIs9+G5vZLa0pnmnaftZUGm4UwSoqEpWdqvC7zms3A==",
+      "license": "MIT",
+      "peerDependencies": {
+        "three": ">=0.125.0"
+      }
+    },
+    "node_modules/troika-worker-utils": {
+      "version": "0.52.0",
+      "resolved": "https://registry.npmjs.org/troika-worker-utils/-/troika-worker-utils-0.52.0.tgz",
+      "integrity": "sha512-W1CpvTHykaPH5brv5VHLfQo9D1OYuo0cSBEUQFFT/nBUzM8iD6Lq2/tgG/f1OelbAS1WtaTPQzE5uM49egnngw==",
+      "license": "MIT"
+    },
     "node_modules/trough": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz",
@@ -3789,6 +4018,15 @@
       "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
       "license": "0BSD"
     },
+    "node_modules/tweakpane": {
+      "version": "3.1.10",
+      "resolved": "https://registry.npmjs.org/tweakpane/-/tweakpane-3.1.10.tgz",
+      "integrity": "sha512-rqwnl/pUa7+inhI2E9ayGTqqP0EPOOn/wVvSWjZsRbZUItzNShny7pzwL3hVlaN4m9t/aZhsP0aFQ9U5VVR2VQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/cocopon"
+      }
+    },
     "node_modules/typescript": {
       "version": "6.0.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
@@ -4125,6 +4363,12 @@
         }
       }
     },
+    "node_modules/webgl-sdf-generator": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/webgl-sdf-generator/-/webgl-sdf-generator-1.1.1.tgz",
+      "integrity": "sha512-9Z0JcMTFxeE+b2x1LJTdnaT8rT8aEp7MVxkNwoycNmJWwPdzoXzMh0BjJSh/AEFP+KPYZUli814h8bJZFIZ2jA==",
+      "license": "MIT"
+    },
     "node_modules/whatwg-mimetype": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-3.0.0.tgz",
diff --git a/template/package.json b/template/package.json
index ca5ed1b..e5ce672 100644
--- a/template/package.json
+++ b/template/package.json
@@ -26,6 +26,7 @@
     "@types/d3-zoom": "^3.0.8",
     "@types/dompurify": "^3.0.5",
     "@types/node": "^20.17.0",
+    "@types/three": "^0.185.0",
     "happy-dom": "^20.9.0",
     "svelte-check": "^4.4.7",
     "typescript": "^6.0.3",
@@ -36,6 +37,8 @@
     "@lucide/svelte": "^1.14.0",
     "@neodrag/svelte": "3.0.0-next.8",
     "@sveltejs/kit": "^2.59.0",
+    "@threlte/core": "^8.5.16",
+    "@threlte/extras": "^9.21.0",
     "bits-ui": "^2.18.1",
     "d3-force": "^3.0.0",
     "d3-hierarchy": "^3.1.2",
@@ -48,7 +51,8 @@
     "rehype-highlight": "^7.0.2",
     "svelte": "^5.55.5",
     "svelte-exmarkdown": "^5.0.2",
-    "svelte-sonner": "^1.1.1"
+    "svelte-sonner": "^1.1.1",
+    "three": "^0.185.1"
   },
   "overrides": {
     "cookie": ">=0.7.0"
diff --git a/template/src/widgets/composed-map/model/shared-drill-bus.svelte.test.ts b/template/src/widgets/composed-map/model/shared-drill-bus.svelte.test.ts
new file mode 100644
index 0000000..bfe7fa9
--- /dev/null
+++ b/template/src/widgets/composed-map/model/shared-drill-bus.svelte.test.ts
@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  sharedFocusChain,
+  focusTo,
+  chainsEqual,
+} from "./shared-drill-bus.svelte";
+
+// RFC-036 Test Strategy Hooks / EVID-100 Finding #2 — the shared-drill-bus
+// reducer had zero tests. This file covers the bus itself: (1) reducer
+// idempotence and (2) the bidirectional 2D<->3D sync contract + the
+// content-guard that prevents an infinite re-fire loop.
+//
+// The THIRD hook — mid-animation convergence (EVID-100 Finding #1) — lives
+// in the 3D consumer, `widgets/iso-map/model/iso-view-state.svelte.ts`, and
+// depends on that module's own `$effect.root` watcher actually firing.
+// `$effect` is compiled to a no-op under this project's "unit" (node/SSR)
+// vitest project — Svelte only runs effects in client-generated code, which
+// requires the "dom" project's `happy-dom` environment + `browser` resolve
+// condition (verified empirically: a minimal $effect.root repro in "unit"
+// never ran its effect body, not even once, at module-init time). That test
+// lives in the co-located `iso-view-state.render.test.ts` instead, so it
+// exercises the real mechanism rather than a fake standing in for it.
+
+describe("chainsEqual", () => {
+  it("is true for two empty chains", () => {
+    expect(chainsEqual([], [])).toBe(true);
+  });
+
+  it("is true for equal-content chains regardless of array identity", () => {
+    expect(chainsEqual(["a", "b"], ["a", "b"])).toBe(true);
+  });
+
+  it("is false for different lengths", () => {
+    expect(chainsEqual(["a"], ["a", "b"])).toBe(false);
+  });
+
+  it("is false for the same length but different content", () => {
+    expect(chainsEqual(["a", "b"], ["a", "c"])).toBe(false);
+  });
+});
+
+describe("shared-drill-bus", () => {
+  // Module-level $state persists across tests in this file (the same
+  // singleton both real views consume) — reset it before every test via
+  // the bus's own public API, mirroring camera-bus.test.ts's
+  // `clearCameraTarget()` pattern.
+  beforeEach(() => {
+    focusTo([]);
+  });
+
+  it("starts with an empty chain", () => {
+    expect(sharedFocusChain()).toEqual([]);
+  });
+
+  describe("reducer idempotence", () => {
+    it("descending into the same zone twice does not duplicate the chain", () => {
+      focusTo(["z.a"]);
+      focusTo(["z.a"]);
+      expect(sharedFocusChain()).toEqual(["z.a"]);
+    });
+
+    it("re-applying the identical multi-level chain is a no-op (same array reference, no churn)", () => {
+      focusTo(["z.a", "z.b"]);
+      const applied = sharedFocusChain();
+      // A structurally-identical but NOT reference-identical array — proves
+      // the guard compares content, not the input array's identity.
+      focusTo([...applied]);
+      expect(sharedFocusChain()).toBe(applied);
+    });
+
+    it("writes a NEW array only when the chain genuinely changes", () => {
+      focusTo(["z.a"]);
+      const before = sharedFocusChain();
+      focusTo(["z.a", "z.b"]);
+      expect(sharedFocusChain()).not.toBe(before);
+      expect(sharedFocusChain()).toEqual(["z.a", "z.b"]);
+    });
+
+    it("ascend past root (focusTo([]) on an already-empty chain) is a no-op", () => {
+      expect(sharedFocusChain()).toEqual([]);
+      const before = sharedFocusChain();
+      focusTo([]);
+      expect(sharedFocusChain()).toBe(before);
+    });
+  });
+
+  describe("bidirectional-sync contract", () => {
+    it("a 2D-origin write is visible to the 3D reader", () => {
+      focusTo(["z.a"]); // simulates ComposedMapView's outbound effect
+      expect(sharedFocusChain()).toEqual(["z.a"]); // iso-view-state's inbound effect would read this
+    });
+
+    it("a 3D-origin write is visible to the 2D reader (and vice versa)", () => {
+      focusTo(["z.a"]);
+      focusTo(["z.a", "mega-1"]); // simulates the 3D surface descending further
+      expect(sharedFocusChain()).toEqual(["z.a", "mega-1"]); // 2D reads it back
+    });
+
+    it("single source of truth — every reader observes the identical array reference", () => {
+      focusTo(["z.a"]);
+      const readByComposedMapView = sharedFocusChain();
+      const readByIsoViewState = sharedFocusChain();
+      expect(readByComposedMapView).toBe(readByIsoViewState);
+    });
+
+    it("echoing the just-applied chain back (content-guarded write) does not re-fire an update — breaks the 2D<->3D loop", () => {
+      focusTo(["z.a", "z.b"]);
+      const applied = sharedFocusChain();
+      // The scenario the file's own header comment describes: a view that
+      // just applied an externally-driven chain "confirms" it right back
+      // into the bus. Without the content guard this would assign a NEW
+      // array and re-trigger the other view's inbound effect for no reason.
+      focusTo([...applied]);
+      expect(sharedFocusChain()).toBe(applied);
+    });
+  });
+});
diff --git a/template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts b/template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts
new file mode 100644
index 0000000..e85d2a4
--- /dev/null
+++ b/template/src/widgets/composed-map/model/shared-drill-bus.svelte.ts
@@ -0,0 +1,76 @@
+// Shared FOCUS CHAIN between the 2D ComposedMapView and the 3D IsoMinimap
+// corner (widgets/iso-map/model/iso-view-state.svelte.ts). Holds ONLY the
+// ordered list of drilled zone/node ids — the same shape
+// drill-state.ts#focusChain returns (root excluded, deepest entry last).
+// Each view keeps its OWN LevelFrame[] levelStack locally for view-specific
+// concerns that must never be shared (2D: pan/zoom transform + kFit; 3D:
+// depthWindow + enter/exit animation tweens) and reconciles that local
+// state against this chain via a pair of $effects living in each view's own
+// component (an $effect needs a component owner, so the reconciliation
+// itself is NOT implemented here — see ComposedMapView.svelte's and
+// IsoMinimap.svelte's own OUTBOUND/INBOUND effect pair). Mirrors
+// camera-bus.svelte.ts's shape: no class, one module-level $state singleton
+// per page.
+//
+// Plain data only — this file MUST NOT import three/@threlte (or anything
+// that does), so importing it from the 2D/SSR path never pulls the 3D
+// dependency graph in.
+//
+// Naming note (EVID-100 Finding #7): RFC-036 documents this bus's contract
+// as `focusChain` (the reactive chain) + `focusTo(chain)` (reconcile to an
+// explicit chain). `focusTo` below is exactly what this module's setter
+// does ("reconcile to an explicit chain... used when one surface must
+// jump the other to an arbitrary focus", per the RFC) — renamed to match.
+// The getter keeps its `sharedFocusChain` name rather than the RFC's bare
+// `focusChain`: `widgets/composed-map/model/drill-state.ts` already
+// exports an UNRELATED `focusChain(levelStack)` (a per-view LOCAL chain
+// derivation) that both ComposedMapView.svelte and iso-view-state.svelte.ts
+// import alongside this module — a bare `focusChain` here would collide
+// with that import at every call site. `sharedFocusChain` disambiguates
+// the two "focus chain" concepts by name, same as the file's own header
+// paragraph above already does in prose. The RFC ALSO documents per-action
+// `descend`/`ascend` and depth/visibility (`setDepth`/`toggleVisible`) as
+// bus methods — those are NOT implemented here: depth-window and
+// visibility are intentionally LOCAL-only state inside
+// `iso-view-state.svelte.ts` (never shared), and each view's own
+// descend/ascend mutates its OWN local levelStack, then mirrors the
+// resulting full chain out via `focusTo` — a broadcast, not a per-action
+// shared mutator. RFC-036's Function Signatures section still needs a
+// follow-up edit to reflect this; that is Profile A/B territory (ADR/RFC
+// ownership), not this coder change.
+
+import { untrack } from "svelte";
+
+let chain = $state<string[]>([]);
+
+/** Reactive read — call from inside an $effect/$derived to track changes. */
+export function sharedFocusChain(): string[] {
+  return chain;
+}
+
+export function chainsEqual(
+  a: readonly string[],
+  b: readonly string[],
+): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+// Content-guarded write: a no-op (no new array, no reactive notification)
+// when `next` already matches the current chain. This is load-bearing for
+// the outbound/inbound effect pair in each consuming view — without it, a
+// view that just applied an externally-driven chain would immediately
+// "confirm" it right back into a NEW object, re-triggering the other
+// view's inbound effect for no reason. The internal comparison read is
+// wrapped in `untrack` so that calling this from inside a REACTIVE
+// $effect (as both consuming views do) never makes that effect an
+// accidental subscriber of this module's own state — only the writes a
+// caller performs on ITS OWN local state should decide when it re-runs.
+export function focusTo(next: readonly string[]): void {
+  const current = untrack(() => chain);
+  if (chainsEqual(current, next)) return;
+  chain = [...next];
+}
diff --git a/template/src/widgets/composed-map/ui/ComposedMapView.svelte b/template/src/widgets/composed-map/ui/ComposedMapView.svelte
index fbe606f..82848a0 100644
--- a/template/src/widgets/composed-map/ui/ComposedMapView.svelte
+++ b/template/src/widgets/composed-map/ui/ComposedMapView.svelte
@@ -10,6 +10,7 @@
    * document instead of chasing whatever the shared poller keeps fetching
    * for other mounted panes.
    */
+  import { untrack } from "svelte";
   import {
     zoom,
     zoomIdentity,
@@ -73,6 +74,11 @@
     currentCameraRequest,
     type CameraTarget,
   } from "@/widgets/composed-map/model/camera-bus.svelte";
+  import {
+    sharedFocusChain,
+    focusTo,
+    chainsEqual,
+  } from "@/widgets/composed-map/model/shared-drill-bus.svelte";
   import type { ArtifactSummary } from "@/entities/artifact";
   import type { GraphEdge } from "@/entities/graph";
   import type { ScoreEntry } from "@/entities/score";
@@ -540,6 +546,65 @@
     if (req.target) applyCameraTarget(req.target);
   });
 
+  // Shared drill-chain bus (2D <-> 3D iso corner) — the ONE shared focus
+  // chain both this view and widgets/iso-map/model/iso-view-state.svelte.ts
+  // read/write (shared-drill-bus.svelte.ts). This view keeps its OWN
+  // LevelFrame[] levelStack (pan/zoom transform + kFit stay 2D-only, never
+  // shared) — only the ORDERED list of drilled ids is shared.
+  //
+  // OUTBOUND — push this view's own chain whenever levelStack changes, from
+  // ANY cause (click-descend, wheel-drill, Esc/ascend, breadcrumb climbTo).
+  // focusTo no-ops on unchanged content, so this can never fight the
+  // INBOUND effect below into a loop.
+  $effect(() => {
+    focusTo(focusChain(levelStack));
+  });
+
+  // INBOUND — replay an externally-driven chain (e.g. a descend that
+  // happened in the 3D corner) onto this view's OWN levelStack via the
+  // SAME descend/climbTo primitives a click would use, so pan/zoom/kFit
+  // stay consistent with a normal drill. Skips its own very first run so
+  // reopening the Map view never auto-jumps to a chain a previous session
+  // left behind — the map still opens at root, same as before this
+  // feature. `untrack` keeps this effect's ONLY dependency the shared
+  // chain itself — reading levelStack/isLive/okDoc inside the callback
+  // must not leak as dependencies, or ordinary local panning/drilling
+  // would re-run this effect against a not-yet-updated shared value and
+  // risk undoing the very action that triggered it.
+  let sharedChainPrimed = false;
+  $effect(() => {
+    const shared = sharedFocusChain();
+    if (!sharedChainPrimed) {
+      sharedChainPrimed = true;
+      return;
+    }
+    untrack(() => {
+      if (!isLive || !okDoc) return;
+      if (chainsEqual(focusChain(levelStack), shared)) return;
+      applyExternalFocusChain(shared);
+    });
+  });
+
+  // Applies `target` (the shared chain) to this view's own levelStack: it
+  // climbs to the longest shared prefix already drilled, then descends
+  // through the rest via descend() — the SAME primitive a click uses, so
+  // camera fit/kFit/layerCache all update exactly as they would for a
+  // real click. Mirrors the 3D side's own reconciliation (see
+  // iso-view-state.svelte.ts#applyExternalFocusChain).
+  function applyExternalFocusChain(target: readonly string[]) {
+    const local = focusChain(levelStack);
+    let common = 0;
+    while (
+      common < local.length &&
+      common < target.length &&
+      local[common] === target[common]
+    ) {
+      common++;
+    }
+    if (common < local.length) climbTo(common);
+    for (let i = common; i < target.length; i++) descend(target[i]!);
+  }
+
   // Zoom-to-fit only the FIRST non-empty layout (didFit latches); later
   // meta.version recomputes must not disturb the user's pan/zoom. The
   // queueMicrotask callback can outlive this effect (e.g. the view is
diff --git a/template/src/widgets/dependency-graph/ui/DependencyGraph.svelte b/template/src/widgets/dependency-graph/ui/DependencyGraph.svelte
index 6c10706..1c5822d 100644
--- a/template/src/widgets/dependency-graph/ui/DependencyGraph.svelte
+++ b/template/src/widgets/dependency-graph/ui/DependencyGraph.svelte
@@ -13,6 +13,7 @@
   import Idef0View from './Idef0View.svelte';
   import ComposedMapView from '../../composed-map/ui/ComposedMapView.svelte';
   import Minimap from './Minimap.svelte';
+  import IsoMapCorner from './IsoMapCorner.svelte';
 
   let {
     view = 'force',
@@ -215,13 +216,21 @@
     />
   {/if}
 
-  <Minimap
-    enabled={minimapEnabled}
-    nodes={miniNodes}
-    transform={miniTransform}
-    viewportSize={miniViewport}
-    {onTeleport}
-  />
+  {#if view === 'map'}
+    <!-- Map-view-only corner: a 3D IsoMinimap replaces the 2D <Minimap> in
+         this one slot (same bottom-right position). ComposedMapView itself
+         (the main 2D map above) is untouched — see IsoMapCorner's header
+         comment for the lazy-load rationale. -->
+    <IsoMapCorner />
+  {:else}
+    <Minimap
+      enabled={minimapEnabled}
+      nodes={miniNodes}
+      transform={miniTransform}
+      viewportSize={miniViewport}
+      {onTeleport}
+    />
+  {/if}
 </div>
 
 <style>
diff --git a/template/src/widgets/dependency-graph/ui/IsoMapCorner.svelte b/template/src/widgets/dependency-graph/ui/IsoMapCorner.svelte
new file mode 100644
index 0000000..ae8f6f6
--- /dev/null
+++ b/template/src/widgets/dependency-graph/ui/IsoMapCorner.svelte
@@ -0,0 +1,82 @@
+<script lang="ts">
+  // Map-view-only replacement for the 2D <Minimap> corner (same bottom-right
+  // slot, same chrome shape) — mounts the 3D IsoMinimap widget. `three` +
+  // `@threlte/*` are heavy (WebGL scene graph) and every OTHER view never
+  // touches them, so this component dynamic-imports widgets/iso-map instead
+  // of a static import: the dependency-graph entry chunk (loaded for every
+  // view) stays free of three/threlte, which only load once the user opens
+  // the Map view and this corner actually mounts. Threlte's Canvas defaults
+  // to `renderMode: 'on-demand'` (no prop override needed) — the corner
+  // canvas only re-renders on scene invalidation, not every frame.
+  //
+  // `browser`-guarded: this component itself is reachable from the
+  // adapter-node server manifest (DependencyGraph is part of the main page,
+  // which is always in the server-side route graph regardless of its own
+  // ssr flag). Guarding with `browser` lets Vite's SSR build tree-shake the
+  // dynamic import out of the server bundle entirely — otherwise the
+  // single-file esbuild bundling step (no code-splitting) inlines it and
+  // three/@threlte blow past the dist/ size cap. The client build (where
+  // this corner actually mounts) is unaffected.
+  import { browser } from '$app/environment';
+
+  const isoMapModule = browser ? import('@/widgets/iso-map') : null;
+</script>
+
+<div class="iso-map-corner">
+  {#if isoMapModule}
+    {#await isoMapModule}
+      <div class="iso-map-corner-status">loading 3D…</div>
+    {:then mod}
+      <!--
+        FR-007's honest fallback has two halves: the {:catch} above catches
+        a REJECTED dynamic import, this boundary catches a runtime failure
+        AFTER the import resolved — e.g. WebGL context creation failing
+        inside @threlte/core's <Canvas> during mod.IsoMinimap's own
+        mount/render (EVID-100 Finding #3). Either failure degrades to the
+        same "3D minimap unavailable" status; the flat 2D map is never
+        coupled to WebGL availability either way.
+      -->
+      <svelte:boundary>
+        <mod.IsoMinimap />
+        {#snippet failed()}
+          <div class="iso-map-corner-status">3D minimap unavailable</div>
+        {/snippet}
+      </svelte:boundary>
+    {:catch}
+      <div class="iso-map-corner-status">3D minimap unavailable</div>
+    {/await}
+  {:else}
+    <div class="iso-map-corner-status">3D minimap unavailable</div>
+  {/if}
+</div>
+
+<style>
+  .iso-map-corner {
+    position: absolute;
+    bottom: 12px;
+    right: 12px;
+    width: 320px;
+    height: 240px;
+    background: var(--bg-1);
+    border: 1px solid var(--line-2);
+    border-radius: 2px;
+    box-shadow: var(--shadow-mini);
+    z-index: 5;
+    overflow: hidden;
+  }
+
+  .iso-map-corner-status {
+    position: absolute;
+    inset: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--fg-3);
+    font-family: var(--font-mono);
+    font-size: 10px;
+    text-transform: uppercase;
+    letter-spacing: 0.12em;
+    text-align: center;
+    padding: 0 12px;
+  }
+</style>
diff --git a/template/src/widgets/iso-map/IsoScene.svelte b/template/src/widgets/iso-map/IsoScene.svelte
new file mode 100644
index 0000000..8bb1ffc
--- /dev/null
+++ b/template/src/widgets/iso-map/IsoScene.svelte
@@ -0,0 +1,210 @@
+<script lang="ts">
+  import { T } from '@threlte/core';
+  import { OrbitControls, interactivity } from '@threlte/extras';
+  import type { MapDocument } from '@/entities/map';
+  import { isDrillable } from '@/entities/map/lib/derive-subdocument';
+  import { themeStore } from '@/shared/lib';
+  import IsoPlane from './ui/IsoPlane.svelte';
+  import IsoSliverPlane from './ui/IsoSliverPlane.svelte';
+  import IsoFrustum from './ui/IsoFrustum.svelte';
+  import IsoIcomArrows from './ui/IsoIcomArrows.svelte';
+  import IsoDeeperMarker from './ui/IsoDeeperMarker.svelte';
+  import {
+    PLANE_GAP,
+    computePlanesForDocs,
+    windowPlanes,
+    computeConnectorGroups,
+    computeIcomArrows,
+    type BoxSpec,
+  } from './lib/iso-projection';
+  import { readIsoColors } from './lib/iso-materials';
+  import {
+    docsForRoot,
+    currentFocusChain,
+    currentDepthWindow,
+    currentDepthWindowAnimIndex,
+    currentAnimationKind,
+    currentEnterProgress,
+    currentExitProgress,
+    currentFocused,
+    setFocused,
+    focusZone,
+    currentDwellTarget,
+    armDwell,
+    disarmDwell,
+  } from './model/iso-view-state.svelte';
+
+  // COMPOSITION ROOT (3D-only): camera + lights + interactivity() live
+  // here; all geometry math is in lib/iso-projection.ts, all material/
+  // color tuning is in lib/iso-materials.ts, all interaction/animation
+  // STATE is in model/iso-view-state.svelte.ts (DIP — this component
+  // consumes that pure model + the rootDoc prop injected from +page.svelte;
+  // it never fetches data itself), and every visible thing is a mounted
+  // <IsoPlane> / <IsoSliverPlane> / <IsoFrustum> / <IsoIcomArrows> /
+  // <IsoDeeperMarker> — no inline geometry, no inline THREE material tuning
+  // (SRP/OCP).
+
+  interactivity();
+
+  let {
+    rootDoc,
+    onDescend,
+  }: {
+    rootDoc: MapDocument;
+    onDescend?: (id: string, label: string) => void;
+  } = $props();
+
+  // Stage 2 — generalized, arbitrary-depth chain (replaces Stage 1's
+  // hardcoded root/layer/derived triple). `docsByDepth` folds
+  // deriveSubDocument (or a cached emitted layer) over the ENTIRE current
+  // focus chain; `rawPlanes` turns that into world-positioned layout data;
+  // `windowedPlanes` applies the depthWindow accordion (expanded vs. thin
+  // collapsed sliver) on top.
+  const docsByDepth = $derived(docsForRoot(rootDoc));
+  const focusChain = $derived(currentFocusChain());
+  const rawPlanes = $derived(computePlanesForDocs(docsByDepth, focusChain));
+  const windowedPlanes = $derived(windowPlanes(rawPlanes, currentDepthWindow()));
+  const deepestDepthIndex = $derived(docsByDepth.length - 1);
+
+  // The absolute depthIndex currently being animated — either a
+  // depthWindow-triggered reveal/collapse (setDepthWindow), or, when none
+  // is in flight, the chain's own deepest index (a descend()/ascend()
+  // drill). Both animation sources share the SAME enter/exit tween pair
+  // (model/iso-view-state.svelte.ts), so exactly one of them is ever
+  // "the" animating index at a time.
+  const animIndex = $derived(currentDepthWindowAnimIndex() ?? deepestDepthIndex);
+
+  const connectorGroups = $derived(computeConnectorGroups(windowedPlanes));
+  const icomArrowPairs = $derived(computeIcomArrows(windowedPlanes, docsByDepth));
+  const settledArrowPairs = $derived(
+    icomArrowPairs.filter((p) => p.childDepthIndex !== animIndex),
+  );
+  const newestArrowPairs = $derived(
+    icomArrowPairs.filter((p) => p.childDepthIndex === animIndex),
+  );
+
+  // The single value driving the CURRENTLY animating plane's grow-in
+  // (descend / depthWindow reveal) / collapse-out (ascend / depthWindow
+  // shrink) animation — every other, already-settled plane/connector/arrow
+  // renders at presence 1 (see model/iso-view-state.svelte.ts#
+  // collapseThenApply for why the underlying state itself only mutates
+  // AFTER this settles on collapse).
+  const animPresence = $derived.by(() => {
+    const kind = currentAnimationKind();
+    if (kind === 'enter') return currentEnterProgress();
+    if (kind === 'exit') return currentExitProgress();
+    return 1;
+  });
+
+  function presenceFor(depthIndex: number): number {
+    return depthIndex === animIndex ? animPresence : 1;
+  }
+
+  // "...deeper" affordance — the deepest doc still has drillable content
+  // the user hasn't descended into yet (depthWindow only renders what's
+  // ALREADY been drilled into, never a preview of what's below it).
+  const deepestDoc = $derived(docsByDepth[docsByDepth.length - 1] ?? null);
+  const hasDeeper = $derived.by(() => {
+    if (!deepestDoc) return false;
+    for (const zone of deepestDoc.zones) {
+      if (isDrillable(deepestDoc, zone.id)) return true;
+    }
+    for (const node of deepestDoc.nodes) {
+      if (node.is_mega && isDrillable(deepestDoc, node.id)) return true;
+    }
+    return false;
+  });
+  const deepestPlane = $derived(windowedPlanes[windowedPlanes.length - 1] ?? null);
+
+  // Theme-reactive colors: `themeStore.tick` is read so this recomputes on
+  // every theme toggle instead of freezing the palette at first paint.
+  const colors = $derived.by(() => {
+    themeStore.tick;
+    return readIsoColors();
+  });
+
+  $effect(() => {
+    themeStore.start();
+    return () => themeStore.stop();
+  });
+
+  const selectedId = $derived(currentFocused()?.id ?? null);
+
+  // Stage 3 — the current hover-dwell target (zone, node, OR plane), read
+  // once here and threaded down as a plain typed VALUE so every rendered
+  // <IsoPlane> below can cheaply check "is it ME" per-box without each
+  // plane re-deriving dwell state itself (ISP: IsoPlane never calls the
+  // model, it only compares the value it was handed).
+  const dwellTarget = $derived(currentDwellTarget());
+
+  // CLICK GATE (unified layer-explosion model) — a drillable zone/mega on
+  // ANY currently expanded plane auto-explodes its subtree down to the
+  // current depthWindow depth; clicking the SAME already-exploded zone
+  // again collapses that subtree back in reverse order; a leaf node only
+  // selects (setFocused above already ran either way). See
+  // model/iso-view-state.svelte.ts#focusZone for the full state machine.
+  // No double-click: a single `onclick` is all either path needs.
+  function handleBoxClick(box: BoxSpec): void {
+    setFocused({ kind: box.kind, id: box.id });
+    const result = focusZone(rootDoc, box.id);
+    if (result === 'explode') onDescend?.(box.id, box.label);
+  }
+</script>
+
+<T.OrthographicCamera
+  makeDefault
+  position={[46, 42, 46]}
+  zoom={7}
+  near={0.1}
+  far={500}
+  oncreate={(ref) => ref.lookAt(0, -PLANE_GAP, 0)}
+>
+  <OrbitControls enableDamping target={[0, -PLANE_GAP, 0]} />
+</T.OrthographicCamera>
+
+<T.AmbientLight intensity={0.7} />
+<T.DirectionalLight position={[20, 30, 15]} intensity={0.9} />
+
+{#each windowedPlanes as plane (plane.id)}
+  {#if plane.mode === 'expanded'}
+    <IsoPlane
+      {plane}
+      planeIndex={plane.depthIndex}
+      dimIndex={deepestDepthIndex - plane.depthIndex}
+      {selectedId}
+      {colors}
+      presence={presenceFor(plane.depthIndex)}
+      interactive={true}
+      {dwellTarget}
+      onBoxClick={handleBoxClick}
+      onPlanePointerEnter={() =>
+        armDwell({ kind: 'plane', planeId: plane.id, depthIndex: plane.depthIndex })}
+      onPlanePointerLeave={() =>
+        disarmDwell({ kind: 'plane', planeId: plane.id, depthIndex: plane.depthIndex })}
+      onNodePointerEnter={(box) => armDwell({ kind: 'node', id: box.id })}
+      onNodePointerLeave={(box) => disarmDwell({ kind: 'node', id: box.id })}
+      onZonePointerEnter={(box) => armDwell({ kind: 'zone', id: box.id })}
+      onZonePointerLeave={(box) => disarmDwell({ kind: 'zone', id: box.id })}
+    />
+  {:else}
+    <IsoSliverPlane {plane} color={colors.plate} />
+  {/if}
+{/each}
+
+{#each connectorGroups as group (group.id)}
+  <IsoFrustum {group} color={colors.accentSoft} presence={presenceFor(group.childDepthIndex)} />
+{/each}
+
+<IsoIcomArrows pairs={settledArrowPairs} color={colors.accent} />
+<IsoIcomArrows pairs={newestArrowPairs} color={colors.accent} presence={animPresence} />
+
+{#if hasDeeper && deepestPlane}
+  <IsoDeeperMarker
+    x={deepestPlane.originX}
+    y={deepestPlane.y}
+    z={deepestPlane.originZ}
+    w={deepestPlane.plateW * 0.3}
+    d={deepestPlane.plateD * 0.3}
+    color={colors.accentSoft}
+  />
+{/if}
diff --git a/template/src/widgets/iso-map/index.ts b/template/src/widgets/iso-map/index.ts
new file mode 100644
index 0000000..24d9e61
--- /dev/null
+++ b/template/src/widgets/iso-map/index.ts
@@ -0,0 +1,7 @@
+// TODO(iso-promote): the shared drill-chain logic this widget depends on
+// (widgets/composed-map/model/shared-drill-bus.svelte.ts) is a lateral
+// widget->widget import (FSD boundary note, RFC-036 Risk R-3) — move it to
+// entities/ on a later graduation pass. This is the ONE canonical copy of
+// this note (EVID-100 Finding #5); no other file under widgets/iso-map/
+// repeats it.
+export { default as IsoMinimap } from "./ui/IsoMinimap.svelte";
diff --git a/template/src/widgets/iso-map/lib/iso-materials.ts b/template/src/widgets/iso-map/lib/iso-materials.ts
new file mode 100644
index 0000000..8a7a952
--- /dev/null
+++ b/template/src/widgets/iso-map/lib/iso-materials.ts
@@ -0,0 +1,137 @@
+// Token -> THREE.Color reader + tuned material constants for the iso-spike.
+// THEME-REACTIVE: `readIsoColors` must be called from inside a `$derived.by`
+// that ALSO reads `themeStore.tick` (see IsoScene.svelte), fixing the former
+// "read once at mount, not reactive to theme" TODO — colors recompute every
+// time the theme toggles instead of freezing at first paint.
+import * as THREE from "three";
+
+export interface IsoColorTokens {
+  /** --accent */
+  accent: THREE.Color;
+  /** --accent-soft */
+  accentSoft: THREE.Color;
+  /** --bg-2 */
+  plate: THREE.Color;
+  /** --fg-2 */
+  node: THREE.Color;
+}
+
+const FALLBACKS = {
+  accent: "#ff5a1f",
+  accentSoft: "#ff8a5b",
+  plate: "#141414",
+  node: "#a3a3a3",
+} as const;
+
+function readCssColor(varName: string, fallback: string): THREE.Color {
+  if (typeof document === "undefined") return new THREE.Color(fallback);
+  const val = getComputedStyle(document.documentElement)
+    .getPropertyValue(varName)
+    .trim();
+  return new THREE.Color(val || fallback);
+}
+
+export function readIsoColors(): IsoColorTokens {
+  return {
+    accent: readCssColor("--accent", FALLBACKS.accent),
+    accentSoft: readCssColor("--accent-soft", FALLBACKS.accentSoft),
+    plate: readCssColor("--bg-2", FALLBACKS.plate),
+    node: readCssColor("--fg-2", FALLBACKS.node),
+  };
+}
+
+// --- Scout-1: matte paper-sheet zone fill --------------------------------
+// Zone fill used to be MeshBasicMaterial opacity 0.02 with NO color
+// (effectively invisible, kept alive only so raycast picking still worked).
+// Now the fill is bound to the SAME color driving <Edges> (see
+// IsoZoneFrame.svelte) at a low-but-visible opacity, so zones read as thin
+// matte sheets tinted in their own outline color.
+//
+// MINIMAP reframe: this view is a compact overview shown alongside the main
+// 2D map, not a heavy interactive surface — sheets read as thin translucent
+// PAPER, not dark plates, so opacity was lowered again (0.16 -> 0.07).
+export const ZONE_FILL_OPACITY = 0.07;
+// polygonOffset (paired with depthWrite:false on the fill material) keeps
+// the coplanar fill + <Edges> outline from z-fighting.
+export const ZONE_POLYGON_OFFSET_FACTOR = -1;
+export const ZONE_POLYGON_OFFSET_UNITS = -1;
+
+// Per-level floor "plate" — thin translucent paper, faintly tinted (MINIMAP
+// reframe: 0.12/0.28 read as heavy dark plates, dropped to 0.03/0.10).
+export const PLATE_THICKNESS = 0.03;
+export const PLATE_Y_OFFSET = PLATE_THICKNESS / 2 + 0.02;
+export const PLATE_OPACITY = 0.1;
+
+// --- Stage 3 (redesigned): per-ELEMENT hover-dwell emphasis --------------
+// Highlights ONLY the individual zone/node under the cursor — the former
+// whole-PLATE emphasis (PLATE_EMPHASIS_OPACITY_MULT, boosting the entire
+// sheet's fill + gating a bright <Edges> outline on the plate itself) is
+// retired: on a minimap, brightening the whole sheet for one hovered box
+// is disproportionate. `brightenForEmphasis` lightens the element's OWN
+// color toward white; callers (IsoZoneFrame/IsoNodeBox) pair it with a
+// modest fill boost for translucent elements.
+export const ELEMENT_EMPHASIS_LERP = 0.55;
+export const ELEMENT_EMPHASIS_FILL_MULT = 1.8;
+
+/** Brightens `color` toward white for the per-element hover-dwell
+ * highlight. Returns a NEW THREE.Color; never mutates the input. */
+export function brightenForEmphasis(color: THREE.Color): THREE.Color {
+  return color.clone().lerp(new THREE.Color(1, 1, 1), ELEMENT_EMPHASIS_LERP);
+}
+
+// Monotonic depth falloff: shallower planes (index 0 = root) keep full
+// tint; deeper planes dim toward PLANE_FALLOFF_MIN so the exploded stack
+// reads front-to-back.
+export const PLANE_FALLOFF_STEP = 0.42;
+export const PLANE_FALLOFF_MIN = 0.22;
+
+/** Opacity multiplier for a plane at `index` (0 = shallowest/root). */
+export function planeFalloff(index: number): number {
+  return Math.max(PLANE_FALLOFF_MIN, 1 - index * PLANE_FALLOFF_STEP);
+}
+
+// Desaturation companion to the opacity falloff above — deeper planes lose
+// saturation toward neutral gray, on top of dimming.
+export const PLANE_DESATURATION_STEP = 0.09;
+export const PLANE_DESATURATION_MAX = 0.3;
+
+/** Desaturates `color` toward neutral gray as depth `index` increases.
+ * Returns a NEW THREE.Color; never mutates the input. */
+export function desaturateForDepth(
+  color: THREE.Color,
+  index: number,
+): THREE.Color {
+  const amount = Math.min(
+    PLANE_DESATURATION_MAX,
+    index * PLANE_DESATURATION_STEP,
+  );
+  if (amount <= 0) return color.clone();
+  const hsl = { h: 0, s: 0, l: 0 };
+  color.getHSL(hsl);
+  return new THREE.Color().setHSL(hsl.h, hsl.s * (1 - amount), hsl.l);
+}
+
+// --- Fine dashed lines (frustum connectors + ICOM boundary arrows) -------
+// Thinner, higher dash frequency, shorter dash segments than the original
+// fat-dash pass — a fine dotted look instead of chunky dashes.
+//
+// The now-thin translucent plates (PLATE_OPACITY/ZONE_FILL_OPACITY above)
+// made these lines nearly invisible where they cross a sheet — fixed by
+// pairing near-opaque CONNECTOR_LINE_OPACITY with `depthTest={false}` +
+// a high `renderOrder` on the mesh (see IsoFrustum.svelte /
+// IsoIcomArrows.svelte), so the dashed corner-to-corner lines always
+// paint ON TOP of every plate/zone sheet regardless of draw order.
+export const CONNECTOR_LINE_WIDTH = 0.8;
+export const CONNECTOR_LINE_OPACITY = 1;
+export const CONNECTOR_DASH_ARRAY = 0.06;
+export const CONNECTOR_DASH_RATIO = 0.65;
+
+export const ICOM_ARROW_WIDTH = 1.2;
+export const ICOM_ARROW_OPACITY = 0.95;
+export const ICOM_ARROW_DASH_ARRAY = 0.06;
+export const ICOM_ARROW_DASH_RATIO = 0.65;
+
+/** Shared renderOrder for dashed connector/arrow meshes — always higher
+ * than any plate's own `renderOrder={planeIndex}` (see IsoPlane.svelte),
+ * so these lines composite after (visually on top of) every sheet. */
+export const LINE_RENDER_ORDER = 1000;
diff --git a/template/src/widgets/iso-map/lib/iso-projection.ts b/template/src/widgets/iso-map/lib/iso-projection.ts
new file mode 100644
index 0000000..70bb827
--- /dev/null
+++ b/template/src/widgets/iso-map/lib/iso-projection.ts
@@ -0,0 +1,445 @@
+// Pure geometry/projection helpers for the iso-spike 3D layered map. No
+// Svelte, no THREE materials — only math + plain data (THREE.Vector3 is a
+// math primitive, not a material). Stage 2 (RFC-031-style generalization):
+// every function here now operates over an ARBITRARY-length chain of
+// already-resolved MapDocuments (one per altitude) instead of Stage 1's
+// hardcoded root/layer/derived triple — drill-derivation itself
+// (deriveSubDocument / emitted-layer preference) lives entirely in
+// model/iso-view-state.svelte.ts's `docsForRoot`; this file only turns a
+// resolved `MapDocument[]` + its focus-id chain into 3D layout data.
+import * as THREE from "three";
+import { computeComposedLayout } from "@/entities/map/lib/composed-layout";
+import type { MapDocument } from "@/entities/map";
+import {
+  classifyIcom,
+  icomToSide,
+  isCanonicalRelation,
+} from "@/shared/lib/idef0";
+import type { IcomSide } from "@/shared/lib/idef0";
+
+export const SCALE = 0.06;
+export const PLANE_GAP = 26;
+// IDEF0 read: a zone is a thin outlined FRAME (a region boundary), not a
+// filled volume — ZONE_FRAME_H is just enough height to give <Edges> a box
+// to outline. NODE_BOX_H is the readable content and stays much taller.
+export const ZONE_FRAME_H = 0.5;
+export const NODE_BOX_H = 1.2;
+export const NODE_FOOTPRINT = 0.82;
+export const ICOM_ARROW_LEN = 1.4;
+
+// Stage 2 — accordion collapse: how tightly collapsed ancestor "sliver"
+// planes stack above the expanded window (much smaller than PLANE_GAP, so
+// a long drill history still compresses into a small visual footprint
+// "near the focus" instead of receding to infinity).
+export const SLIVER_GAP = 1.6;
+
+export interface BoxSpec {
+  id: string;
+  label: string;
+  kind: "zone" | "node";
+  x: number;
+  z: number;
+  w: number;
+  d: number;
+}
+
+export interface PlaneSpec {
+  /** Stable identity across renders (keyed {#each}) — "root", or the
+   * dot-free join of the focus chain up to and including this depth. */
+  id: string;
+  /** The focusId that produced this plane (the zone/mega clicked into the
+   * PARENT plane to reveal this one). null for the root plane. */
+  focusId: string | null;
+  label: string;
+  y: number;
+  /** World (x,z) of the parent zone-box this plane funnels under — (0,0)
+   * for the root plane. See `computePlanesForDocs` below (FIX R1). */
+  originX: number;
+  originZ: number;
+  boxes: BoxSpec[];
+  plateW: number;
+  plateD: number;
+}
+
+export interface WindowedPlane extends PlaneSpec {
+  /** "expanded" = fully rendered (plate + boxes, clickable if deepest);
+   * "sliver" = collapsed ancestor, rendered as a thin bare plate only. */
+  mode: "expanded" | "sliver";
+  /** Absolute index into the full (unwindowed) docsByDepth/planes chain —
+   * 0 is always the root, regardless of how the window is currently sized. */
+  depthIndex: number;
+}
+
+export function boxesForDoc(doc: MapDocument): {
+  boxes: BoxSpec[];
+  plateW: number;
+  plateD: number;
+} {
+  const layout = computeComposedLayout(doc);
+  const cx = layout.width / 2;
+  const cz = layout.height / 2;
+  const boxes: BoxSpec[] = [];
+  for (const zone of doc.zones) {
+    const rect = layout.zoneRects.get(zone.id);
+    if (!rect) continue;
+    boxes.push({
+      id: zone.id,
+      label: zone.label,
+      kind: "zone",
+      x: (rect.x + rect.w / 2 - cx) * SCALE,
+      z: (rect.y + rect.h / 2 - cz) * SCALE,
+      w: Math.max(rect.w * SCALE, 1),
+      d: Math.max(rect.h * SCALE, 1),
+    });
+  }
+  for (const node of doc.nodes) {
+    const pos = layout.nodePositions.get(node.id);
+    if (!pos) continue;
+    boxes.push({
+      id: node.id,
+      label: node.label,
+      kind: "node",
+      x: (pos.x + doc.canvas.cell.card_w / 2 - cx) * SCALE,
+      z: (pos.y + doc.canvas.cell.card_h / 2 - cz) * SCALE,
+      w: doc.canvas.cell.card_w * SCALE,
+      d: doc.canvas.cell.card_h * SCALE,
+    });
+  }
+  return {
+    boxes,
+    plateW: Math.max(layout.width * SCALE, 1),
+    plateD: Math.max(layout.height * SCALE, 1),
+  };
+}
+
+// IDEF0 explosion (FIPS PUB 183 §3.3.1.2-3 Fig.6): each deeper plane must
+// sit UNDER the specific parent zone-box it details, not at world (0,0) —
+// otherwise every plane stacks dead-center and the scene reads as a
+// centered stack, never an explosion. Generalized (Stage 2) to fold over
+// however many `docs` the drill history has accumulated: `docs[i]` is the
+// document revealed by descending into `focusChain[i-1]` (docs[0] is
+// always the root, with no corresponding focusChain entry).
+export function computePlanesForDocs(
+  docs: readonly MapDocument[],
+  focusChain: readonly string[],
+): PlaneSpec[] {
+  const planes: PlaneSpec[] = [];
+  let originX = 0;
+  let originZ = 0;
+  for (let i = 0; i < docs.length; i++) {
+    const shape = boxesForDoc(docs[i]!);
+    let label = "WHOLE SYSTEM";
+    let focusId: string | null = null;
+    if (i > 0) {
+      focusId = focusChain[i - 1]!;
+      const parent = planes[i - 1]!;
+      const box = parent.boxes.find((b) => b.id === focusId);
+      originX = parent.originX + (box?.x ?? 0);
+      originZ = parent.originZ + (box?.z ?? 0);
+      label = box?.label ?? focusId;
+    }
+    planes.push({
+      id: i === 0 ? "root" : focusChain.slice(0, i).join(">"),
+      focusId,
+      label,
+      y: -PLANE_GAP * i,
+      originX,
+      originZ,
+      ...shape,
+    });
+  }
+  return planes;
+}
+
+// ACCORDION depthWindow (MINIMAP reframe — ROOT-ANCHORED): of the full
+// (arbitrary-depth) `planes` chain, the FIRST `depthWindow` entries — root
+// downward — render "expanded" (full plate + boxes); everything DEEPER
+// collapses to a thin "sliver" stacked tightly BELOW the expanded block
+// (SLIVER_GAP apart, not PLANE_GAP). depthWindow=1 is root only (no
+// explosion); 2 is root + the first child level exploded below; 3 adds one
+// more level below that. The window is always contiguous from the top —
+// root (index 0) is never hidden while a deeper index is shown — so
+// increasing depthWindow reveals exactly the next-deeper level and
+// decreasing it collapses exactly the deepest-currently-visible level
+// first. Root's own position never moves (still y=0, same as the
+// unwindowed `planes` passed in); only planes past the window are
+// repositioned into the sliver stack.
+export function windowPlanes(
+  planes: readonly PlaneSpec[],
+  depthWindow: number,
+): WindowedPlane[] {
+  const total = planes.length;
+  const windowSize = Math.max(1, Math.min(depthWindow, total));
+  const expandedBottomY = -PLANE_GAP * (windowSize - 1);
+  return planes.map((plane, i) => {
+    if (i < windowSize) {
+      return { ...plane, mode: "expanded" as const, depthIndex: i };
+    }
+    const sliverDepth = i - windowSize + 1;
+    return {
+      ...plane,
+      y: expandedBottomY - SLIVER_GAP * sliverDepth,
+      mode: "sliver" as const,
+      depthIndex: i,
+    };
+  });
+}
+
+// IDEF0 exploded pyramid: 4 lines from a parent zone's 4 top corners down
+// to the 4 corners of the child level's floor frame (a truncated-pyramid /
+// frustum wireframe), the signature "explosion" connector look. Each
+// corner is its own <MeshLineGeometry> segment (not one combined
+// THREE.LineSegments buffer) so every segment can carry
+// MeshLineMaterial's dashArray/dashRatio — FIPS Fig.6 draws correspondence
+// lines dashed, not solid. `attenuate={false}` (set by callers) is
+// load-bearing: MeshLine's default world-unit width attenuation is what
+// produced huge misshapen kite polygons under this scene's
+// OrthographicCamera in an earlier pass; pixel-space width (attenuate off)
+// sidesteps that entirely.
+export function rectCorners(
+  cx: number,
+  cz: number,
+  w: number,
+  d: number,
+  y: number,
+): [THREE.Vector3, THREE.Vector3, THREE.Vector3, THREE.Vector3] {
+  const hw = w / 2;
+  const hd = d / 2;
+  return [
+    new THREE.Vector3(cx - hw, y, cz - hd),
+    new THREE.Vector3(cx + hw, y, cz - hd),
+    new THREE.Vector3(cx + hw, y, cz + hd),
+    new THREE.Vector3(cx - hw, y, cz + hd),
+  ];
+}
+
+export interface CornerSegment {
+  id: string;
+  points: [THREE.Vector3, THREE.Vector3];
+}
+
+export interface PyramidGroup {
+  id: string;
+  /** Absolute depth index of the CHILD plane this connector leads to — lets
+   * IsoScene apply the child's enter/exit presence to this connector too. */
+  childDepthIndex: number;
+  segments: CornerSegment[];
+}
+
+export function pyramidSegments(
+  idPrefix: string,
+  parent: { x: number; z: number; w: number; d: number; y: number },
+  child: { x: number; z: number; plateW: number; plateD: number; y: number },
+): CornerSegment[] {
+  const parentCorners = rectCorners(
+    parent.x,
+    parent.z,
+    parent.w,
+    parent.d,
+    parent.y,
+  );
+  const childCorners = rectCorners(
+    child.x,
+    child.z,
+    child.plateW,
+    child.plateD,
+    child.y,
+  );
+  return parentCorners.map((corner, i) => ({
+    id: `${idPrefix}-corner-${i}`,
+    points: [corner, childCorners[i]!] as [THREE.Vector3, THREE.Vector3],
+  }));
+}
+
+// Generalized (Stage 2): one connector group per CONSECUTIVE pair of
+// EXPANDED planes (a sliver ancestor carries no boxes, so there is no
+// meaningful parent-box anchor to frustum from/to — collapsed history is
+// conveyed by tight sliver-stack proximity alone, not by connector lines).
+export function computeConnectorGroups(
+  planes: readonly WindowedPlane[],
+): PyramidGroup[] {
+  const list: PyramidGroup[] = [];
+  for (let i = 1; i < planes.length; i++) {
+    const parent = planes[i - 1]!;
+    const child = planes[i]!;
+    if (parent.mode !== "expanded" || child.mode !== "expanded") continue;
+    if (child.focusId === null) continue;
+    const parentBox = parent.boxes.find((b) => b.id === child.focusId);
+    if (!parentBox) continue;
+    list.push({
+      id: `${parent.id}->${child.id}`,
+      childDepthIndex: child.depthIndex,
+      segments: pyramidSegments(
+        `${parent.id}-${child.id}`,
+        {
+          x: parent.originX + parentBox.x,
+          z: parent.originZ + parentBox.z,
+          w: parentBox.w,
+          d: parentBox.d,
+          y: parent.y + ZONE_FRAME_H,
+        },
+        {
+          x: child.originX,
+          z: child.originZ,
+          plateW: child.plateW,
+          plateD: child.plateD,
+          y: child.y,
+        },
+      ),
+    });
+  }
+  return list;
+}
+
+// ICOM boundary arrows (FIPS Fig.6's signature feature, §3.3.2.7-8
+// Figs.14-15). For each zone being exploded, find the OWN document's edges
+// that cross the zone's node-membership boundary (one endpoint inside,
+// one outside), classify each via the real ADR-007 `classifyIcom` (never
+// reinvented here), and draw one representative arrow per ICOM side
+// (input/control/output/mechanism) — capped at one per side so a dense
+// real graph doesn't turn into visual noise (FIPS tunneling escape
+// hatch; v1 does not continue arrows into the child's own internal
+// arrows either). `decomposition` (the `refines` relation) is excluded:
+// it IS the exploded pyramid connector itself, not a boundary face —
+// counting it again as an arrow would double-represent the same edge.
+// Provenance (SPEC-004 honesty): a canonical forgeplan relation is real
+// (solid line); anything else — e.g. this workspace's own `imports`
+// code-dep edges — is classifyIcom's honest E-UNKNOWN fallback and
+// renders dashed, same as the frustum's derived/inferred convention.
+export interface IcomArrowSpec {
+  id: string;
+  side: IcomSide;
+  provenance: "real" | "derived";
+}
+
+export function classifyZoneBoundaryEdges(
+  doc: MapDocument,
+  zoneId: string,
+): IcomArrowSpec[] {
+  const inZoneIds = new Set(
+    doc.nodes.filter((n) => n.zone === zoneId).map((n) => n.id),
+  );
+  if (inZoneIds.size === 0) return [];
+  const seenSide = new Set<IcomSide>();
+  const specs: IcomArrowSpec[] = [];
+  for (const edge of doc.edges) {
+    const fromIn = inZoneIds.has(edge.from);
+    const toIn = inZoneIds.has(edge.to);
+    if (fromIn === toIn) continue; // not a boundary edge — both in or both out
+    const icom = classifyIcom(edge.relation);
+    if (icom === "decomposition") continue; // structural tree edge, not an ICOM face
+    const side = icomToSide(icom);
+    if (seenSide.has(side)) continue; // TODO(spike-icom): capped to 1 arrow/side, see comment above
+    seenSide.add(side);
+    specs.push({
+      id: `${zoneId}-${side}`,
+      side,
+      provenance: isCanonicalRelation(edge.relation) ? "real" : "derived",
+    });
+  }
+  return specs;
+}
+
+export function faceAnchor(
+  cx: number,
+  cz: number,
+  w: number,
+  d: number,
+  side: IcomSide,
+): { x: number; z: number; nx: number; nz: number } {
+  switch (side) {
+    case "left":
+      return { x: cx - w / 2, z: cz, nx: -1, nz: 0 };
+    case "right":
+      return { x: cx + w / 2, z: cz, nx: 1, nz: 0 };
+    case "top":
+      return { x: cx, z: cz - d / 2, nx: 0, nz: -1 };
+    case "bottom":
+    default:
+      return { x: cx, z: cz + d / 2, nx: 0, nz: 1 };
+  }
+}
+
+export interface IcomArrowGeom {
+  id: string;
+  points: [THREE.Vector3, THREE.Vector3];
+  provenance: "real" | "derived";
+}
+
+export function icomArrowSegment(
+  id: string,
+  anchor: { x: number; z: number; nx: number; nz: number },
+  y: number,
+  provenance: "real" | "derived",
+): IcomArrowGeom {
+  const inner = new THREE.Vector3(anchor.x, y, anchor.z);
+  const outer = new THREE.Vector3(
+    anchor.x + anchor.nx * ICOM_ARROW_LEN,
+    y,
+    anchor.z + anchor.nz * ICOM_ARROW_LEN,
+  );
+  return { id, points: [inner, outer], provenance };
+}
+
+export interface IcomArrowPair {
+  id: string;
+  /** Same purpose as PyramidGroup.childDepthIndex (see above). */
+  childDepthIndex: number;
+  parent: IcomArrowGeom;
+  child: IcomArrowGeom;
+}
+
+// Generalized (Stage 2): loops every consecutive EXPANDED plane pair,
+// reading boundary edges from `docs[i-1]` (the PARENT altitude's own
+// document — same source Stage 1 used per hardcoded pair).
+export function computeIcomArrows(
+  planes: readonly WindowedPlane[],
+  docs: readonly MapDocument[],
+): IcomArrowPair[] {
+  const list: IcomArrowPair[] = [];
+  for (let i = 1; i < planes.length; i++) {
+    const parent = planes[i - 1]!;
+    const child = planes[i]!;
+    if (parent.mode !== "expanded" || child.mode !== "expanded") continue;
+    if (child.focusId === null) continue;
+    const parentDoc = docs[i - 1];
+    if (!parentDoc) continue;
+    const parentBox = parent.boxes.find((b) => b.id === child.focusId);
+    if (!parentBox) continue;
+    const parentCx = parent.originX + parentBox.x;
+    const parentCz = parent.originZ + parentBox.z;
+    for (const spec of classifyZoneBoundaryEdges(parentDoc, child.focusId)) {
+      const parentAnchor = faceAnchor(
+        parentCx,
+        parentCz,
+        parentBox.w,
+        parentBox.d,
+        spec.side,
+      );
+      const childAnchor = faceAnchor(
+        child.originX,
+        child.originZ,
+        child.plateW,
+        child.plateD,
+        spec.side,
+      );
+      list.push({
+        id: `${parent.id}-${spec.id}`,
+        childDepthIndex: child.depthIndex,
+        parent: icomArrowSegment(
+          `${parent.id}-${spec.id}-parent`,
+          parentAnchor,
+          parent.y + ZONE_FRAME_H,
+          spec.provenance,
+        ),
+        child: icomArrowSegment(
+          `${parent.id}-${spec.id}-child`,
+          childAnchor,
+          child.y,
+          spec.provenance,
+        ),
+      });
+    }
+  }
+  return list;
+}
diff --git a/template/src/widgets/iso-map/lib/leader-line.ts b/template/src/widgets/iso-map/lib/leader-line.ts
new file mode 100644
index 0000000..0b0adef
--- /dev/null
+++ b/template/src/widgets/iso-map/lib/leader-line.ts
@@ -0,0 +1,36 @@
+// Pure geometry for IsoLeaderLine: clamps a point onto the nearest edge of
+// a DOMRect, so the leader line's card-side endpoint always lands ON the
+// card's border rather than floating inside it. No Svelte, no DOM globals
+// beyond the DOMRect/Point shapes themselves (same "pure helper" pattern
+// as iso-projection.ts/iso-materials.ts).
+export interface Point {
+  x: number;
+  y: number;
+}
+
+export function nearestRectEdgePoint(
+  rect: Pick<DOMRect, "left" | "right" | "top" | "bottom">,
+  x: number,
+  y: number,
+): Point {
+  const clampedX = Math.min(Math.max(x, rect.left), rect.right);
+  const clampedY = Math.min(Math.max(y, rect.top), rect.bottom);
+  const insideX = x > rect.left && x < rect.right;
+  const insideY = y > rect.top && y < rect.bottom;
+
+  // (x,y) strictly inside the rect (the anchor sits behind its own card,
+  // e.g. a degenerate/very small viewport) — push out to the CLOSER edge
+  // instead of leaving the endpoint floating inside the card.
+  if (insideX && insideY) {
+    const candidates: Array<{ dist: number; point: Point }> = [
+      { dist: x - rect.left, point: { x: rect.left, y } },
+      { dist: rect.right - x, point: { x: rect.right, y } },
+      { dist: y - rect.top, point: { x, y: rect.top } },
+      { dist: rect.bottom - y, point: { x, y: rect.bottom } },
+    ];
+    candidates.sort((a, b) => a.dist - b.dist);
+    return candidates[0]!.point;
+  }
+
+  return { x: clampedX, y: clampedY };
+}
diff --git a/template/src/widgets/iso-map/lib/motion.ts b/template/src/widgets/iso-map/lib/motion.ts
new file mode 100644
index 0000000..39df0fc
--- /dev/null
+++ b/template/src/widgets/iso-map/lib/motion.ts
@@ -0,0 +1,14 @@
+// Route-local copy of widgets/dependency-graph/lib/reduced-motion.ts's
+// `motionDuration` helper. That file is not part of dependency-graph's
+// public index.ts barrel, so importing it directly would reach into
+// another widget's private lib/ (FSD encapsulation violation) — this route
+// owns an identical, tiny copy instead until promotion (see
+// widgets/iso-map/index.ts's canonical TODO(iso-promote)) hoists a shared
+// version both call sites can use. Safe on server:
+// matchMedia is window-only, so it guards.
+export function motionDuration(defaultMs: number): number {
+  if (typeof window === "undefined") return defaultMs;
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches
+    ? 0
+    : defaultMs;
+}
diff --git a/template/src/widgets/iso-map/model/iso-view-state.render.test.ts b/template/src/widgets/iso-map/model/iso-view-state.render.test.ts
new file mode 100644
index 0000000..2b04213
--- /dev/null
+++ b/template/src/widgets/iso-map/model/iso-view-state.render.test.ts
@@ -0,0 +1,160 @@
+import { describe, it, expect, vi } from "vitest";
+import { tick } from "svelte";
+import type { MapDocument } from "@/entities/map";
+import { chainsEqual } from "@/widgets/composed-map/model/shared-drill-bus.svelte";
+
+// RFC-036 Test Strategy Hooks / EVID-100 Finding #1 — the mid-animation
+// convergence fix: a focus-chain update that arrives while iso-view-state's
+// own enter/exit tween is in flight is recorded (`pendingExternal`) and
+// re-applied by the module's `$effect.root` watcher once the animation
+// settles, so the 3D view always converges to the LATEST shared chain.
+//
+// This lives in a `.render.test.ts` file (the "dom" vitest project:
+// happy-dom + `resolve.conditions: ["browser"]`), not a plain `.test.ts`
+// ("unit" project: node), because the retry mechanism is driven entirely by
+// a Svelte `$effect` — and `$effect` compiles to a no-op under "unit"'s
+// node/SSR transform (effects are a client-only lifecycle concept; verified
+// empirically with a minimal $effect.root repro that never ran its effect
+// body, not even once, at module-init time, under "unit"). Only the "dom"
+// project's browser-conditioned, client-generated build actually runs
+// `$effect` bodies, so this is the one place the fix can be exercised for
+// real rather than asserted against a mechanism that never fires.
+vi.mock("@/widgets/iso-map/lib/motion", () => ({
+  motionDuration: () => 0,
+}));
+
+// iso-view-state.svelte.ts imports `validateMapDocument` (a runtime value)
+// from the `@/entities/map` barrel, which also re-exports
+// `mapPoller`/`acquireMapPolling` (entities/map/api/store.ts ->
+// shared/api/poller.svelte.ts). `validateMapDocument` is never actually
+// invoked by the code paths these tests exercise (the test focus ids never
+// match `isRootZoneDescend`, so the per-zone-layer fetch that would call it
+// never fires) — stubbing the barrel keeps this test focused on the
+// animation/effect seam without depending on the poller's own behaviour.
+vi.mock("@/entities/map", () => ({
+  validateMapDocument: vi.fn(),
+}));
+
+const {
+  currentFocusChain,
+  currentLevelStack,
+  currentAnimationKind,
+  applyExternalFocusChain,
+  ascend,
+} = await import("./iso-view-state.svelte");
+
+// A minimal, valid MapDocument (same shape as
+// composed-map/model/level-documents.test.ts#baseDoc). Only used as the
+// `rootDoc` argument to `applyExternalFocusChain` — its zones deliberately
+// do NOT contain the test's focus ids ("ext-a" / "ext-b"), so
+// `isRootZoneDescend` is always false and no per-zone layer `fetch()` is
+// ever kicked off.
+const rootDoc: MapDocument = {
+  schema: "forgeplan.map/v1",
+  meta: {
+    map_id: "test",
+    status: "confirmed",
+    project_type: "generic",
+    composition_id: "c1",
+    source_fingerprint: "fp",
+    version: 1,
+  },
+  canvas: {
+    grid: { cols: 1, rows: 1 },
+    gap: { x: 88, y: 70 },
+    margin: 40,
+    cell: {
+      card_w: 190,
+      card_h: 60,
+      card_gap: 36,
+      zpad: { top: 50, side: 24, bottom: 24 },
+    },
+  },
+  composition: {
+    template: "generic",
+    arrangement: "stack-ttb",
+    entry_zone: "z.a",
+    placements: [{ zone: "z.a", cell: { row: 0, col: 0 } }],
+    zone_connectors: [],
+  },
+  zones: [
+    {
+      id: "z.a",
+      label: "Zone A",
+      kind: "surface",
+      accent: "--map-accent-cyan",
+      treatment: "neutral-dashed",
+      rule_edge: "off",
+      layout_rule: "grid",
+      cols: 2,
+    },
+  ],
+  nodes: [
+    {
+      id: "n1",
+      label: "Node 1",
+      kind: "component",
+      zone: "z.a",
+      found_at: "2026-01-01T00:00:00.000Z",
+    },
+  ],
+  edges: [],
+};
+
+describe("iso-view-state — mid-animation convergence (RFC-036 Test Strategy Hooks / EVID-100 Finding #1)", () => {
+  // These tests share the iso-view-state module singleton (no reset hook is
+  // exported) and build on each other's ending state in declaration order —
+  // root -> mid-flight -> converged — mirroring
+  // composed-map/model/drill-state.test.ts's incremental-stack pattern.
+
+  it("ascend() is a no-op at the root level (nothing to ascend from)", () => {
+    expect(currentFocusChain()).toEqual([]);
+    const stackBefore = currentLevelStack();
+    ascend();
+    expect(currentLevelStack()).toBe(stackBefore);
+    expect(currentFocusChain()).toEqual([]);
+  });
+
+  it("records the pending target while an animation is in flight, then converges to the LATEST chain once it settles (no permanent drift)", async () => {
+    // First external update starts an enter animation for "ext-a"; its own
+    // synchronous prelude (levelStack push + animationKind = "enter") runs
+    // before the function's first `await`, so it is observable immediately.
+    const first = applyExternalFocusChain(rootDoc, ["ext-a"]);
+    expect(currentAnimationKind()).toBe("enter");
+    expect(currentFocusChain()).toEqual(["ext-a"]);
+
+    // A second, deeper update arrives while the first is still animating —
+    // the 3D can't apply it immediately, so it must be RECORDED (not
+    // dropped, not applied out of order): the chain must NOT yet show
+    // "ext-b".
+    const second = applyExternalFocusChain(rootDoc, ["ext-a", "ext-b"]);
+    expect(currentFocusChain()).toEqual(["ext-a"]);
+
+    await Promise.all([first, second]);
+
+    // Let the module's own `$effect.root` watcher (which re-applies the
+    // pending target once `animationKind` settles back to null) run to
+    // completion. Polled via `tick()` — a microtask + reactivity flush, not
+    // a real timer/animation frame — so this stays deterministic and fast.
+    for (let i = 0; i < 20; i++) {
+      if (
+        currentAnimationKind() === null &&
+        chainsEqual(currentFocusChain(), ["ext-a", "ext-b"])
+      ) {
+        break;
+      }
+      await tick();
+    }
+
+    expect(currentAnimationKind()).toBeNull();
+    expect(currentFocusChain()).toEqual(["ext-a", "ext-b"]);
+  });
+
+  it("is idempotent once converged — reconciling to the already-current chain triggers no animation and no state churn", async () => {
+    expect(currentFocusChain()).toEqual(["ext-a", "ext-b"]);
+    const stackBefore = currentLevelStack();
+    await applyExternalFocusChain(rootDoc, ["ext-a", "ext-b"]);
+    expect(currentAnimationKind()).toBeNull();
+    expect(currentLevelStack()).toBe(stackBefore);
+  });
+});
diff --git a/template/src/widgets/iso-map/model/iso-view-state.svelte.ts b/template/src/widgets/iso-map/model/iso-view-state.svelte.ts
new file mode 100644
index 0000000..9361738
--- /dev/null
+++ b/template/src/widgets/iso-map/model/iso-view-state.svelte.ts
@@ -0,0 +1,678 @@
+// Stage 2 — dynamic re-layering + collapse/animate + accordion depthWindow.
+// ALL new interaction/animation state for the iso-spike route lives here
+// (SRP): the levelStack (RFC-031's own LevelFrame, reused verbatim — 3D
+// pushLevel/popLevel/climbTo pass a dummy {x:0,y:0,k:1} transform since
+// OrbitControls owns its own camera state independently of drill altitude),
+// the depthWindow accordion setting, the on-demand emitted-layer cache
+// (PRD-038 FR-002, the same fetch-once-per-zone gate ComposedMapView uses),
+// and the enter/exit presence tweens driving a plane's grow-in / collapse-
+// out animation. IsoScene.svelte CONSUMES this module (calls the exported
+// functions, reads plane presence) — every other component (IsoPlane,
+// IsoZoneFrame, IsoNodeBox, IsoFrustum, IsoIcomArrows, IsoSliverPlane,
+// IsoDeeperMarker, IsoControls) stays a dumb, prop-only renderer
+// (SRP/ISP/DIP) and never imports this module directly except IsoScene and
+// +page.svelte (the two composition roots — 3D scene and page shell).
+//
+// Mirrors the module-level $state store shape used by
+// widgets/composed-map/model/camera-bus.svelte.ts (no class, one shared
+// instance per page) — same pattern the Stage-1 skeleton already used for
+// hovered/focused below.
+
+import { Tween } from "svelte/motion";
+import {
+  validateMapDocument,
+  type MapDocument,
+  type MapNode,
+} from "@/entities/map";
+import { isDrillable } from "@/entities/map/lib/derive-subdocument";
+import {
+  buildLevelDocuments,
+  isRootZoneDescend,
+} from "@/widgets/composed-map/model/level-documents";
+import {
+  pushLevel,
+  popLevel,
+  focusChain,
+  rootFrame,
+  type LevelFrame,
+} from "@/widgets/composed-map/model/drill-state";
+import {
+  buildNodeConnections,
+  type NodeConnection,
+} from "@/widgets/composed-map/model/node-tabs.svelte";
+import {
+  computePlanesForDocs,
+  windowPlanes,
+  NODE_BOX_H,
+} from "../lib/iso-projection";
+import { motionDuration } from "../lib/motion";
+
+export interface IsoViewTarget {
+  kind: "zone" | "node";
+  id: string;
+}
+
+// ---- pointer focus/hover ---------------------------------------------
+// Stage-1 skeleton, now wired as the real "selected box" store, closing
+// that stage's own TODO ("replace the local selectedId state in
+// IsoScene.svelte with this focus store"). The former hover stub
+// (setHovered/currentHovered) is retired in favor of the Stage-3 dwell
+// system at the bottom of this file — a plane/sheet hover target isn't an
+// IsoViewTarget (it has no zone/node id), so it needed its own shape
+// rather than overloading this one.
+let focused = $state<IsoViewTarget | null>(null);
+
+export function setFocused(target: IsoViewTarget | null): void {
+  focused = target;
+}
+
+export function currentFocused(): IsoViewTarget | null {
+  return focused;
+}
+
+// ---- drill-down level stack (generalized, arbitrary depth) -----------
+const DUMMY_TRANSFORM = { x: 0, y: 0, k: 1 };
+const ENTER_MS = 320;
+const EXIT_MS = 260;
+
+let levelStack = $state<LevelFrame[]>([rootFrame(1)]);
+
+// ACCORDION (MINIMAP reframe — ROOT-ANCHORED) — how many levels, root
+// downward, render fully expanded (plate + boxes); anything DEEPER
+// collapses to a thin sliver (see lib/iso-projection.ts#windowPlanes).
+let depthWindow = $state<1 | 2 | 3>(2);
+
+// The single absolute depthIndex (into the unwindowed docsByDepth/planes
+// chain) whose presence is CURRENTLY being tweened by a depthWindow change
+// (setDepthWindow below) — as opposed to a descend()/ascend() chain
+// mutation, which always animates the chain's own deepest index instead.
+// `null` means "no depthWindow-triggered animation in flight"; IsoScene
+// falls back to the deepest chain index in that case (see
+// IsoScene.svelte#presenceFor) so the two animation sources share one
+// enter/exit tween pair without fighting over which plane it applies to.
+let depthWindowAnimIndex = $state<number | null>(null);
+
+// PRD-038 FR-002 (E3 seam) — identical on-demand per-zone-layer cache/fetch
+// gate as ComposedMapView.maybeFetchLayer: fetched at most once per zoneId,
+// `null` cached on absent/invalid (client-derived deriveSubDocument fold
+// applies, via buildLevelDocuments). This 3D scene has only one root, so
+// "first descent from root" is whatever depth the user is currently
+// drilling from — buildLevelDocuments already encodes that rule (it only
+// ever consults the cache for focusChain index 0).
+let layerCache = $state<Map<string, MapDocument | null>>(new Map());
+const pendingLayerFetches = new Set<string>();
+
+// Guards re-entrant descend/ascend/climbTo while an enter/exit tween is in
+// flight, and tells IsoScene which tween value currently applies to the
+// deepest rendered plane (and its connectors/arrows).
+let animationKind = $state<"enter" | "exit" | null>(null);
+const enterProgress = new Tween(0, { duration: 0 });
+const exitProgress = new Tween(1, { duration: 0 });
+
+// The most recently DROPPED external focus-chain target (see
+// applyExternalFocusChain below) — recorded whenever a chain update from
+// the shared drill-bus arrives while `animationKind !== null` and can't be
+// applied yet. `$effect.root` gives this module its own detached reactive
+// scope (no component owner, same shape Svelte's own testing docs use for
+// a plain .svelte.ts module) that watches `animationKind` and retries the
+// pending target the instant it settles back to `null` — so the 3D view
+// always converges to the latest shared chain even if no FURTHER external
+// chain change ever arrives (EVID-100 Finding #1 / RFC-036 NFR-004 /
+// INV-E "no drift"). Re-running is always safe: `applyExternalFocusChain`
+// is idempotent (a target that already matches the current chain is a
+// no-op), and Svelte batches synchronous `animationKind` writes into one
+// effect run, so a transient null in the middle of a still-running
+// depthWindow resize (growDepthWindow/shrinkDepthWindow) never fires this
+// watcher — only a genuine settle to idle does.
+let pendingExternal: {
+  rootDoc: MapDocument;
+  target: readonly string[];
+} | null = null;
+
+$effect.root(() => {
+  $effect(() => {
+    if (animationKind !== null) return;
+    if (!pendingExternal) return;
+    const { rootDoc, target } = pendingExternal;
+    pendingExternal = null;
+    void applyExternalFocusChain(rootDoc, target);
+  });
+});
+
+export function currentLevelStack(): LevelFrame[] {
+  return levelStack;
+}
+
+export function currentFocusChain(): string[] {
+  return focusChain(levelStack);
+}
+
+export function currentDepthWindow(): 1 | 2 | 3 {
+  return depthWindow;
+}
+
+export function currentDepthWindowAnimIndex(): number | null {
+  return depthWindowAnimIndex;
+}
+
+// "the primary (first drillable) child" (CONFIRMED layer-explosion
+// behavior #1) — zones are tried in document order before mega nodes,
+// mirroring the same zone-then-mega priority IsoScene's own `hasDeeper`
+// check already uses.
+function primaryDrillableChild(doc: MapDocument): string | null {
+  for (const zone of doc.zones) {
+    if (isDrillable(doc, zone.id)) return zone.id;
+  }
+  for (const node of doc.nodes) {
+    if (node.is_mega && isDrillable(doc, node.id)) return node.id;
+  }
+  return null;
+}
+
+// Pushes ONE new level (levelStack + enter tween) — the shared push
+// primitive behind a single click-to-descend AND the multi-level
+// auto-explode loop below, so every pushed level animates identically
+// regardless of which caller triggered it.
+function pushLevelAnimated(
+  rootDoc: MapDocument,
+  focusId: string,
+): Promise<void> {
+  if (isRootZoneDescend(rootDoc, levelStack.length, focusId)) {
+    void maybeFetchLayer(focusId);
+  }
+  levelStack = pushLevel(levelStack, focusId, DUMMY_TRANSFORM);
+  animationKind = "enter";
+  enterProgress.set(0, { duration: 0 });
+  return enterProgress
+    .set(1, { duration: motionDuration(ENTER_MS) })
+    .then(() => {
+      animationKind = null;
+    });
+}
+
+// Shared collapse-then-mutate shape: the deepest plane visually shrinks to
+// 0 FIRST; the real pop/truncate happens inside `apply()`, called only
+// once the tween settles. Returns the settle promise (unlike the Stage-2
+// version) so the multi-level callers below can await one pop before
+// starting the next — CONFIRMED behavior #3's "reverse order, one level at
+// a time".
+function collapseThenApply(apply: () => void): Promise<void> {
+  animationKind = "exit";
+  exitProgress.set(1, { duration: 0 });
+  return exitProgress.set(0, { duration: motionDuration(EXIT_MS) }).then(() => {
+    apply();
+    exitProgress.set(1, { duration: 0 });
+    animationKind = null;
+  });
+}
+
+// Pops real chain levels one at a time — deepest first, each animated —
+// until the chain is exactly `targetChainLen` long. Shared by the
+// zone-click collapse-toggle (focusZone), climbTo, and ascend — the one
+// place that actually shrinks `levelStack`, as opposed to
+// shrinkDepthWindow below, which only narrows the WINDOW over an
+// unchanged chain.
+async function collapseChainTo(targetChainLen: number): Promise<void> {
+  while (focusChain(levelStack).length > targetChainLen) {
+    await collapseThenApply(() => {
+      levelStack = popLevel(levelStack);
+    });
+  }
+}
+
+// Auto-descends via the primary drillable child, one level at a time,
+// until the chain reaches `depthWindow - 1` entries (docsByDepth.length
+// === depthWindow) or no more drillable content exists — CONFIRMED
+// behavior #1's "down to the current depthWindow depth (or the full
+// available depth if shallower)".
+async function explodeToDepthWindow(rootDoc: MapDocument): Promise<void> {
+  while (focusChain(levelStack).length < depthWindow - 1) {
+    const docs = docsForRoot(rootDoc);
+    const deepest = docs[docs.length - 1];
+    const nextId = deepest ? primaryDrillableChild(deepest) : null;
+    if (!nextId) return;
+    await pushLevelAnimated(rootDoc, nextId);
+  }
+}
+
+// CLICK GATE (unified layer-explosion model, CONFIRMED behavior #1/#3) —
+// replaces the old single-level descend(). `targetId` is a box on ANY
+// currently expanded plane (every expanded plane is interactive now, see
+// IsoScene.svelte):
+//   - if it's already the occupant of its own chain slot (its children are
+//     currently shown) -> COLLAPSE: drop it and everything below it,
+//     reverse order, animated (#3, "clicking the SAME already-exploded
+//     zone again").
+//   - else, if it's drillable -> EXPLODE: first drop whatever subtree was
+//     shown below its slot, if any (a sibling swap — #1's "WHICH zone you
+//     click determines the subtree shown"), push it, then auto-continue
+//     via the primary child down to the current depthWindow depth (#1).
+//   - else (a non-drillable leaf, or an id not on any visible plane) ->
+//     no-op; the caller still calls setFocused for the select-only case
+//     (see IsoScene.svelte#handleBoxClick).
+export function focusZone(
+  rootDoc: MapDocument,
+  targetId: string,
+): "explode" | "collapse" | "none" {
+  if (animationKind !== null) return "none";
+  const docs = docsForRoot(rootDoc);
+  const chain = focusChain(levelStack);
+  const planes = computePlanesForDocs(docs, chain);
+  const planeIndex = planes.findIndex((p) =>
+    p.boxes.some((b) => b.id === targetId),
+  );
+  if (planeIndex === -1) return "none";
+
+  if (planeIndex < chain.length && chain[planeIndex] === targetId) {
+    void collapseChainTo(planeIndex);
+    return "collapse";
+  }
+
+  const targetDoc = docs[planeIndex];
+  if (!targetDoc || !isDrillable(targetDoc, targetId)) return "none";
+
+  void (async () => {
+    if (chain.length > planeIndex) {
+      await collapseChainTo(planeIndex);
+    }
+    await pushLevelAnimated(rootDoc, targetId);
+    // A descend must ALWAYS reveal the level you clicked into — grow the
+    // window so the new deepest level is expanded, not a hidden sliver
+    // (fixes: at depthWindow=2 a descend into a deeper plane didn't show
+    // until you also bumped the control to 3).
+    depthWindow = Math.min(
+      3,
+      Math.max(depthWindow, focusChain(levelStack).length + 1),
+    ) as 1 | 2 | 3;
+    await explodeToDepthWindow(rootDoc);
+  })();
+  return "explode";
+}
+
+// Grows/shrinks the root-anchored expanded window, walking ONE level at a
+// time — auto-descending via the primary drillable child (same mechanism
+// as focusZone) when growing past the currently-drilled chain, or simply
+// revealing an already-drilled-but-hidden level otherwise; shrinking
+// narrows the window only (the chain itself stays intact, re-revealable
+// later), one level at a time, deepest first. This is the literal fix for
+// CONFIRMED behavior #2: the control used to only re-window an
+// ALREADY-drilled chain, so from a fresh root it visibly did nothing.
+export function setDepthWindow(rootDoc: MapDocument, n: 1 | 2 | 3): void {
+  if (animationKind !== null || n === depthWindow) return;
+  if (n > depthWindow) {
+    void growDepthWindow(rootDoc, n);
+    return;
+  }
+  void shrinkDepthWindow(n);
+}
+
+async function revealExistingLevel(nextWindow: 1 | 2 | 3): Promise<void> {
+  depthWindow = nextWindow;
+  depthWindowAnimIndex = nextWindow - 1;
+  animationKind = "enter";
+  enterProgress.set(0, { duration: 0 });
+  await enterProgress.set(1, { duration: motionDuration(ENTER_MS) });
+  animationKind = null;
+  depthWindowAnimIndex = null;
+}
+
+async function growDepthWindow(
+  rootDoc: MapDocument,
+  target: 1 | 2 | 3,
+): Promise<void> {
+  while (depthWindow < target) {
+    const nextWindow = (depthWindow + 1) as 1 | 2 | 3;
+    const docs = docsForRoot(rootDoc);
+    if (nextWindow - 1 < docs.length) {
+      await revealExistingLevel(nextWindow);
+      continue;
+    }
+    const deepest = docs[docs.length - 1];
+    const nextId = deepest ? primaryDrillableChild(deepest) : null;
+    if (!nextId) return; // no more drillable content — "full available depth"
+    depthWindow = nextWindow;
+    await pushLevelAnimated(rootDoc, nextId);
+  }
+}
+
+async function shrinkDepthWindow(target: 1 | 2 | 3): Promise<void> {
+  while (depthWindow > target) {
+    depthWindowAnimIndex = depthWindow - 1;
+    animationKind = "exit";
+    exitProgress.set(1, { duration: 0 });
+    await exitProgress.set(0, { duration: motionDuration(EXIT_MS) });
+    depthWindow = (depthWindow - 1) as 1 | 2 | 3;
+    depthWindowAnimIndex = null;
+    animationKind = null;
+  }
+}
+
+export function currentAnimationKind(): "enter" | "exit" | null {
+  return animationKind;
+}
+
+export function currentEnterProgress(): number {
+  return enterProgress.current;
+}
+
+export function currentExitProgress(): number {
+  return exitProgress.current;
+}
+
+async function maybeFetchLayer(zoneId: string): Promise<void> {
+  if (layerCache.has(zoneId) || pendingLayerFetches.has(zoneId)) return;
+  pendingLayerFetches.add(zoneId);
+  let resolved: MapDocument | null = null;
+  try {
+    const res = await fetch(`/api/map/layers/${encodeURIComponent(zoneId)}`);
+    const body = (await res.json()) as { ok: boolean; data?: unknown };
+    if (body.ok && body.data && Object.keys(body.data as object).length > 0) {
+      const result = validateMapDocument(body.data);
+      if (result.ok) resolved = result.doc;
+    }
+  } catch {
+    resolved = null;
+  } finally {
+    pendingLayerFetches.delete(zoneId);
+  }
+  const next = new Map(layerCache);
+  next.set(zoneId, resolved);
+  layerCache = next;
+}
+
+// Generalized docsByDepth — folds deriveSubDocument (or a cached emitted
+// layer for the first descent) over the ENTIRE current focus chain,
+// however deep it has grown (Stage-2 generalization of Stage-1's hardcoded
+// two-level demo pair).
+export function docsForRoot(rootDoc: MapDocument): MapDocument[] {
+  return buildLevelDocuments(rootDoc, focusChain(levelStack), layerCache);
+}
+
+// Resolves a breadcrumb frame's focusId to its human label, at the
+// altitude where it was a valid drill target — for LevelBreadcrumb's
+// `labelFor` prop (reused as-is, RFC-031 Phase 4).
+export function labelForFocus(
+  rootDoc: MapDocument,
+  focusId: string | null,
+): string {
+  if (focusId === null) return "All";
+  const docs = docsForRoot(rootDoc);
+  const planes = computePlanesForDocs(docs, focusChain(levelStack));
+  return planes.find((p) => p.focusId === focusId)?.label ?? focusId;
+}
+
+// FR-003 equivalent — ascend one level (the current deepest level
+// collapses away, revealing its parent as the new deepest). Reuses
+// collapseChainTo (single-iteration case) so ascend/climbTo/focusZone's
+// collapse-toggle all share one animated-pop implementation.
+export function ascend(): void {
+  if (animationKind !== null || levelStack.length <= 1) return;
+  void collapseChainTo(focusChain(levelStack).length - 1);
+}
+
+// Breadcrumb crumb click — climb directly to an ancestor level. Reuses the
+// same reverse-order, one-level-at-a-time collapse as focusZone's
+// collapse-toggle and depthWindow's shrink path, so a jump spanning
+// multiple levels (e.g. depth 4 -> depth 1) now animates each
+// intermediate level's collapse in turn instead of vanishing instantly
+// (resolves the former iso-multi-collapse TODO).
+export function climbTo(index: number): void {
+  if (animationKind !== null || index < 0 || index >= levelStack.length - 1) {
+    return;
+  }
+  void collapseChainTo(index);
+}
+
+// Reconciliation entry point for the shared drill-chain bus (2D <-> 3D
+// corner, see widgets/composed-map/model/shared-drill-bus.svelte.ts).
+// Applies an EXTERNALLY specified chain (e.g. a descend that happened in
+// the 2D map) verbatim, one exact id at a time — unlike focusZone (the
+// click gate above), this NEVER substitutes a "primary drillable child":
+// every id in `target` must land exactly, so the two views always end up
+// drilled into the SAME zone, not merely the same depth. Also grows
+// depthWindow to keep every newly-revealed level expanded (mirrors
+// focusZone's own window-growing rule — "always show expanded"); never
+// shrinks it on ascend, since windowPlanes already caps the window at
+// however many docs actually exist, so a wide window over a short chain
+// is harmless (it just means "show everything that's there"). NOT
+// best-effort: when `animationKind !== null` (either here or mid-loop
+// below) the drop is recorded in `pendingExternal` and the module-level
+// watcher above retries it the moment the in-flight animation settles, so
+// this always converges even if the caller's own effect never fires again
+// for this exact target (EVID-100 Finding #1).
+export async function applyExternalFocusChain(
+  rootDoc: MapDocument,
+  target: readonly string[],
+): Promise<void> {
+  if (animationKind !== null) {
+    pendingExternal = { rootDoc, target };
+    return;
+  }
+  pendingExternal = null;
+  const local = focusChain(levelStack);
+  let common = 0;
+  while (
+    common < local.length &&
+    common < target.length &&
+    local[common] === target[common]
+  ) {
+    common++;
+  }
+  if (common < local.length) {
+    await collapseChainTo(common);
+  }
+  for (let i = common; i < target.length; i++) {
+    if (animationKind !== null) {
+      pendingExternal = { rootDoc, target };
+      return;
+    }
+    await pushLevelAnimated(rootDoc, target[i]!);
+    depthWindow = Math.min(
+      3,
+      Math.max(depthWindow, focusChain(levelStack).length + 1),
+    ) as 1 | 2 | 3;
+  }
+}
+
+// ---- Stage 3 (redesigned): hover-dwell (zones, nodes, AND planes/sheets)
+// Unified dwell mechanism for every hover target this stage introduces —
+// gated by the EXACT SAME timing rule (ZONE_DWELL_MS parity with
+// ComposedMapView, restart-on-move), so one small state machine covers all
+// of them instead of several near-duplicate ones (SRP: this IS "hover
+// state", all of it, in one place, per this stage's own mandate).
+// MINIMAP reframe: `kind: 'zone'` was added so a hovered zone highlights
+// itself (IsoZoneFrame.svelte), matching the existing per-node highlight —
+// the retired whole-plane emphasis used to be the only feedback a zone
+// hover produced. `kind: 'plane'` is kept (not removed) purely to back the
+// optional info-card path (+page.svelte, gated behind `showInfoCards`).
+export type IsoDwellTarget =
+  | { kind: "node"; id: string }
+  | { kind: "zone"; id: string }
+  | { kind: "plane"; planeId: string; depthIndex: number };
+
+function sameDwellTarget(a: IsoDwellTarget, b: IsoDwellTarget): boolean {
+  if (a.kind === "plane" || b.kind === "plane") {
+    return a.kind === "plane" && b.kind === "plane" && a.planeId === b.planeId;
+  }
+  return a.kind === b.kind && a.id === b.id;
+}
+
+const DWELL_MS = 350;
+
+// The raw target currently under the pointer (or keyboard focus) — armed
+// on enter, cleared on leave. `dwellCard` only advances to it once it has
+// survived DWELL_MS untouched (see armDwell) — mirrors ComposedMapView's
+// hoveredZoneId/detailZoneId split exactly (parity requested by this
+// stage), just generalized to two target KINDS instead of one.
+let pointerDwellTarget = $state<IsoDwellTarget | null>(null);
+let dwellCard = $state<IsoDwellTarget | null>(null);
+let dwellTimer: ReturnType<typeof setTimeout> | null = null;
+
+function clearDwellTimer(): void {
+  if (dwellTimer !== null) {
+    clearTimeout(dwellTimer);
+    dwellTimer = null;
+  }
+}
+
+export function currentDwellTarget(): IsoDwellTarget | null {
+  return dwellCard;
+}
+
+// Pointer ENTERED (or keyboard focus landed on) a target — (re)arms the
+// dwell timer. A target switch before DWELL_MS elapses restarts the clock
+// from zero: every call clears the previous timer before starting a new
+// one, so only a genuine DWELL_MS rest on ONE target ever fires it.
+export function armDwell(target: IsoDwellTarget): void {
+  pointerDwellTarget = target;
+  clearDwellTimer();
+  const captured = target;
+  dwellTimer = setTimeout(() => {
+    dwellTimer = null;
+    if (pointerDwellTarget && sameDwellTarget(pointerDwellTarget, captured)) {
+      dwellCard = captured;
+    }
+  }, DWELL_MS);
+}
+
+// Pointer LEFT (or keyboard focus left) a target — cancels a still-
+// pending arm and, if THIS target's card is the one currently shown,
+// closes it. The sameDwellTarget guard stops a stale leave (fired after
+// the pointer already moved on to a new target) from clearing that NEW
+// target's card out from under it.
+export function disarmDwell(target: IsoDwellTarget): void {
+  if (pointerDwellTarget && sameDwellTarget(pointerDwellTarget, target)) {
+    pointerDwellTarget = null;
+    clearDwellTimer();
+  }
+  if (dwellCard && sameDwellTarget(dwellCard, target)) {
+    dwellCard = null;
+  }
+}
+
+// IsoA11yProxy's keyboard path — a Tab landing on a specific hidden proxy
+// button has already committed to that exact target (no "just passing
+// through" ambiguity a mouse has), so it opens immediately, no DWELL_MS.
+export function focusDwell(target: IsoDwellTarget): void {
+  clearDwellTimer();
+  pointerDwellTarget = target;
+  dwellCard = target;
+}
+
+export function blurDwell(target: IsoDwellTarget): void {
+  disarmDwell(target);
+}
+
+export interface DwellNodeCardData {
+  kind: "node";
+  node: MapNode;
+  connections: NodeConnection[];
+  worldPos: [number, number, number];
+}
+
+export interface DwellLayerCardData {
+  kind: "plane";
+  label: string;
+  zoneCount: number;
+  nodeCount: number;
+  descriptionRu?: string;
+  worldPos: [number, number, number];
+}
+
+function currentWindowedPlanes(rootDoc: MapDocument) {
+  const docs = docsForRoot(rootDoc);
+  const planes = computePlanesForDocs(docs, focusChain(levelStack));
+  return { docs, planes: windowPlanes(planes, depthWindow) };
+}
+
+// Resolves the CURRENTLY dwelt target (if any) into the exact data its
+// card needs — the single source both IsoNodeCard's and IsoLayerCard's
+// caller (+page.svelte) reads from, so neither card component ever
+// derives its own content (DIP: they stay dumb prop renderers).
+export function resolveDwellCardData(
+  rootDoc: MapDocument,
+): DwellNodeCardData | DwellLayerCardData | null {
+  const target = dwellCard;
+  if (!target) return null;
+  const { docs, planes } = currentWindowedPlanes(rootDoc);
+
+  if (target.kind === "plane") {
+    const plane = planes.find(
+      (p) => p.mode === "expanded" && p.id === target.planeId,
+    );
+    if (!plane) return null;
+    const doc = docs[plane.depthIndex];
+    if (!doc) return null;
+    const parentDoc = plane.depthIndex > 0 ? docs[plane.depthIndex - 1] : null;
+    const descriptionRu = parentDoc?.zones.find(
+      (z) => z.id === plane.focusId,
+    )?.description_ru;
+    return {
+      kind: "plane",
+      label: plane.label,
+      zoneCount: doc.zones.length,
+      nodeCount: doc.nodes.length,
+      descriptionRu,
+      worldPos: [plane.originX, plane.y, plane.originZ],
+    };
+  }
+
+  // A hovered ZONE highlights itself (IsoZoneFrame.svelte) but has no info
+  // card of its own (only node/plane do) — no data to resolve here.
+  if (target.kind === "zone") return null;
+
+  for (const plane of planes) {
+    if (plane.mode !== "expanded") continue;
+    const box = plane.boxes.find(
+      (b) => b.kind === "node" && b.id === target.id,
+    );
+    if (!box) continue;
+    const doc = docs[plane.depthIndex];
+    const node = doc?.nodes.find((n) => n.id === target.id);
+    if (!doc || !node) return null;
+    return {
+      kind: "node",
+      node,
+      connections: buildNodeConnections(doc, target.id),
+      worldPos: [
+        plane.originX + box.x,
+        plane.y + NODE_BOX_H / 2,
+        plane.originZ + box.z,
+      ],
+    };
+  }
+  return null;
+}
+
+export interface DwellTargetSummary {
+  target: IsoDwellTarget;
+  label: string;
+}
+
+// IsoA11yProxy's data source — every CURRENTLY rendered dwellable target
+// (one entry per visible expanded plane + one per zone/node box on it), so
+// the visually-hidden proxy button list always matches what a mouse could
+// actually reach right now (never stale, never includes a collapsed
+// sliver's contents).
+export function currentDwellableTargets(
+  rootDoc: MapDocument,
+): DwellTargetSummary[] {
+  const { planes } = currentWindowedPlanes(rootDoc);
+  const list: DwellTargetSummary[] = [];
+  for (const plane of planes) {
+    if (plane.mode !== "expanded") continue;
+    list.push({
+      target: {
+        kind: "plane",
+        planeId: plane.id,
+        depthIndex: plane.depthIndex,
+      },
+      label: `Layer: ${plane.label}`,
+    });
+    for (const box of plane.boxes) {
+      const kind = box.kind === "node" ? "node" : "zone";
+      list.push({ target: { kind, id: box.id }, label: box.label });
+    }
+  }
+  return list;
+}
diff --git a/template/src/widgets/iso-map/ui/IsoA11yProxy.svelte b/template/src/widgets/iso-map/ui/IsoA11yProxy.svelte
new file mode 100644
index 0000000..05d0431
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoA11yProxy.svelte
@@ -0,0 +1,76 @@
+<script lang="ts">
+  // Stage 3 — a11y proxy. WebGL meshes are never focusable/tabbable, so a
+  // keyboard user has no way to reach the hover-only IsoNodeCard /
+  // IsoLayerCard affordance. This renders one visually-hidden, focusable
+  // <button> per CURRENTLY visible dwellable target (one per rendered
+  // expanded plane + one per node box on it —
+  // model/iso-view-state.svelte.ts#currentDwellableTargets, recomputed
+  // whenever the drill/window state changes, so the list never goes stale
+  // or offers a target from a collapsed sliver). Focusing one opens the
+  // SAME card the pointer-hover path opens (model#focusDwell — no
+  // artificial dwell delay: a keyboard user tabbing to a specific button
+  // has already committed to that exact target, unlike a mouse "just
+  // passing through"); blurring closes it (model#blurDwell).
+  //
+  // ISP/DIP: this component receives the target list + callbacks as
+  // narrow, typed props — it never imports the model itself (only
+  // composition roots, +page.svelte and IsoScene, do that).
+  import type { IsoDwellTarget, DwellTargetSummary } from '../model/iso-view-state.svelte';
+
+  let {
+    targets,
+    onFocusTarget,
+    onBlurTarget,
+  }: {
+    targets: readonly DwellTargetSummary[];
+    onFocusTarget: (target: IsoDwellTarget) => void;
+    onBlurTarget: (target: IsoDwellTarget) => void;
+  } = $props();
+
+  function keyFor(entry: DwellTargetSummary): string {
+    const t = entry.target;
+    return t.kind === 'plane' ? `plane:${t.planeId}` : `${t.kind}:${t.id}`;
+  }
+</script>
+
+<div class="iso-a11y-proxy">
+  {#each targets as entry, i (keyFor(entry) + '#' + i)}
+    <button
+      type="button"
+      class="iso-a11y-btn"
+      onfocus={() => onFocusTarget(entry.target)}
+      onblur={() => onBlurTarget(entry.target)}
+    >
+      {entry.label}
+    </button>
+  {/each}
+</div>
+
+<style>
+  .iso-a11y-proxy {
+    position: absolute;
+    inset: 0;
+    /* Buttons inside are individually focusable; the wrapper itself must
+       never intercept a pointer (it sits on top of the whole viewport). */
+    pointer-events: none;
+  }
+
+  .iso-a11y-btn {
+    /* Standard visually-hidden pattern: NOT display:none / visibility:
+       hidden (both remove an element from the accessibility tree and
+       from the tab order) — clipped to 1x1px instead, so screen readers
+       and keyboard focus still reach it. */
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border: 0;
+    pointer-events: auto;
+  }
+</style>
diff --git a/template/src/widgets/iso-map/ui/IsoControls.svelte b/template/src/widgets/iso-map/ui/IsoControls.svelte
new file mode 100644
index 0000000..9935374
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoControls.svelte
@@ -0,0 +1,63 @@
+<script lang="ts">
+  // Bottom-right control cluster: the depthWindow accordion (1/2/3) +
+  // ascend. All state lives in model/iso-view-state.svelte.ts (SRP) — this
+  // component only renders shared/ui <Button> instances and forwards
+  // clicks up (ISP: it knows nothing about levelStack/planes/animation).
+  // Rule 24: composes the shared/ui primitive only, no re-skinning — the
+  // only CSS here is the wrapper's own position/layout.
+  import { Button } from '@/shared/ui';
+
+  const DEPTH_OPTIONS = [1, 2, 3] as const;
+
+  let {
+    depthWindow,
+    onDepthWindowChange,
+    canAscend,
+    onAscend,
+  }: {
+    depthWindow: 1 | 2 | 3;
+    onDepthWindowChange: (n: 1 | 2 | 3) => void;
+    canAscend: boolean;
+    onAscend: () => void;
+  } = $props();
+</script>
+
+<div class="iso-controls">
+  <div class="depth-group" role="group" aria-label="Visible depth layers">
+    {#each DEPTH_OPTIONS as n (n)}
+      <Button
+        variant={depthWindow === n ? 'primary' : 'ghost'}
+        size="sm"
+        aria-pressed={depthWindow === n}
+        onclick={() => onDepthWindowChange(n)}
+      >
+        {n}
+      </Button>
+    {/each}
+  </div>
+  <Button variant="secondary" size="sm" disabled={!canAscend} onclick={onAscend}>
+    ascend ⬆
+  </Button>
+</div>
+
+<style>
+  .iso-controls {
+    position: absolute;
+    right: 16px;
+    bottom: 16px;
+    z-index: 3;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px;
+    background: var(--bg-1);
+    border: 1px solid var(--line, var(--fg-4));
+    border-radius: 8px;
+  }
+
+  .depth-group {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+  }
+</style>
diff --git a/template/src/widgets/iso-map/ui/IsoDeeperMarker.svelte b/template/src/widgets/iso-map/ui/IsoDeeperMarker.svelte
new file mode 100644
index 0000000..5be0f6a
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoDeeperMarker.svelte
@@ -0,0 +1,52 @@
+<script lang="ts">
+  // Subtle "...deeper" affordance: 4 dashed lines converging from the
+  // deepest EXPANDED plane's plate corners down to a point below it —
+  // a collapsing-pyramid stub hinting that this level has further
+  // drillable content not yet rendered (depthWindow only shows what's been
+  // descended into, not a preview of what's below). Mounted independently
+  // in IsoScene (OCP) whenever the deepest doc has any drillable zone/mega;
+  // reuses the same dashed MeshLine convention as IsoFrustum/IsoIcomArrows
+  // (dashed = inferred/not-yet-real, same visual language).
+  import { T } from '@threlte/core';
+  import { MeshLineGeometry, MeshLineMaterial } from '@threlte/extras';
+  import * as THREE from 'three';
+  import { CONNECTOR_DASH_ARRAY, CONNECTOR_DASH_RATIO } from '../lib/iso-materials';
+
+  const DROP = 2.2;
+  const LINE_WIDTH = 0.6;
+  const OPACITY = 0.5;
+
+  let {
+    x,
+    y,
+    z,
+    w,
+    d,
+    color,
+  }: { x: number; y: number; z: number; w: number; d: number; color: THREE.Color } = $props();
+
+  const apex = $derived(new THREE.Vector3(x, y - DROP, z));
+  const corners = $derived(
+    [
+      [x - w / 2, y, z - d / 2],
+      [x + w / 2, y, z - d / 2],
+      [x + w / 2, y, z + d / 2],
+      [x - w / 2, y, z + d / 2],
+    ] as const,
+  );
+</script>
+
+{#each corners as corner, i (i)}
+  <T.Mesh>
+    <MeshLineGeometry points={[new THREE.Vector3(...corner), apex]} />
+    <MeshLineMaterial
+      {color}
+      width={LINE_WIDTH}
+      attenuate={false}
+      transparent
+      opacity={OPACITY}
+      dashArray={CONNECTOR_DASH_ARRAY}
+      dashRatio={CONNECTOR_DASH_RATIO}
+    />
+  </T.Mesh>
+{/each}
diff --git a/template/src/widgets/iso-map/ui/IsoFrustum.svelte b/template/src/widgets/iso-map/ui/IsoFrustum.svelte
new file mode 100644
index 0000000..bcb8b13
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoFrustum.svelte
@@ -0,0 +1,43 @@
+<script lang="ts">
+  // The dashed corner-to-corner connector for ONE parent-box -> child-plane
+  // (a truncated-pyramid / frustum wireframe). Fine-dash tuning (thinner,
+  // higher dash frequency, shorter segments) lives in lib/iso-materials.ts.
+  //
+  // Stage 2: `presence` (0..1) fades this connector in step with the CHILD
+  // plane's own enter/exit animation (IsoScene passes the child plane's
+  // presence value here when this group's childDepthIndex is the current
+  // deepest — 1 for every already-settled connector).
+  import { T } from '@threlte/core';
+  import { MeshLineGeometry, MeshLineMaterial } from '@threlte/extras';
+  import type * as THREE from 'three';
+  import type { PyramidGroup } from '../lib/iso-projection';
+  import {
+    CONNECTOR_LINE_WIDTH,
+    CONNECTOR_LINE_OPACITY,
+    CONNECTOR_DASH_ARRAY,
+    CONNECTOR_DASH_RATIO,
+    LINE_RENDER_ORDER,
+  } from '../lib/iso-materials';
+
+  let {
+    group,
+    color,
+    presence = 1,
+  }: { group: PyramidGroup; color: THREE.Color; presence?: number } = $props();
+</script>
+
+{#each group.segments as seg (seg.id)}
+  <T.Mesh renderOrder={LINE_RENDER_ORDER}>
+    <MeshLineGeometry points={seg.points} />
+    <MeshLineMaterial
+      {color}
+      width={CONNECTOR_LINE_WIDTH}
+      attenuate={false}
+      transparent
+      depthTest={false}
+      opacity={CONNECTOR_LINE_OPACITY * presence}
+      dashArray={CONNECTOR_DASH_ARRAY}
+      dashRatio={CONNECTOR_DASH_RATIO}
+    />
+  </T.Mesh>
+{/each}
diff --git a/template/src/widgets/iso-map/ui/IsoIcomArrows.svelte b/template/src/widgets/iso-map/ui/IsoIcomArrows.svelte
new file mode 100644
index 0000000..5b74b39
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoIcomArrows.svelte
@@ -0,0 +1,61 @@
+<script lang="ts">
+  // ICOM boundary arrows (FIPS Fig.6 §3.3.2.7-8 Figs.14-15) for all
+  // parent-zone -> child-plane pairs. Split out of the frustum connector
+  // (IsoFrustum.svelte) for SRP — a future toggle/filter on ICOM arrows can
+  // be added here without touching the frustum lines (OCP).
+  //
+  // Stage 2: `presence` (0..1), same purpose as IsoFrustum's — IsoScene
+  // mounts this component TWICE (once for already-settled pairs at
+  // presence=1, once for the currently-animating deepest transition's
+  // pairs) rather than adding per-pair presence plumbing here.
+  import { T } from '@threlte/core';
+  import { MeshLineGeometry, MeshLineMaterial } from '@threlte/extras';
+  import type * as THREE from 'three';
+  import type { IcomArrowGeom, IcomArrowPair } from '../lib/iso-projection';
+  import {
+    ICOM_ARROW_WIDTH,
+    ICOM_ARROW_OPACITY,
+    ICOM_ARROW_DASH_ARRAY,
+    ICOM_ARROW_DASH_RATIO,
+    LINE_RENDER_ORDER,
+  } from '../lib/iso-materials';
+
+  let {
+    pairs,
+    color,
+    presence = 1,
+  }: { pairs: IcomArrowPair[]; color: THREE.Color; presence?: number } = $props();
+
+  function dashArrayFor(geom: IcomArrowGeom): number {
+    return geom.provenance === 'derived' ? ICOM_ARROW_DASH_ARRAY : 0;
+  }
+</script>
+
+{#each pairs as pair (pair.id)}
+  <T.Mesh renderOrder={LINE_RENDER_ORDER}>
+    <MeshLineGeometry points={pair.parent.points} shape="custom" shapeFunction={(p) => 1 - p} />
+    <MeshLineMaterial
+      {color}
+      width={ICOM_ARROW_WIDTH}
+      attenuate={false}
+      transparent
+      depthTest={false}
+      opacity={ICOM_ARROW_OPACITY * presence}
+      dashArray={dashArrayFor(pair.parent)}
+      dashRatio={ICOM_ARROW_DASH_RATIO}
+    />
+  </T.Mesh>
+  <T.Mesh renderOrder={LINE_RENDER_ORDER}>
+    <MeshLineGeometry points={pair.child.points} shape="custom" shapeFunction={(p) => 1 - p} />
+    <MeshLineMaterial
+      {color}
+      width={ICOM_ARROW_WIDTH}
+      attenuate={false}
+      transparent
+      depthTest={false}
+      opacity={ICOM_ARROW_OPACITY * presence}
+      dashArray={dashArrayFor(pair.child)}
+      dashRatio={ICOM_ARROW_DASH_RATIO}
+    />
+  </T.Mesh>
+{/each}
diff --git a/template/src/widgets/iso-map/ui/IsoLayerCard.svelte b/template/src/widgets/iso-map/ui/IsoLayerCard.svelte
new file mode 100644
index 0000000..eb9466b
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoLayerCard.svelte
@@ -0,0 +1,97 @@
+<script lang="ts">
+  // Stage 3 — sibling of IsoNodeCard.svelte (SAME token-styled card
+  // chrome, same reasoning: rule 24, no shared/ui primitive re-skin), for
+  // a hovered/dwelt LEVEL/plane ("sheet") instead of a node box. Content
+  // is exactly what model/iso-view-state.svelte.ts#resolveDwellCardData
+  // already resolved: the level's label, its zone/node counts, and (when
+  // this level IS the decomposition of a parent zone) that zone's own
+  // description_ru — this component derives NONE of it itself (DIP).
+  //
+  // Same non-sticky, no-close-button, pointer-events:none shape as
+  // IsoNodeCard — see that file's header comment for why.
+  let {
+    label,
+    zoneCount,
+    nodeCount,
+    descriptionRu,
+    cardEl = $bindable(null),
+  }: {
+    label: string;
+    zoneCount: number;
+    nodeCount: number;
+    descriptionRu?: string;
+    cardEl?: HTMLElement | null;
+  } = $props();
+
+  $effect(() => {
+    return () => {
+      cardEl = null;
+    };
+  });
+</script>
+
+<div class="iso-card" role="note" aria-label="Layer detail" bind:this={cardEl}>
+  <h3 class="iso-card-title">{label}</h3>
+  <div class="iso-card-kind">layer</div>
+  {#if descriptionRu}
+    <p class="iso-card-desc">{descriptionRu}</p>
+  {/if}
+  <div class="iso-card-stats">
+    <span>{zoneCount} {zoneCount === 1 ? 'zone' : 'zones'}</span>
+    <span class="iso-card-stats-sep">·</span>
+    <span>{nodeCount} {nodeCount === 1 ? 'node' : 'nodes'}</span>
+  </div>
+</div>
+
+<style>
+  .iso-card {
+    position: absolute;
+    bottom: 16px;
+    left: 16px;
+    max-width: 300px;
+    max-height: calc(100vh - 84px);
+    overflow-y: auto;
+    background: var(--bg-1);
+    border: 1px solid var(--line-2);
+    border-radius: 12px;
+    padding: 14px 16px;
+    box-shadow: var(--shadow-mini);
+    z-index: 4;
+    pointer-events: none;
+  }
+
+  .iso-card-title {
+    margin: 0 0 2px;
+    font-family: var(--font-sans);
+    font-weight: 500;
+    font-size: 15px;
+    color: var(--fg);
+  }
+
+  .iso-card-kind {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    letter-spacing: 0.04em;
+    text-transform: uppercase;
+    color: var(--fg-3);
+    margin-bottom: 8px;
+  }
+
+  .iso-card-desc {
+    font-size: 12px;
+    line-height: 1.5;
+    color: var(--fg-2);
+    margin: 0 0 8px;
+  }
+
+  .iso-card-stats {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    color: var(--fg-2);
+  }
+
+  .iso-card-stats-sep {
+    color: var(--fg-3);
+    margin: 0 6px;
+  }
+</style>
diff --git a/template/src/widgets/iso-map/ui/IsoLeaderLine.svelte b/template/src/widgets/iso-map/ui/IsoLeaderLine.svelte
new file mode 100644
index 0000000..456fb5a
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoLeaderLine.svelte
@@ -0,0 +1,129 @@
+<script lang="ts">
+  // Stage 3 — the leader line connecting the current hover-dwell target's
+  // 3D world position (a node box or a plane's plate center — see
+  // model/iso-view-state.svelte.ts#resolveDwellCardData) to the edge of
+  // whichever 2D card is showing it (IsoNodeCard / IsoLayerCard, rendered
+  // by +page.svelte, the SAME composition root that owns `cardEl`).
+  //
+  // Mounted as a SIBLING of <IsoScene> inside <Canvas> (composition root:
+  // +page.svelte) — it needs Threlte context (useOrbitControls, <HTML>'s
+  // camera projection) that only exists inside <Canvas>, but it is
+  // otherwise fully decoupled from IsoScene itself (DIP/OCP: a pure
+  // decoration, addable/removable without touching IsoScene's own tree).
+  //
+  // Two portalled pieces, both via @threlte/extras <HTML> — the ONLY
+  // sanctioned way to get real, painted DOM out of <Canvas> (its ordinary
+  // children render inside the actual <canvas> tag, which the browser
+  // never paints):
+  //   1. An invisible 1x1 anchor div — `center` + `transform={false}` so
+  //      Threlte keeps it translated to the live screen projection of
+  //      `anchorWorldPos` every render frame, automatically.
+  //   2. A plain SVG <line>, nested INSIDE THE SAME centered/transformed
+  //      wrapper as (1). Both are ordinary `position:absolute; top:0;
+  //      left:0` children of that one already-translated parent, so they
+  //      share the exact same local (0,0) origin — the line's start point
+  //      is always local (0,0), no further transform math needed. Only
+  //      the END point (the card's nearest edge, in real viewport pixels)
+  //      needs converting into that same local frame, via ONE
+  //      getBoundingClientRect() read of the anchor div itself.
+  //      `overflow: visible` on the <svg> is required — its UA default
+  //      clips at its own nominal 0x0 box otherwise.
+  // Recomputed on OrbitControls 'change' (rAF-throttled — a damped
+  // multi-frame orbit gesture reads the DOM at most once per paint) AND
+  // whenever the dwell target / card itself changes.
+  import { HTML, useOrbitControls } from '@threlte/extras';
+  import { nearestRectEdgePoint } from '../lib/leader-line';
+
+  let {
+    anchorWorldPos,
+    cardEl,
+  }: {
+    anchorWorldPos: [number, number, number] | null;
+    cardEl: HTMLElement | null;
+  } = $props();
+
+  let anchorEl = $state<HTMLDivElement | undefined>();
+  let line = $state<{ x2: number; y2: number } | null>(null);
+
+  function recompute(): void {
+    if (!anchorEl || !cardEl) {
+      line = null;
+      return;
+    }
+    const anchorRect = anchorEl.getBoundingClientRect();
+    const originX = anchorRect.left + anchorRect.width / 2;
+    const originY = anchorRect.top + anchorRect.height / 2;
+    const edge = nearestRectEdgePoint(cardEl.getBoundingClientRect(), originX, originY);
+    line = { x2: edge.x - originX, y2: edge.y - originY };
+  }
+
+  let rafId: number | null = null;
+  function scheduleRecompute(): void {
+    if (rafId !== null) return;
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      recompute();
+    });
+  }
+
+  // Target (or its card) changed — recompute right away rather than
+  // waiting for the next orbit 'change' event, so the line appears the
+  // moment a new card does.
+  $effect(() => {
+    void anchorWorldPos;
+    void cardEl;
+    scheduleRecompute();
+  });
+
+  const orbitControls = useOrbitControls();
+
+  $effect(() => {
+    const controls = orbitControls.current;
+    if (!controls) return;
+    controls.addEventListener('change', scheduleRecompute);
+    return () => controls.removeEventListener('change', scheduleRecompute);
+  });
+
+  $effect(() => {
+    return () => {
+      if (rafId !== null) cancelAnimationFrame(rafId);
+    };
+  });
+</script>
+
+{#if anchorWorldPos}
+  <HTML transform={false} center portal={document.body} pointerEvents="none" position={anchorWorldPos}>
+    <div bind:this={anchorEl} class="iso-leader-anchor"></div>
+    {#if line}
+      <svg class="iso-leader-svg" aria-hidden="true" focusable="false">
+        <line x1={0} y1={0} x2={line.x2} y2={line.y2} />
+      </svg>
+    {/if}
+  </HTML>
+{/if}
+
+<style>
+  .iso-leader-anchor {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 1px;
+    height: 1px;
+  }
+
+  .iso-leader-svg {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 1px;
+    height: 1px;
+    overflow: visible;
+    pointer-events: none;
+  }
+
+  .iso-leader-svg line {
+    stroke: var(--accent, #ff5a1f);
+    stroke-width: 1.5;
+    stroke-dasharray: 4 3;
+  }
+</style>
diff --git a/template/src/widgets/iso-map/ui/IsoMinimap.svelte b/template/src/widgets/iso-map/ui/IsoMinimap.svelte
new file mode 100644
index 0000000..5b6c0d1
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoMinimap.svelte
@@ -0,0 +1,219 @@
+<script lang="ts">
+  // Self-contained 3D minimap box — absorbs the working Canvas/overlay
+  // wiring that used to live directly in routes/iso-spike/+page.svelte
+  // (that route is now a thin `<IsoMinimap fullscreen />` host). Reuses the
+  // SAME widget-owned mapPoller (RFC-030 SD-1) ComposedMapView uses — no
+  // second poller.
+  //
+  // Two layouts, one component (OCP): `fullscreen` (the /iso-spike dev
+  // route) gets the old fixed/inset:0 page chrome + breadcrumb; the default
+  // corner mode sizes to 100%/100% of whatever box the caller gives it
+  // (DependencyGraph's IsoMapCorner) and drops the breadcrumb — cramped at
+  // ~320x240 alongside the bottom-right IsoControls cluster. IsoControls/
+  // IsoA11yProxy are already `position: absolute` against their nearest
+  // positioned ancestor, so mounting them here anchors correctly to THIS
+  // box without any change to those components (this file is the
+  // positioned ancestor in both modes).
+  //
+  // showInfoCards is intentionally NOT a prop here (unlike the old
+  // +page.svelte): this component is always the compact minimap shape —
+  // IsoLeaderLine/IsoNodeCard/IsoLayerCard stay unmounted. The per-element
+  // hover highlight in IsoZoneFrame/IsoNodeBox is the primary feedback;
+  // IsoA11yProxy still mounts unconditionally for keyboard reachability.
+  import { untrack } from "svelte";
+  import { Canvas } from "@threlte/core";
+  import IsoScene from "../IsoScene.svelte";
+  import IsoControls from "./IsoControls.svelte";
+  import IsoA11yProxy from "./IsoA11yProxy.svelte";
+  import LevelBreadcrumb from "@/widgets/composed-map/ui/LevelBreadcrumb.svelte";
+  import { Button } from "@/shared/ui";
+  import {
+    acquireMapPolling,
+    isEmptyMapResponse,
+    mapPoller,
+    validateMapDocument,
+    type MapDocument,
+  } from "@/entities/map";
+  import {
+    sharedFocusChain,
+    focusTo,
+    chainsEqual,
+  } from "@/widgets/composed-map/model/shared-drill-bus.svelte";
+  import {
+    currentLevelStack,
+    currentDepthWindow,
+    currentFocusChain,
+    setDepthWindow,
+    climbTo,
+    ascend,
+    labelForFocus,
+    currentDwellableTargets,
+    focusDwell,
+    blurDwell,
+    applyExternalFocusChain,
+  } from "../model/iso-view-state.svelte";
+
+  let { fullscreen = false }: { fullscreen?: boolean } = $props();
+
+  const levelStack = $derived(currentLevelStack());
+  const depthWindow = $derived(currentDepthWindow());
+  const focusChainNow = $derived(currentFocusChain());
+
+  // Control-panel toggle (requirement: hideable/showable depth+ascend
+  // cluster) — a small always-visible corner button; default visible.
+  let controlsVisible = $state(true);
+
+  $effect(() => {
+    const release = acquireMapPolling();
+    return () => release();
+  });
+
+  type Branch =
+    | { kind: "loading" }
+    | { kind: "empty" }
+    | { kind: "error"; message: string }
+    | { kind: "ok"; doc: MapDocument };
+
+  const rootBranch = $derived.by((): Branch => {
+    const { data: raw, error, lastFetched } = mapPoller.state;
+    if (raw === null && lastFetched === null) return { kind: "loading" };
+    if (error) return { kind: "error", message: error };
+    if (isEmptyMapResponse(raw)) return { kind: "empty" };
+    const result = validateMapDocument(raw);
+    if (!result.ok) {
+      return {
+        kind: "error",
+        message: result.errors[0]?.message ?? "invalid map",
+      };
+    }
+    return { kind: "ok", doc: result.doc };
+  });
+
+  const dwellableTargets = $derived.by(() =>
+    rootBranch.kind === "ok" ? currentDwellableTargets(rootBranch.doc) : [],
+  );
+
+  function labelFor(focusId: string | null): string {
+    return rootBranch.kind === "ok"
+      ? labelForFocus(rootBranch.doc, focusId)
+      : (focusId ?? "All");
+  }
+
+  // Shared drill-chain bus (2D <-> 3D corner) — OUTBOUND: mirror this
+  // scene's own focus chain out whenever it changes, regardless of cause
+  // (box click in IsoScene, ascend/climbTo below). focusTo no-ops on
+  // unchanged content, so this can never fight the INBOUND effect below
+  // into a loop.
+  $effect(() => {
+    focusTo(focusChainNow);
+  });
+
+  // INBOUND — replay an externally-driven chain (e.g. a descend in the 2D
+  // map) onto this scene via applyExternalFocusChain, which drills the
+  // EXACT ids given (never substituting a "primary child" the way a click
+  // would). Skips its own very first run so opening the corner never
+  // auto-explodes to a chain a previous session left behind. `untrack`
+  // keeps this effect's ONLY dependency the shared chain itself — reading
+  // rootBranch/local state inside the callback must not leak as
+  // dependencies, or this scene's own box clicks would re-run it against
+  // a not-yet-updated shared value. A chain update dropped here because a
+  // local enter/exit animation is in flight is NOT lost:
+  // applyExternalFocusChain itself records the pending target and a
+  // module-level watcher inside iso-view-state.svelte.ts retries it the
+  // instant that animation settles (EVID-100 Finding #1) — this effect
+  // does not need to know about `animationKind` at all.
+  let sharedChainPrimed = false;
+  $effect(() => {
+    const shared = sharedFocusChain();
+    if (!sharedChainPrimed) {
+      sharedChainPrimed = true;
+      return;
+    }
+    untrack(() => {
+      if (rootBranch.kind !== "ok") return;
+      if (chainsEqual(currentFocusChain(), shared)) return;
+      void applyExternalFocusChain(rootBranch.doc, shared);
+    });
+  });
+</script>
+
+<div class="iso-minimap" class:fullscreen>
+  {#if rootBranch.kind === "loading"}
+    <p class="status-msg">Loading map…</p>
+  {:else if rootBranch.kind === "empty"}
+    <p class="status-msg">No map yet</p>
+  {:else if rootBranch.kind === "error"}
+    <p class="status-msg">Map error: {rootBranch.message}</p>
+  {:else}
+    <Canvas>
+      <IsoScene rootDoc={rootBranch.doc} />
+    </Canvas>
+    {#if fullscreen}
+      <LevelBreadcrumb stack={levelStack} onCrumb={climbTo} {labelFor} />
+    {/if}
+    <Button
+      variant="ghost"
+      size="icon"
+      class="iso-controls-toggle-pos"
+      aria-label={controlsVisible ? "Hide 3D controls" : "Show 3D controls"}
+      aria-expanded={controlsVisible}
+      onclick={() => (controlsVisible = !controlsVisible)}
+    >
+      <span aria-hidden="true">⋯</span>
+    </Button>
+    {#if controlsVisible}
+      <IsoControls
+        {depthWindow}
+        onDepthWindowChange={(n) => setDepthWindow(rootBranch.doc, n)}
+        canAscend={levelStack.length > 1}
+        onAscend={ascend}
+      />
+    {/if}
+    <IsoA11yProxy
+      targets={dwellableTargets}
+      onFocusTarget={focusDwell}
+      onBlurTarget={blurDwell}
+    />
+  {/if}
+</div>
+
+<style>
+  .iso-minimap {
+    position: relative;
+    width: 100%;
+    height: 100%;
+    background: var(--bg);
+    color: var(--fg);
+    overflow: hidden;
+  }
+
+  .iso-minimap.fullscreen {
+    position: fixed;
+    inset: 0;
+  }
+
+  .status-msg {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    max-width: 90%;
+    margin: 0;
+    font-size: 11px;
+    line-height: 1.4;
+    color: var(--fg-3);
+    text-align: center;
+    pointer-events: none;
+  }
+
+  /* Positioning only (rule 24) — the button itself is the shared/ui
+     Button primitive, unmodified. Top-right corner, clear of the
+     bottom-right IsoControls cluster and the (fullscreen-only) top-left
+     breadcrumb. */
+  :global(.iso-controls-toggle-pos) {
+    position: absolute;
+    top: 6px;
+    right: 6px;
+    z-index: 6;
+  }
+</style>
diff --git a/template/src/widgets/iso-map/ui/IsoNodeBox.svelte b/template/src/widgets/iso-map/ui/IsoNodeBox.svelte
new file mode 100644
index 0000000..7a556fd
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoNodeBox.svelte
@@ -0,0 +1,60 @@
+<script lang="ts">
+  // ONE node: a lit MeshStandard box. Stays lit (never desaturated/faded by
+  // plane depth) per Scout-1 — only zone frames + plates carry the matte
+  // paper-sheet falloff.
+  //
+  // Stage 2: position is now RELATIVE to the parent <IsoPlane>'s own
+  // <T.Group> (see IsoZoneFrame.svelte's header comment — same reason).
+  //
+  // Stage 3: onPointerEnter/onPointerLeave feed model/iso-view-state's
+  // hover-dwell (armDwell/disarmDwell, wired by IsoPlane -> IsoScene, this
+  // box stays ISP-narrow and knows nothing about dwell timing itself).
+  // stopPropagation on both is load-bearing: without it, the SAME ray also
+  // intersects the plate mesh sitting directly below this box, and the
+  // plate would ALSO fire its own pointerenter/leave for every hover here
+  // — two simultaneous, conflicting dwell targets (node AND its parent
+  // plane) instead of the node one taking precedence while hovered.
+  //
+  // Stage 3 (redesigned): `emphasized` highlights THIS node only — the
+  // former whole-plane emphasis is retired (see IsoPlane.svelte) in favor
+  // of brightening just the hovered element's own fill color.
+  import { T } from '@threlte/core';
+  import type * as THREE from 'three';
+  import type { BoxSpec } from '../lib/iso-projection';
+  import { NODE_BOX_H, NODE_FOOTPRINT } from '../lib/iso-projection';
+  import { brightenForEmphasis } from '../lib/iso-materials';
+
+  let {
+    box,
+    color,
+    emphasized = false,
+    onClick,
+    onPointerEnter,
+    onPointerLeave,
+  }: {
+    box: BoxSpec;
+    color: THREE.Color;
+    emphasized?: boolean;
+    onClick?: (box: BoxSpec) => void;
+    onPointerEnter?: (box: BoxSpec) => void;
+    onPointerLeave?: (box: BoxSpec) => void;
+  } = $props();
+
+  const boxColor = $derived(emphasized ? brightenForEmphasis(color) : color);
+</script>
+
+<T.Mesh
+  position={[box.x, NODE_BOX_H / 2, box.z]}
+  onclick={() => onClick?.(box)}
+  onpointerenter={(event: PointerEvent) => {
+    event.stopPropagation();
+    onPointerEnter?.(box);
+  }}
+  onpointerleave={(event: PointerEvent) => {
+    event.stopPropagation();
+    onPointerLeave?.(box);
+  }}
+>
+  <T.BoxGeometry args={[box.w * NODE_FOOTPRINT, NODE_BOX_H, box.d * NODE_FOOTPRINT]} />
+  <T.MeshStandardMaterial color={boxColor} />
+</T.Mesh>
diff --git a/template/src/widgets/iso-map/ui/IsoNodeCard.svelte b/template/src/widgets/iso-map/ui/IsoNodeCard.svelte
new file mode 100644
index 0000000..fa5d144
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoNodeCard.svelte
@@ -0,0 +1,138 @@
+<script lang="ts">
+  // Stage 3 — a 3D-flavored sibling of
+  // widgets/composed-map/ui/ZoneDetailCard.svelte: SAME token-styled card
+  // chrome (rule 24 — plain CSS reading the SAME --bg-1/--line-2/--fg-*
+  // tokens, no shared/ui primitive re-skin), but for a hovered/dwelt 3D
+  // NODE box instead of a 2D zone. Content only, per this stage's brief:
+  // label, kind, description_ru, and connections (via the EXISTING
+  // widgets/composed-map/model/node-tabs.svelte#buildNodeConnections,
+  // reused verbatim — not reinvented here).
+  //
+  // Unlike ZoneDetailCard this card is NOT sticky/pinned: it is a
+  // transient hover-dwell affordance (model/iso-view-state.svelte.ts),
+  // closed by the SAME leave/blur that closed the dwell, so it carries no
+  // close button. `pointer-events: none` — it never intercepts the
+  // pointer itself; the 3D mesh hover is the only thing that opens/closes
+  // it, and letting the mouse "arrive" over the card must not be a way to
+  // keep it open past that (kept simple on purpose for this spike stage).
+  import type { MapNode } from '@/entities/map';
+  import type { NodeConnection } from '@/widgets/composed-map/model/node-tabs.svelte';
+
+  let {
+    node,
+    connections,
+    cardEl = $bindable(null),
+  }: {
+    node: MapNode;
+    connections: readonly NodeConnection[];
+    cardEl?: HTMLElement | null;
+  } = $props();
+
+  // Resets the parent's bound ref on unmount so a stale, detached DOM node
+  // never lingers as IsoLeaderLine's supposed target (+page.svelte swaps
+  // between this and IsoLayerCard, never both at once).
+  $effect(() => {
+    return () => {
+      cardEl = null;
+    };
+  });
+</script>
+
+<div class="iso-card" role="note" aria-label="Node detail" bind:this={cardEl}>
+  <h3 class="iso-card-title">{node.label}</h3>
+  <div class="iso-card-kind">{node.kind}</div>
+  {#if node.description_ru}
+    <p class="iso-card-desc">{node.description_ru}</p>
+  {/if}
+  {#if connections.length > 0}
+    <div class="iso-card-section-label">Connections</div>
+    <ul class="iso-card-list">
+      {#each connections as conn (conn.dir + '|' + conn.relation + '|' + conn.label)}
+        <li>
+          <span class="iso-card-dir" class:iso-card-dir-in={conn.dir === 'in'}>
+            {conn.dir === 'out' ? '→' : '←'}
+          </span>
+          {conn.label}
+          <span class="iso-card-relation">({conn.relation})</span>
+        </li>
+      {/each}
+    </ul>
+  {/if}
+</div>
+
+<style>
+  .iso-card {
+    position: absolute;
+    bottom: 16px;
+    left: 16px;
+    max-width: 300px;
+    max-height: calc(100vh - 84px);
+    overflow-y: auto;
+    background: var(--bg-1);
+    border: 1px solid var(--line-2);
+    border-radius: 12px;
+    padding: 14px 16px;
+    box-shadow: var(--shadow-mini);
+    z-index: 4;
+    pointer-events: none;
+  }
+
+  .iso-card-title {
+    margin: 0 0 2px;
+    font-family: var(--font-sans);
+    font-weight: 500;
+    font-size: 15px;
+    color: var(--fg);
+  }
+
+  .iso-card-kind {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    letter-spacing: 0.04em;
+    text-transform: uppercase;
+    color: var(--fg-3);
+    margin-bottom: 8px;
+  }
+
+  .iso-card-desc {
+    font-size: 12px;
+    line-height: 1.5;
+    color: var(--fg-2);
+    margin: 0 0 8px;
+  }
+
+  .iso-card-section-label {
+    font-family: var(--font-mono);
+    font-size: 9.5px;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+    color: var(--fg-3);
+    margin-bottom: 4px;
+  }
+
+  .iso-card-list {
+    margin: 0;
+    padding-left: 16px;
+    font-size: 11.5px;
+    line-height: 1.6;
+    color: var(--fg-2);
+    max-height: 130px;
+    overflow-y: auto;
+  }
+
+  .iso-card-dir {
+    display: inline-block;
+    width: 1em;
+    color: var(--accent);
+  }
+
+  .iso-card-dir-in {
+    color: var(--fg-3);
+  }
+
+  .iso-card-relation {
+    color: var(--fg-3);
+    font-family: var(--font-mono);
+    font-size: 10px;
+  }
+</style>
diff --git a/template/src/widgets/iso-map/ui/IsoPlane.svelte b/template/src/widgets/iso-map/ui/IsoPlane.svelte
new file mode 100644
index 0000000..bc13545
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoPlane.svelte
@@ -0,0 +1,154 @@
+<script lang="ts">
+  // ONE level/sheet: the matte floor plate + its zone frames + node boxes.
+  // Owns per-box color resolution (selected vs default) so IsoZoneFrame /
+  // IsoNodeBox stay dumb/presentational (ISP) — they take final colors, not
+  // selection state.
+  //
+  // Stage 2: wraps its content in a <T.Group> positioned at the plane's own
+  // world origin (originX/y/originZ) and scaled by `presence` (0 -> 1 on
+  // descend-in, 1 -> 0 on ascend/collapse-out, driven by
+  // model/iso-view-state.svelte.ts — this component only reads the number,
+  // it owns no Tween of its own). Children (IsoZoneFrame/IsoNodeBox) now
+  // position themselves RELATIVE to this group, so scaling pivots around
+  // the plane's own origin instead of world (0,0,0). `interactive` gates
+  // whether boxes on this plane receive the click handler at all — the
+  // unified layer-explosion model (model/iso-view-state.svelte.ts#focusZone)
+  // makes every EXPANDED plane interactive (a click on any visible zone/
+  // mega, not just the deepest, re-focuses the explosion or collapses it);
+  // only collapsed sliver planes (rendered by IsoSliverPlane instead, never
+  // this component) stay inert. The prop itself is kept as an extension
+  // point, not removed.
+  //
+  // Stage 3 (redesigned): the plate itself no longer emphasizes as a
+  // WHOLE on hover — MINIMAP reframe retired the whole-plate boost
+  // (PLATE_EMPHASIS_OPACITY_MULT + bright plate <Edges>) in favor of
+  // highlighting only the individual zone/node under the cursor (see
+  // IsoZoneFrame.svelte / IsoNodeBox.svelte). `dwellTarget` is threaded
+  // through as a plain typed VALUE (type-only import — same pattern
+  // IsoA11yProxy.svelte already uses) purely so each box below can check
+  // "is it ME"; this component still never CALLS the model (no armDwell/
+  // disarmDwell here — ISP holds).
+  // onPlanePointerEnter/Leave fire from the plate mesh itself (stopping
+  // propagation so a lower-stacked plane along the same ray doesn't also
+  // register as hovered) — kept for the optional plane-level info card
+  // (+page.svelte, gated behind `showInfoCards`); onNodePointerEnter/Leave
+  // and onZonePointerEnter/Leave are forwarded straight through to each
+  // IsoNodeBox/IsoZoneFrame (ISP — this component doesn't know what a
+  // "dwell" is, it just relays box-level pointer events up).
+  import { T } from '@threlte/core';
+  import type { BoxSpec, PlaneSpec } from '../lib/iso-projection';
+  import type { IsoDwellTarget } from '../model/iso-view-state.svelte';
+  import {
+    type IsoColorTokens,
+    PLATE_THICKNESS,
+    PLATE_Y_OFFSET,
+    PLATE_OPACITY,
+    ZONE_FILL_OPACITY,
+    planeFalloff,
+    desaturateForDepth,
+  } from '../lib/iso-materials';
+  import IsoZoneFrame from './IsoZoneFrame.svelte';
+  import IsoNodeBox from './IsoNodeBox.svelte';
+
+  let {
+    plane,
+    planeIndex,
+    dimIndex,
+    selectedId,
+    colors,
+    presence = 1,
+    interactive = true,
+    dwellTarget = null,
+    onBoxClick,
+    onPlanePointerEnter,
+    onPlanePointerLeave,
+    onNodePointerEnter,
+    onNodePointerLeave,
+    onZonePointerEnter,
+    onZonePointerLeave,
+  }: {
+    plane: PlaneSpec;
+    planeIndex: number;
+    /** Depth used for the depth-dim/desaturate falloff. Defaults to
+     * planeIndex; IsoScene passes distance-from-deepest so the drilled-into
+     * (deepest) plane stays full and ancestors recede into faint context. */
+    dimIndex?: number;
+    selectedId: string | null;
+    colors: IsoColorTokens;
+    presence?: number;
+    interactive?: boolean;
+    dwellTarget?: IsoDwellTarget | null;
+    onBoxClick?: (box: BoxSpec) => void;
+    onPlanePointerEnter?: () => void;
+    onPlanePointerLeave?: () => void;
+    onNodePointerEnter?: (box: BoxSpec) => void;
+    onNodePointerLeave?: (box: BoxSpec) => void;
+    onZonePointerEnter?: (box: BoxSpec) => void;
+    onZonePointerLeave?: (box: BoxSpec) => void;
+  } = $props();
+
+  const dim = $derived(dimIndex ?? planeIndex);
+  const falloff = $derived(planeFalloff(dim));
+  const plateColor = $derived(desaturateForDepth(colors.plate, dim));
+  // Node boxes (the heaviest visual mass) darken with depth-from-focus too,
+  // so ancestor planes recede into faint context instead of cluttering the
+  // drilled-into level. The deepest plane (dim 0, falloff 1) stays full.
+  const nodeColor = $derived(colors.node.clone().multiplyScalar(0.22 + 0.78 * falloff));
+  const plateOpacity = $derived(PLATE_OPACITY * falloff);
+  const clickHandler = $derived(interactive ? onBoxClick : undefined);
+
+  function isEmphasized(box: BoxSpec): boolean {
+    if (!dwellTarget || dwellTarget.kind === 'plane') return false;
+    return dwellTarget.kind === box.kind && dwellTarget.id === box.id;
+  }
+</script>
+
+<T.Group position={[plane.originX, plane.y, plane.originZ]} scale={presence}>
+  <T.Mesh
+    position={[0, -PLATE_Y_OFFSET, 0]}
+    renderOrder={planeIndex}
+    onpointerenter={(event: PointerEvent) => {
+      event.stopPropagation();
+      onPlanePointerEnter?.();
+    }}
+    onpointerleave={(event: PointerEvent) => {
+      event.stopPropagation();
+      onPlanePointerLeave?.();
+    }}
+  >
+    <T.BoxGeometry args={[plane.plateW, PLATE_THICKNESS, plane.plateD]} />
+    <T.MeshStandardMaterial color={plateColor} transparent opacity={plateOpacity} />
+  </T.Mesh>
+
+  <!-- TODO(spike): level label skipped — @threlte/extras <Text> (troika-three-text)
+       fetches a default font at runtime; not worth the network-availability
+       risk in a throwaway route. plane.label is still read by the HUD text
+       overlay in +page.svelte instead. -->
+
+  {#each plane.boxes as box (box.id)}
+    {#if box.kind === 'zone'}
+      <IsoZoneFrame
+        {box}
+        renderOrder={planeIndex}
+        color={desaturateForDepth(selectedId === box.id ? colors.accentSoft : colors.accent, dim)}
+        fillOpacity={ZONE_FILL_OPACITY * falloff}
+        emphasized={isEmphasized(box)}
+        onClick={clickHandler}
+        onPointerEnter={onZonePointerEnter}
+        onPointerLeave={onZonePointerLeave}
+      />
+    {:else if dim === 0}
+      <!-- Node boxes only on the drilled-into (deepest) plane; ancestor
+           planes show frames-only so they read as faint context, not
+           clutter (minimap declutter). -->
+      <IsoNodeBox
+        {box}
+        color={selectedId === box.id ? colors.accent : nodeColor}
+        emphasized={isEmphasized(box)}
+        onClick={clickHandler}
+        onPointerEnter={onNodePointerEnter}
+        onPointerLeave={onNodePointerLeave}
+      />
+    {/if}
+  {/each}
+</T.Group>
diff --git a/template/src/widgets/iso-map/ui/IsoSliverPlane.svelte b/template/src/widgets/iso-map/ui/IsoSliverPlane.svelte
new file mode 100644
index 0000000..9519fe9
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoSliverPlane.svelte
@@ -0,0 +1,26 @@
+<script lang="ts">
+  // ACCORDION collapse — a collapsed ANCESTOR level (shallower than the
+  // current depthWindow), rendered as a bare thin plate only: no zone
+  // frames, no node boxes, no click handling. This is deliberate
+  // decluttering (OCP: a NEW component, mounted alongside <IsoPlane> in
+  // IsoScene, not a variant bolted onto it) — the collapsed history reads
+  // as "there's more above" via tight sliver-stack proximity
+  // (lib/iso-projection.ts#windowPlanes), not via full detail nobody asked
+  // to see. Inert by design (ISP: a sliver knows nothing about controls or
+  // selection) — climbing back to one of these levels goes through the
+  // reused LevelBreadcrumb (+page.svelte), not by clicking the sliver
+  // itself.
+  import { T } from '@threlte/core';
+  import type * as THREE from 'three';
+  import type { WindowedPlane } from '../lib/iso-projection';
+
+  const SLIVER_THICKNESS = 0.06;
+  const SLIVER_OPACITY = 0.35;
+
+  let { plane, color }: { plane: WindowedPlane; color: THREE.Color } = $props();
+</script>
+
+<T.Mesh position={[plane.originX, plane.y, plane.originZ]}>
+  <T.BoxGeometry args={[plane.plateW, SLIVER_THICKNESS, plane.plateD]} />
+  <T.MeshBasicMaterial {color} transparent opacity={SLIVER_OPACITY} />
+</T.Mesh>
diff --git a/template/src/widgets/iso-map/ui/IsoZoneFrame.svelte b/template/src/widgets/iso-map/ui/IsoZoneFrame.svelte
new file mode 100644
index 0000000..e8b4774
--- /dev/null
+++ b/template/src/widgets/iso-map/ui/IsoZoneFrame.svelte
@@ -0,0 +1,82 @@
+<script lang="ts">
+  // ONE zone: a thin outlined FRAME (a region boundary), not a filled volume —
+  // a near-invisible box (kept solid only so raycast picking still works)
+  // topped with an <Edges> outline. Scout-1 matte paper-sheet pass: the fill
+  // now shares the SAME `color` prop as the outline (tinted matte sheet)
+  // instead of being colorless/invisible.
+  //
+  // Stage 2: position is now RELATIVE to the parent <IsoPlane>'s own
+  // <T.Group> (which carries plane.originX/y/originZ) instead of taking
+  // originX/originZ/y props and re-adding them here — this makes the
+  // group's own `scale` (the enter/exit presence animation) pivot around
+  // the plane's own origin, not world (0,0,0).
+  //
+  // Stage 3 (redesigned): onPointerEnter/onPointerLeave feed model/iso-
+  // view-state's per-ELEMENT hover-dwell (armDwell/disarmDwell with
+  // kind:'zone', wired by IsoPlane -> IsoScene — mirrors IsoNodeBox's own
+  // wiring). `emphasized` brightens THIS zone's own fill + outline only —
+  // the former whole-plane emphasis is retired (see IsoPlane.svelte).
+  // stopPropagation is load-bearing for the same reason as IsoNodeBox: the
+  // same ray also intersects the plate mesh directly below this frame.
+  import { T } from '@threlte/core';
+  import { Edges } from '@threlte/extras';
+  import type * as THREE from 'three';
+  import type { BoxSpec } from '../lib/iso-projection';
+  import { ZONE_FRAME_H } from '../lib/iso-projection';
+  import {
+    ZONE_POLYGON_OFFSET_FACTOR,
+    ZONE_POLYGON_OFFSET_UNITS,
+    ELEMENT_EMPHASIS_FILL_MULT,
+    brightenForEmphasis,
+  } from '../lib/iso-materials';
+
+  let {
+    box,
+    color,
+    fillOpacity,
+    renderOrder = 0,
+    emphasized = false,
+    onClick,
+    onPointerEnter,
+    onPointerLeave,
+  }: {
+    box: BoxSpec;
+    /** Drives BOTH the matte fill and the <Edges> outline. */
+    color: THREE.Color;
+    fillOpacity: number;
+    renderOrder?: number;
+    emphasized?: boolean;
+    onClick?: (box: BoxSpec) => void;
+    onPointerEnter?: (box: BoxSpec) => void;
+    onPointerLeave?: (box: BoxSpec) => void;
+  } = $props();
+
+  const edgeColor = $derived(emphasized ? brightenForEmphasis(color) : color);
+  const fill = $derived(emphasized ? fillOpacity * ELEMENT_EMPHASIS_FILL_MULT : fillOpacity);
+</script>
+
+<T.Mesh
+  position={[box.x, ZONE_FRAME_H / 2, box.z]}
+  {renderOrder}
+  onclick={() => onClick?.(box)}
+  onpointerenter={(event: PointerEvent) => {
+    event.stopPropagation();
+    onPointerEnter?.(box);
+  }}
+  onpointerleave={(event: PointerEvent) => {
+    event.stopPropagation();
+    onPointerLeave?.(box);
+  }}
+>
+  <T.BoxGeometry args={[box.w, ZONE_FRAME_H, box.d]} />
+  <T.MeshBasicMaterial
+    color={edgeColor}
+    transparent
+    opacity={fill}
+    depthWrite={false}
+    polygonOffset={true}
+    polygonOffsetFactor={ZONE_POLYGON_OFFSET_FACTOR}
+    polygonOffsetUnits={ZONE_POLYGON_OFFSET_UNITS}
+  />
+  <Edges color={edgeColor} />
+</T.Mesh>
diff --git a/template/vite.config.ts b/template/vite.config.ts
index ce993b2..092bfc7 100644
--- a/template/vite.config.ts
+++ b/template/vite.config.ts
@@ -1,8 +1,8 @@
-import { sveltekit } from '@sveltejs/kit/vite';
-import { defineConfig } from 'vite';
-import { readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { sveltekit } from "@sveltejs/kit/vite";
+import { defineConfig } from "vite";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -11,11 +11,13 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 // (the only authoritative version source for the published app).
 const TEMPLATE_PKG_VERSION = (() => {
   try {
-    const pkg = JSON.parse(readFileSync(resolve(__dirname, 'package.json'), 'utf8'));
-    return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+    const pkg = JSON.parse(
+      readFileSync(resolve(__dirname, "package.json"), "utf8"),
+    );
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     // FIXME(build): template/package.json unreadable — falling back to 0.0.0
-    return '0.0.0';
+    return "0.0.0";
   }
 })();
 
@@ -25,14 +27,40 @@ export default defineConfig(({ command, mode }) => {
   // leaves FORGEPLAN_CWD untouched — the server then falls back to the
   // repo root's .forgeplan/ via runForgeplan's default resolution.
   // `dist/` (shipped via init) never executes this file (rule 21).
-  if (command === 'serve' && mode === 'playground' && !process.env.FORGEPLAN_CWD) {
-    process.env.FORGEPLAN_CWD = resolve(__dirname, '..', 'playground');
+  if (
+    command === "serve" &&
+    mode === "playground" &&
+    !process.env.FORGEPLAN_CWD
+  ) {
+    process.env.FORGEPLAN_CWD = resolve(__dirname, "..", "playground");
   }
 
   return {
     plugins: [sveltekit()],
     define: {
-      __FORGEPLAN_WEB_VERSION__: JSON.stringify(TEMPLATE_PKG_VERSION)
+      __FORGEPLAN_WEB_VERSION__: JSON.stringify(TEMPLATE_PKG_VERSION),
+    },
+    resolve: {
+      alias: {
+        // widgets/iso-map (Threlte/three) never calls useDraco/useGltf/
+        // useKtx2 from @threlte/extras, but the barrel re-exports them and
+        // the package has no deep-import subpaths + no sideEffects:false —
+        // DRACOLoader.js/KTX2Loader.js each emit a ~700KB/~500KB WASM asset
+        // the moment Vite's import graph reaches them, whether or not the
+        // class is ever instantiated. See vite/stubs/three-loaders.ts.
+        // TODO(iso-draco-basis): this alias is load-bearing (RFC-036 Risk
+        // R-4) — if a future @threlte/extras feature needs the REAL
+        // draco/basis loaders, this stub silently breaks it. Any real
+        // loader need re-opens this decision (ADR-011 revisit trigger).
+        "three/examples/jsm/loaders/DRACOLoader.js": resolve(
+          __dirname,
+          "vite/stubs/three-loaders.ts",
+        ),
+        "three/examples/jsm/loaders/KTX2Loader.js": resolve(
+          __dirname,
+          "vite/stubs/three-loaders.ts",
+        ),
+      },
     },
     // FIXME(prd-015-css-minify): lightningcss tree-shakes the
     // `:root[data-theme='light']` block + the new `--canvas-*` tokens
@@ -40,18 +68,18 @@ export default defineConfig(({ command, mode }) => {
     // separate chunks. Force esbuild for CSS minify until lightningcss
     // gains cross-chunk custom-property awareness.
     css: {
-      transformer: 'postcss'
+      transformer: "postcss",
     },
     build: {
-      cssMinify: 'esbuild',
-      sourcemap: false
+      cssMinify: "esbuild",
+      sourcemap: false,
     },
     server: {
       port: 5174,
       strictPort: false,
       fs: {
-        strict: false
-      }
-    }
+        strict: false,
+      },
+    },
   };
 });
diff --git a/template/vite/stubs/three-loaders.ts b/template/vite/stubs/three-loaders.ts
new file mode 100644
index 0000000..36692cf
--- /dev/null
+++ b/template/vite/stubs/three-loaders.ts
@@ -0,0 +1,20 @@
+// Build-only stub for two three.js example loaders that widgets/iso-map
+// never uses (grep confirms: only OrbitControls, interactivity,
+// MeshLineGeometry, MeshLineMaterial, Edges, HTML, useOrbitControls are
+// imported from @threlte/extras). @threlte/extras' barrel `index.js` also
+// re-exports useDraco/useGltf/useKtx2, and DRACOLoader.js/KTX2Loader.js each
+// carry a MODULE-TOP-LEVEL `new URL('../libs/.../*.wasm', import.meta.url)`
+// — Vite's asset pipeline emits that file the moment the module is reached
+// by the import graph, regardless of whether the exported class is ever
+// instantiated. @threlte/extras has no `sideEffects: false` and ships no
+// deep-import subpaths (package.json `exports` = "." only), so there is no
+// way to avoid pulling these two files in other than aliasing them away.
+//
+// Aliased in vite.config.ts onto the exact specifiers
+// 'three/examples/jsm/loaders/DRACOLoader.js' and
+// '.../KTX2Loader.js' — never onto the bare 'three' package, so any future
+// real usage of these loaders elsewhere would need its own explicit import
+// path (not silently stubbed).
+export class DRACOLoader {}
+export class KTX2Loader {}
+export const DRACO_GLTF_CONFIG = {};