Fix pre-release smoke probes after merged contracts

Issue: #122
Issue: #131
Issue: #107
User-Visible: no

.githooks/commit-msg

@@ -0,0 +1,14 @@
+#!/bin/sh
+set -eu
+
+message_file=$1
+
+# Git-generated merge commits do not represent an independently authored
+# product change and inherit provenance from their parents.
+case "${message_file##*/}" in
+  MERGE_MSG) exit 0 ;;
+esac
+
+repo_root=$(git rev-parse --show-toplevel)
+node "$repo_root/scripts/validate-commit-provenance.mjs" \
+  --message-file "$message_file" --staged --check-hook-mode

.githooks/pre-push

@@ -0,0 +1,80 @@
+#!/bin/sh
+set -eu
+
+# PROCESS.md 10.1: the blocking process gate lives here, because commits go
+# straight to dev without pull requests and GitHub blocks nothing on its side.
+# CI still runs the same script (10.3), but by then the code is already in dev —
+# that catch-up pass reports, it does not prevent.
+#
+# Git feeds one line per ref on stdin:
+#   <local ref> <local sha> <remote ref> <remote sha>
+
+repo_root=$(git rev-parse --show-toplevel)
+gate="$repo_root/scripts/process-gate.mjs"
+zero=$(printf '%040d' 0)
+
+# The gate reasons about commits. A repository without it — an old checkout, a
+# bisect, a worktree from before the script existed — must still be pushable.
+if [ ! -f "$gate" ]; then
+  exit 0
+fi
+
+# Reading issue status needs gh, and a hook that cannot work on a train is a
+# hook people disable. Offline the checks that need no network still run, and the
+# strict pass happens in CI, where gh is always present.
+issues_flag=""
+if command -v gh >/dev/null 2>&1 && gh auth status >/dev/null 2>&1; then
+  issues_flag="--issues"
+else
+  echo "process-gate: gh недоступен, проверка статуса issue пропущена — её выполнит CI" >&2
+fi
+
+status=0
+
+while read -r local_ref local_sha remote_ref remote_sha; do
+  # Deleting a remote branch pushes nothing to examine.
+  if [ "$local_sha" = "$zero" ]; then
+    continue
+  fi
+
+  # Tags carry no process state of their own: the commit they point at was
+  # already checked when it was pushed.
+  case "$local_ref" in
+    refs/tags/*) continue ;;
+  esac
+
+  if [ "$remote_sha" = "$zero" ]; then
+    # A branch that does not exist on the remote yet. Everything it adds on top
+    # of dev is new, so that is the range — not the whole history, which would
+    # drag in every violation committed before the gate existed.
+    base=$(git merge-base "$local_sha" refs/remotes/origin/dev 2>/dev/null || true)
+    if [ -z "$base" ]; then
+      echo "process-gate: не нашёл общего предка с origin/dev, проверяю последние 20 коммитов" >&2
+      base="$local_sha~20"
+    fi
+  else
+    base="$remote_sha"
+  fi
+
+  echo "process-gate: $local_ref, диапазон ${base}..${local_sha}" >&2
+  # shellcheck disable=SC2086
+  if ! node "$gate" --range "${base}..${local_sha}" --target-ref "$remote_ref" $issues_flag >&2; then
+    status=1
+  fi
+done
+
+if [ "$status" -ne 0 ]; then
+  cat >&2 <<'EOF'
+
+Push остановлен: нарушен процесс (PROCESS.md §10.2).
+
+Починить надо причину, а не симптом. Если нарушение уже опубликовано, его
+исправляет следующий коммит плюс issue с меткой `process` — не force-push
+(§12, правило 17).
+
+Обойти проверку можно через `git push --no-verify`, и тогда то же самое найдёт
+job `process-gate` в Validate — уже после того, как код окажется в dev.
+EOF
+fi
+
+exit "$status"

.github/workflows/mutation-gate.yml

@@ -0,0 +1,61 @@
+name: Mutation gate
+
+# Реестр известных поломок (issue #85): каждый мутант ломает продуктовый код
+# известным способом, и объявленный тест ОБЯЗАН на этом покраснеть. Тест,
+# оставшийся зелёным на сломанном коде, ничего не защищает — он лишь выглядит
+# защитой, и это хуже его отсутствия.
+#
+# Прогон дорогой: пересборка бандла на каждого мутанта. Поэтому он не входит в
+# Validate и не идёт на каждый push. Его место — перед стабильным релизом
+# (PROCESS.md §8) и раз в неделю по расписанию, чтобы дрейф тестов не копился
+# до релиза. Дешёвая половина — «якоря патчей живы, guard-файлы существуют» —
+# идёт с обычными юнитами: test/mutation-gate.test.mjs.
+
+on:
+  workflow_dispatch:
+  schedule:
+    # Понедельник, 05:20 UTC — до начала рабочего дня владельца.
+    - cron: '20 5 * * 1'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: mutation-gate
+  cancel-in-progress: true
+
+jobs:
+  mutants:
+    runs-on: ubuntu-latest
+    # Шесть мутантов × (сборка + браузерный смок) — это десятки минут, и это
+    # нормально: гейт предрелизный. Час — потолок против зависшего Chromium.
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: dev
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+
+      - run: npm ci
+
+      - name: Кэш браузеров Playwright
+        id: pw
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/ms-playwright
+          key: playwright-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
+
+      - name: Установить Chromium
+        if: steps.pw.outputs.cache-hit != 'true'
+        run: npx playwright install --with-deps chromium
+
+      - name: Реестр применим к текущему коду
+        run: node scripts/mutation-gate.mjs --check
+
+      - name: Каждый тест ловит свою поломку
+        run: node scripts/mutation-gate.mjs

.github/workflows/performance.yml

@@ -148,6 +148,8 @@ jobs:
         run: |
           npm run benchmark:large-house -- --target-root=../baseline --samples=7 --warmups=1 --output=../artifacts/performance/baseline.json
           npm run benchmark:large-house -- --target-root=. --samples=7 --warmups=1 --output=../artifacts/performance/candidate.json
+          npm run benchmark:large-house-isometric -- --target-root=../baseline --samples=7 --warmups=1 --output=../artifacts/performance/isometric-baseline.json
+          npm run benchmark:large-house-isometric -- --target-root=. --samples=7 --warmups=1 --output=../artifacts/performance/isometric-candidate.json
           npm run benchmark:glow -- --profile=large-light-blend-v1 --target-root=../baseline --samples=7 --warmups=1 --output=../artifacts/performance/blend-baseline.json
           npm run benchmark:glow -- --profile=large-light-blend-v1 --target-root=. --samples=7 --warmups=1 --output=../artifacts/performance/blend-candidate.json
           npm run benchmark:glow -- --profile=large-house-glow-overlay-v1 --target-root=../baseline --samples=7 --warmups=1 --output=../artifacts/performance/overlay-baseline.json
@@ -161,6 +163,7 @@ jobs:
         working-directory: candidate
         run: |
           npm run benchmark:compare -- --baseline=../artifacts/performance/baseline.json --candidate=../artifacts/performance/candidate.json --output=../artifacts/performance/comparison.json
+          npm run benchmark:compare -- --budgets=demo/performance/budgets-large-house-isometric.json --baseline=../artifacts/performance/isometric-baseline.json --candidate=../artifacts/performance/isometric-candidate.json --output=../artifacts/performance/isometric-comparison.json
           npm run benchmark:compare -- --budgets=demo/performance/budgets-large-light-blend.json --baseline=../artifacts/performance/blend-baseline.json --candidate=../artifacts/performance/blend-candidate.json --output=../artifacts/performance/blend-comparison.json
           npm run benchmark:compare -- --budgets=demo/performance/budgets-large-house-glow-overlay.json --baseline=../artifacts/performance/overlay-baseline.json --candidate=../artifacts/performance/overlay-candidate.json --output=../artifacts/performance/overlay-comparison.json
 

.github/workflows/process.yml

@@ -0,0 +1,456 @@
+name: Process
+
+# Событийный конвейер процесса (PROCESS.md). Смена статусной метки — это
+# сообщение: она порождает событие, событие запускает следующий шаг.
+#
+# S4-spec-review -> ревью ТЗ    -> S5-ready | S3-spec
+# S7-code-review -> код-ревью   -> слияние в dev -> S8-merged | S6-in-progress
+#
+# Три вещи, без которых конвейер молча не работает:
+#
+# 1. Метки переставляются токеном HP_PROCESS_TOKEN, а не GITHUB_TOKEN. GitHub
+#    намеренно не запускает workflow от событий, вызванных GITHUB_TOKEN, чтобы
+#    не было циклов — цепочка оборвалась бы после первого шага.
+# 2. Этот файл обязан лежать в ветке по умолчанию (main). Для события `issues`
+#    GitHub берёт workflow только оттуда, независимо от того, что в dev.
+# 3. Многострочный текст внутри `run:` — только через heredoc. Строка с нулевым
+#    отступом обрывает блок YAML, и скрипт обрезается без ошибки парсера.
+#    Проверять не только YAML, но и каждый `run` через `bash -n`.
+
+on:
+  issues:
+    types: [labeled]
+
+concurrency:
+  # Два события по одному issue не должны запускать два прогона.
+  group: process-issue-${{ github.event.issue.number }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+  issues: write
+  # Обязательно: claude-code-action получает OIDC-токен для авторизации
+  # GitHub App. Без этого прогон падает с «Could not fetch an OIDC token».
+  id-token: write
+
+jobs:
+  guard:
+    runs-on: ubuntu-latest
+    outputs:
+      stage: ${{ steps.decide.outputs.stage }}
+      cycle: ${{ steps.decide.outputs.cycle }}
+      limit: ${{ steps.decide.outputs.limit }}
+    steps:
+      - id: decide
+        env:
+          GH_TOKEN: ${{ secrets.HP_PROCESS_TOKEN }}
+          LABEL: ${{ github.event.label.name }}
+          BLOCKED: ${{ contains(github.event.issue.labels.*.name, 'blocked') }}
+          EXHAUSTED: ${{ contains(github.event.issue.labels.*.name, 'review-4') }}
+          SMALL: ${{ contains(github.event.issue.labels.*.name, 'small') }}
+          TRIVIAL: ${{ contains(github.event.issue.labels.*.name, 'trivial') }}
+          NUM: ${{ github.event.issue.number }}
+        run: |
+          # Этап определяется первым: от него зависит, какие вердикты считать.
+          stage=""; marker=""
+          case "$LABEL" in
+            S4-spec-review) stage="spec"; marker="SPEC-REVIEW" ;;
+            S7-code-review) stage="code"; marker="CODE-REVIEW" ;;
+            *) echo "метка $LABEL конвейер не запускает" ;;
+          esac
+
+          # Лимит циклов: 4 обычный, 2 на лёгком и коротком треке (PROCESS.md §4).
+          limit=4
+          if [ "$SMALL" = "true" ] || [ "$TRIVIAL" = "true" ]; then limit=2; fi
+
+          # Счётчик считает вердикты ТОЛЬКО своего этапа. Раньше он брал все
+          # подряд, и вердикт по ТЗ съедал цикл из бюджета код-ревью: на #89
+          # первое код-ревью получило r2/4. На задаче с двумя циклами ТЗ второе
+          # код-ревью упиралось бы в review-4 после одной правки.
+          #
+          # Этап опознаётся по имени документа в теле комментария. Если документа
+          # нет, вердикт не посчитается — недосчёт даёт лишний цикл, а перерасчёт
+          # остановил бы работу досрочно; из двух ошибок выбрана обратимая.
+          done_cycles=0
+          if [ -n "$stage" ]; then
+            done_cycles=$(gh issue view "$NUM" --repo "${{ github.repository }}" \
+              --json comments \
+              -q "[.comments[] | select(.body | test(\"Вердикт:\")) | select(.body | test(\"$marker\"))] | length")
+          fi
+
+          # Отказ обязан быть виден в issue, а не только в логе прогона.
+          # Ревьюшная метка обещает работу; если конвейер её не начал и промолчал,
+          # задача стоит в этом статусе бесконечно и никто об этом не узнаёт.
+          # Так и вышло на #123: чужой issue довели до S4-spec-review, guard
+          # отказался за 9 секунд, и в issue не было ни слова.
+          #
+          # Пишем только когда пытались запустить ревью, то есть stage опознан.
+          # Иначе комментарий уходил бы на каждую смену любой метки.
+          refuse() {
+            echo "$1"
+            gh issue comment "$NUM" --repo "${{ github.repository }}" --body \
+              "Конвейер ревью не запущен: $2
+
+          Метка \`$LABEL\` обещает работу, которая не начнётся, поэтому статус лучше вернуть в предыдущий — иначе задача простоит здесь бесконечно. [Прогон](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})."
+            stage=""
+          }
+
+          # Автор issue здесь не проверяется (решение владельца 2026-08-13).
+          # Проверка стоит на входе в процесс, а не на каждом шаге: как только
+          # задача получила статусную метку, она в работе, и кто её завёл — не
+          # имеет значения. Само присвоение метки и есть явное подтверждение
+          # владельца, причём проверенное платформой: метки может ставить только
+          # тот, у кого есть право записи в репозиторий. Прежняя проверка здесь
+          # дублировала эту гарантию и заставляла переоформлять чужие отчёты
+          # своими issue — чистая работа впустую, как на #123.
+          if [ -z "$stage" ]; then
+            :
+          elif [ "$BLOCKED" = "true" ]; then
+            refuse "стоит blocked — конвейер не запускается" \
+              "на issue стоит \`blocked\` — задача ждёт внешнего решения. Снять метку, когда решение принято."
+          elif [ "$EXHAUSTED" = "true" ]; then
+            refuse "стоит review-4 — решение за владельцем" \
+              "на issue стоит \`review-4\`: лимит циклов ревью исчерпан, дальше решает владелец — разделить задачу, отклонить или арбитраж (PROCESS.md §4)."
+          elif [ "$done_cycles" -ge "$limit" ]; then
+            echo "циклов этапа $stage пройдено $done_cycles из $limit — лимит исчерпан"
+            gh issue edit "$NUM" --repo "${{ github.repository }}" --add-label review-4
+            gh issue comment "$NUM" --repo "${{ github.repository }}" --body \
+              "Лимит циклов ревью исчерпан ($done_cycles из $limit на этапе \`$stage\`). Пятого захода нет: решение владельца — разделить задачу, отклонить или арбитраж (PROCESS.md §4)."
+            stage=""
+          else
+            echo "этап $stage, цикл $((done_cycles + 1)) из $limit"
+          fi
+          echo "stage=$stage" >> "$GITHUB_OUTPUT"
+          echo "cycle=$((done_cycles + 1))" >> "$GITHUB_OUTPUT"
+          echo "limit=$limit" >> "$GITHUB_OUTPUT"
+
+  review:
+    needs: guard
+    if: needs.guard.outputs.stage != ''
+    runs-on: ubuntu-latest
+    # Время — единственный настоящий ограничитель зациклившегося прогона.
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: dev
+
+      # Окружение готовит workflow, а не модель своими ходами. Раньше промпт
+      # велел ревьюеру самому выполнить `npm ci`: минуты уходили на установку без
+      # кэша, платились из бюджета 45 минут и из лимитов подписки, а ходы модели
+      # тратились на работу инфраструктуры. В validate.yml кэш стоит на всех
+      # тяжёлых job, здесь его не было.
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+
+      # Материал ревью живёт в ветке задачи: ТЗ в docs/specs/ и код коммитятся
+      # в issue/<NN>-slug. Если ветка запушена — переключаемся на неё, иначе
+      # ревьюер прочтёт dev и не найдёт того, что должен оценивать.
+      - name: Перейти на ветку задачи
+        id: branch
+        env:
+          NUM: ${{ github.event.issue.number }}
+        run: |
+          branch=$(git ls-remote --heads origin "issue/${NUM}-*" \
+            | head -1 | sed 's|.*refs/heads/||')
+          if [ -n "$branch" ]; then
+            git checkout -q "origin/$branch"
+            echo "материал ревью: ветка $branch, $(git rev-parse --short HEAD)"
+            echo "name=$branch" >> "$GITHUB_OUTPUT"
+          else
+            echo "::warning::ветка issue/${NUM}-* не найдена на origin — ревью пойдёт по dev"
+            echo "МАТЕРИАЛ НЕ ЗАПУШЕН" >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+      # Зависимости ставятся ПОСЛЕ переключения на ветку задачи: lockfile мог
+      # измениться именно в ней, и установка по копии из dev дала бы не то дерево.
+      - name: Установить зависимости
+        run: npm ci
+
+      # Браузер нужен не всякому ревью (см. правило выбора гейтов в промпте),
+      # но когда нужен — качать его заново дороже, чем держать в кэше.
+      - name: Кэш браузеров Playwright
+        id: pw
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/ms-playwright
+          key: playwright-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
+
+      - name: Установить Chromium
+        if: steps.pw.outputs.cache-hit != 'true'
+        run: npx playwright install --with-deps chromium
+
+      - name: Review
+        id: review
+        uses: anthropics/claude-code-action@v1
+        with:
+          # Подписка, а не отдельный счёт API: токен выпускается через
+          # `claude setup-token` (Pro/Max). Действуют лимиты подписки.
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          prompt: |
+            Ты ревьюер проекта House Plan. Язык ответа — русский.
+
+            Issue: #${{ github.event.issue.number }}
+            Репозиторий: ${{ github.repository }}
+            Этап: ${{ needs.guard.outputs.stage }}
+              spec — ревью ТЗ (PROCESS.md §2.4)
+              code — код-ревью (PROCESS.md §2.7)
+
+            Прочитай в этом порядке, прежде чем судить:
+              1. docs/SCOPE.md — зачем продукт существует и для кого. Он
+                 ограничитель: «features are built, improved and accepted only
+                 if they serve a job listed here». Первый вопрос к задаче —
+                 какую строку Core user jobs она закрывает.
+              2. AGENTS.md и PROCESS.md — процесс, классы изменений, трейлеры,
+                 лимит циклов, формат вердикта.
+              3. Тело issue #${{ github.event.issue.number }} и все комментарии.
+              4. Если меняется видимое поведение — docs/USER-GUIDE.ru.md:
+                 терминология интерфейса берётся оттуда, а не изобретается.
+              5. Канонический документ затронутой подсистемы: docs/SUN.md,
+                 LIGHT.md, CANVAS.md, WALL-THICKNESS.md, UX-MODES.md,
+                 CONFIG-COMPATIBILITY.md, TOUCH-SUPPORT.md.
+
+            Для этапа spec: если issue помечен small, ТЗ живёт в теле issue и
+            файла в docs/specs/ быть не должно. Иначе ТЗ — docs/specs/<NN>-*.md.
+            Проверь обязательные разделы §7.1, однозначность каждого AC и
+            указание способа доказательства. Отдельно проверь, что автор не
+            выдал догадку за решение: утверждение о поведении, которого нет ни
+            в одном документе и которое не помечено как предположение, —
+            замечание. Не бывает сложной задачи без единого открытого вопроса.
+
+            Владельцу задаются только продуктовые вопросы: что человек видит или
+            делает и каков объём видимых изменений в этом issue. Технический
+            вопрос, вынесенный владельцу, — тоже замечание: ты его снимаешь и
+            решаешь по существу в своём вердикте.
+
+            Для этапа code: материал — диапазон `git log --oneline origin/dev..HEAD`
+            и `git diff origin/dev...HEAD`. Ручного тестирования в цикле нет,
+            поэтому именно ты отвечаешь на вопрос «оно вообще работает».
+            По каждому AC: либо он доказан автотестом и ты убедился, что тест
+            умеет падать, либо разобран по коду с явной записью «проверено
+            чтением, не исполнением». «Verified» без названной команды и её
+            результата доказательством не является. Зависимости уже установлены
+            workflow, Chromium тоже — `npm ci` выполнять не нужно. Проверь
+            трейлеры Issue и User-Visible, при User-Visible: yes — правки в оба
+            changelog в том же коммите.
+
+            **Объём гейтов соразмерен задаче.** Прогонять весь набор на каждой
+            правке — не тщательность, а потеря времени: полные наборы это
+            предрелизный гейт (PROCESS.md §8), а не гейт ревью.
+
+            Всегда, они дешёвые:
+              `npx tsc --noEmit`, `npm test`, `npm run build` со сверкой трёх
+              копий бандла.
+
+            По необходимости, и «необходимость» определяется diff'ом и AC:
+              - браузерные смоки `demo/smoke_*.mjs` — названные в AC плюс
+                относящиеся к тронутым поверхностям. Их 127; прогон всех уместен
+                только когда задача действительно задевает всё;
+              - `npm run golden:verify` — если diff может изменить видимый
+                результат: рендер, геометрия, стили, слои;
+              - `python -m pytest tests_backend -q` — если тронут
+                `custom_components/**/*.py`;
+              - performance-профили — если названы в AC либо тронуты
+                чувствительные к перфу пути.
+
+            Дисциплина «тест должен уметь падать» не отменяется, но применяется к
+            тем тестам, которые ты прогонял.
+
+            **В комментарии обязателен перечень: какие гейты прогнал, какие нет и
+            почему.** Это условие честности такого сужения: непрогнанный гейт
+            становится видимым решением, а не молчаливым пропуском. Раздел «чего
+            не проверял» в документе ревью — не формальность, а главный его
+            раздел на коротких задачах.
+
+            Ты НЕ правишь ни ТЗ, ни продуктовый код. Только оцениваешь.
+
+            Серьёзность: High блокирует; Medium обязан стать отдельным issue;
+            Low либо правится, либо снимается с записью. Жёлтый вердикт
+            допустим при полностью выполненных AC, если изменение не решает
+            заявленный сценарий или ухудшает смежный. Продуктовое рассуждение
+            расширяет вопросы, но не отменяет AC и не даёт права менять скоуп.
+
+            Каждую Medium-находку заведи отдельным issue со ссылкой на
+            #${{ github.event.issue.number }} и метками: тип, приоритет,
+            S1-new. «Оставили в тексте ревью» закрытием не считается и прямо
+            запрещено §12.
+
+            Напиши полный документ ревью в файл
+            docs/reviews/<SPEC|CODE>-REVIEW-${{ github.event.issue.number }}-r${{ needs.guard.outputs.cycle }}.md
+            (SPEC для этапа spec, CODE для code): скоуп, как проверялось,
+            находки с воспроизведением, что проверено и корректно, чего не
+            проверял. Каталог docs/reviews/ создай, если его нет. Больше не
+            пиши ничего: любой файл вне docs/reviews/ опубликован не будет.
+
+            Затем оставь в issue краткий комментарий: вердикт, ключевые находки
+            и ссылка на документ. Первой строкой — вердикт в формате §7.2:
+            `Вердикт: зелёный/жёлтый/красный · цикл r${{ needs.guard.outputs.cycle }}/${{ needs.guard.outputs.limit }} · High: N · Medium: N → #…`
+
+            Затем верни JSON по схеме. Это последнее действие и оно обязательно:
+            без него метка не переставится и конвейер встанет.
+          claude_args: |
+            --max-turns 150
+            --allowedTools Read,Write,Grep,Glob,Bash,mcp__github__add_issue_comment,mcp__github__issue_write,mcp__github__issue_read
+            --json-schema '{"type":"object","properties":{"verdict":{"type":"string","enum":["green","yellow","red"]},"high":{"type":"integer"},"medium":{"type":"integer"},"summary":{"type":"string"}},"required":["verdict","high","medium","summary"]}'
+
+      # Ревьюер пишет только в docs/reviews/. Что именно попадёт в коммит,
+      # решает этот шаг, а не модель: всё остальное откатывается.
+      - name: Опубликовать документ ревью
+        env:
+          TOKEN: ${{ secrets.HP_PROCESS_TOKEN }}
+          BRANCH: ${{ steps.branch.outputs.name }}
+          NUM: ${{ github.event.issue.number }}
+        run: |
+          # Ветки задачи может не быть: у задач, размеченных до появления
+          # конвейера, ТЗ лежит прямо в dev. Раньше шаг в этом случае молча
+          # выходил с нулём, и разбор ревью терялся — оставался только вердикт
+          # комментарием. Это тот же тихий отказ: шаг сообщал об успехе тем, что
+          # ничего не сделал. Документ ложится туда же, где лежит само ТЗ.
+          target="${BRANCH:-dev}"
+          if [ -z "$BRANCH" ]; then
+            echo "::warning::ветки задачи нет — документ ревью ляжет в dev"
+          fi
+          git checkout -- . 2>/dev/null || true
+          git clean -fd -e docs/reviews -e node_modules >/dev/null 2>&1 || true
+          git add docs/reviews 2>/dev/null || true
+          if git diff --cached --quiet; then
+            echo "::warning::документ ревью не создан"
+            exit 0
+          fi
+          git -c user.name="claude[bot]" \
+              -c user.email="209825114+claude[bot]@users.noreply.github.com" \
+              commit -q -F - <<EOF
+          docs: review document for #$NUM
+
+          Issue: #$NUM
+          User-Visible: no
+          EOF
+          # Публикация в dev идёт из детачнутого состояния поверх ветки задачи
+          # либо dev, поэтому push нужен с явным перебазированием при гонке:
+          # dev мог уйти вперёд, пока шло ревью — оно длится до 45 минут.
+          if ! git push -q "https://x-access-token:$TOKEN@github.com/${{ github.repository }}" \
+               "HEAD:$target"; then
+            git fetch -q origin "$target"
+            if ! git -c user.name="claude[bot]" \
+                     -c user.email="209825114+claude[bot]@users.noreply.github.com" \
+                     rebase "origin/$target"; then
+              git rebase --abort || true
+              echo "::error::документ ревью не удалось опубликовать в $target: конфликт"
+              exit 0
+            fi
+            git push -q "https://x-access-token:$TOKEN@github.com/${{ github.repository }}" \
+              "HEAD:$target"
+          fi
+          echo "документ опубликован в $target"
+
+      - name: Решение по вердикту
+        id: decide
+        env:
+          OUT: ${{ steps.review.outputs.structured_output }}
+          STAGE: ${{ needs.guard.outputs.stage }}
+        run: |
+          verdict=$(echo "$OUT" | jq -r '.verdict')
+          high=$(echo "$OUT" | jq -r '.high')
+          echo "вердикт: $verdict, High: $high"
+
+          # Вперёд двигает ТОЛЬКО зелёный. Жёлтый и красный возвращают
+          # автору: на прогоне #111 жёлтый означал, что AC описывает неверное
+          # изменение контракта — реализовать такое ТЗ значит сделать ошибку
+          # по инструкции. Оба считаются циклом.
+          if [ "$verdict" = "green" ] && [ "$high" -eq 0 ]; then
+            green=true
+            case "$STAGE" in
+              spec) from=S4-spec-review; to=S5-ready ;;
+              code) from=S7-code-review; to=S8-merged ;;
+            esac
+          else
+            green=false
+            case "$STAGE" in
+              spec) from=S4-spec-review; to=S3-spec ;;
+              code) from=S7-code-review; to=S6-in-progress ;;
+            esac
+          fi
+          echo "green=$green" >> "$GITHUB_OUTPUT"
+          echo "from=$from"   >> "$GITHUB_OUTPUT"
+          echo "to=$to"       >> "$GITHUB_OUTPUT"
+
+      # S8-merged утверждает, что код в dev. Значит слияние обязано произойти
+      # ДО метки, иначе она врёт в промежутке.
+      #
+      # При конфликте шаг НЕ падает и метку не оставляет на месте. Первая
+      # редакция делала именно так, и это оказалось тупиком: автор ждёт смену
+      # метки, метка не менялась, и он тридцать раз опрашивал впустую, чтобы
+      # затем отчитаться «лимит исчерпан» — при зелёном вердикте. Инвариант
+      # теперь жёстче: ПОСЛЕ ПРОГОНА РЕВЬЮ МЕТКА МЕНЯЕТСЯ ВСЕГДА.
+      - name: Слить ветку в dev
+        id: merge
+        if: needs.guard.outputs.stage == 'code' && steps.decide.outputs.green == 'true'
+        env:
+          TOKEN: ${{ secrets.HP_PROCESS_TOKEN }}
+          GH_TOKEN: ${{ secrets.HP_PROCESS_TOKEN }}
+          BRANCH: ${{ steps.branch.outputs.name }}
+          NUM: ${{ github.event.issue.number }}
+        run: |
+          if [ -z "$BRANCH" ]; then
+            echo "::error::ветки задачи нет — сливать нечего"
+            echo "merged=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          git fetch -q origin dev
+          git checkout -q -B merge-into-dev "origin/$BRANCH"
+          if ! git -c user.name="claude[bot]" \
+                   -c user.email="209825114+claude[bot]@users.noreply.github.com" \
+                   rebase origin/dev; then
+            git rebase --abort || true
+            echo "merged=false" >> "$GITHUB_OUTPUT"
+            echo "::warning::ветка $BRANCH не сливается в dev без конфликта"
+            cat > /tmp/conflict.md <<EOF
+          **Код-ревью зелёное — вердикт выше в силе, переделывать работу не нужно.** Не удалось только слияние: ветка \`$BRANCH\` конфликтует с \`dev\`.
+
+          Задача переведена в \`S6-in-progress\`, потому что работа вернулась к автору. Осталась не правка кода, а ребейз:
+
+          1. \`git fetch origin\`, затем \`git rebase origin/dev\` в ветке задачи, разрешить конфликт;
+          2. запушить ветку;
+          3. вернуть метку \`S7-code-review\`.
+
+          Повторный прогон ревью — не формальность: после ребейза на новый \`dev\` это другой код, и принимать его без проверки нельзя. Цикл считается по этапу, лимит на код-ревью тратится отдельно от ревью ТЗ.
+          EOF
+            gh issue comment "$NUM" --repo "${{ github.repository }}" --body-file /tmp/conflict.md
+            exit 0
+          fi
+          git push -q "https://x-access-token:$TOKEN@github.com/${{ github.repository }}" HEAD:dev
+          echo "merged=true" >> "$GITHUB_OUTPUT"
+          echo "слито в dev: $(git rev-parse --short HEAD)"
+
+      - name: Переставить метку
+        env:
+          # Именно PAT: с GITHUB_TOKEN следующий шаг конвейера не запустится.
+          GH_TOKEN: ${{ secrets.HP_PROCESS_TOKEN }}
+          NUM: ${{ github.event.issue.number }}
+          FROM: ${{ steps.decide.outputs.from }}
+          # Зелёное код-ревью без слияния ведёт не в S8-merged, а обратно к
+          # автору: метка утверждала бы, что код в dev, а его там нет.
+          TO: ${{ (needs.guard.outputs.stage == 'code' && steps.decide.outputs.green == 'true' && steps.merge.outputs.merged != 'true') && 'S6-in-progress' || steps.decide.outputs.to }}
+        run: |
+          gh issue edit "$NUM" --repo "${{ github.repository }}" \
+            --add-label "$TO" --remove-label "$FROM"
+          echo "$FROM -> $TO"
+
+      - name: Позвать владельца, если ревью упало
+        if: failure()
+        env:
+          GH_TOKEN: ${{ secrets.HP_PROCESS_TOKEN }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        run: |
+          # Тело через heredoc, а не многострочный --body: строка с нулевым
+          # отступом обрывает блок YAML и оставляет незакрытую кавычку.
+          cat > /tmp/failure.md <<EOF
+          Автоматическое ревью не отработало: [прогон]($RUN_URL). Статусная метка не менялась, задача осталась на месте.
+
+          Если вердикт выше всё же опубликован — сбой произошёл после него. Перестановку метки в этом случае выполняет чат обслуживания или владелец, но не автор задачи: автор не толкует вердикт о своей же работе.
+          EOF
+          gh issue comment "${{ github.event.issue.number }}" \
+            --repo "${{ github.repository }}" --body-file /tmp/failure.md

.github/workflows/publish-prerelease.yml

@@ -191,6 +191,60 @@ jobs:
               );
             }
 
+  # PROCESS.md 10.2 item 10: closing issues and stripping status labels happens
+  # because a beta was published, not because someone remembered to do it. The
+  # manual step was skipped twice, and both times it broke the invariant that a
+  # closed issue carries no status label — the one thing `verify` relies on.
+  #
+  # A manual step after a successful release is the worst kind: by the time it is
+  # due, the work already looks finished, which is exactly why it gets forgotten.
+  close-merged:
+    needs: [gate, publish]
+    if: ${{ needs.publish.outputs.newly_published == 'true' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      # Deliberately the stock token, not a PAT: events caused by GITHUB_TOKEN do
+      # not start workflows, so removing the label cannot wake the review
+      # pipeline. A PAT here would build a cascade out of a bookkeeping step.
+      issues: write
+    steps:
+      - name: Close the S8-merged queue and strip status labels
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          TAG: ${{ needs.gate.outputs.tag }}
+          URL: ${{ needs.publish.outputs.url }}
+        run: |
+          set -euo pipefail
+          # Only the owner's issues take part in the process; issues filed by
+          # anyone else never carry status labels and are not ours to close.
+          numbers=$(gh issue list --repo "$REPO" --state open --label S8-merged \
+            --author Matysh --limit 100 --json number --jq '.[].number')
+          if [ -z "$numbers" ]; then
+            echo "the S8-merged queue is empty, nothing to close"
+          else
+            for n in $numbers; do
+              gh issue comment "$n" --repo "$REPO" \
+                --body "Выпущено в \`$TAG\` · [релиз]($URL)"
+              # Label first, then close. If the run dies between the two steps an
+              # open issue without a status is visible and fixable in the flow;
+              # the reverse order would recreate the exact breakage this job is
+              # here to prevent.
+              gh issue edit "$n" --repo "$REPO" --remove-label S8-merged
+              gh issue close "$n" --repo "$REPO" --reason completed
+              echo "closed #$n"
+            done
+          fi
+          # Targeted at the defect that actually recurs, not at the invariant in
+          # general: no closed issue may still carry S8-merged.
+          leftover=$(gh issue list --repo "$REPO" --state closed --label S8-merged \
+            --limit 100 --json number --jq 'length')
+          test "$leftover" = "0" || {
+            echo "::error::$leftover closed issues still carry S8-merged"
+            exit 1
+          }
+
   announce:
     needs: [gate, publish]
     if: ${{ needs.publish.outputs.newly_published == 'true' }}

.github/workflows/validate.yml

@@ -15,6 +15,48 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  provenance:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: { fetch-depth: 0 }
+      - uses: actions/setup-node@v4
+        with: { node-version: 22 }
+      - name: Validate commit trailers and hook mode
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          BEFORE_SHA: ${{ github.event.before }}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.sha }}
+          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+        run: |
+          node scripts/validate-commit-provenance.mjs --check-hook-mode --github-range
+
+  # Догоняющая проверка процесса (PROCESS.md §10.3). Хуки ловят нарушение на
+  # машине автора, но их можно обойти `--no-verify`, а коммиты идут прямо в dev
+  # без PR — GitHub на своей стороне не блокирует ничего. Это последнее место,
+  # где нарушение правила №1 ловится машиной. Job независимый: краснеет сам и
+  # не роняет остальные, откат — удалить его отсюда, скрипт остаётся рабочим.
+  process-gate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: { fetch-depth: 0 }
+      - uses: actions/setup-node@v4
+        with: { node-version: 22 }
+      - name: Process gate
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          BEFORE_SHA: ${{ github.event.before }}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.sha }}
+          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+          TARGET_REF: ${{ github.ref }}
+          # Публичный репозиторий: штатного токена хватает на чтение issue.
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          node scripts/process-gate.mjs --github-range --issues
+
   hacs:
     runs-on: ubuntu-latest
     steps:

AGENTS.md

@@ -6,60 +6,367 @@ House Plan is one HACS package with two parts plus a demo harness:
 - **Storage integration** (`custom_components/houseplan/`, Python) — the Home Assistant backend.
 - **Demo harness** (`demo/`) — a self-contained Playwright page (`demo/srv/demo.html`) that renders the card against a fake `hass`, used for screenshots and the `smoke_*.mjs` end-to-end suite.
 
-Standard commands live in `package.json` scripts, `CONTRIBUTING.md`, and `docs/DEVELOPMENT.md`. Read `docs/ARCHITECTURE.md` and `docs/STATUS.md` before non-trivial changes.
+## Read this first
+
+**`docs/SCOPE.md` before anything else.** It was fixed with the owner and states
+its own authority: features are built, improved and accepted **only** if they
+serve a job listed there. It carries the mission, the three personas, the core
+user jobs and the out-of-scope list.
+
+Its central consequence: **View mode is the product for two of the three
+personas.** Editors are admin-only tools and must never leak interactions into
+View.
+
+For work that changes visible behaviour, also read `docs/USER-GUIDE.ru.md` —
+interface wording comes from there and is not invented, or the UI starts speaking
+developer.
+
+Then `PROCESS.md` (the full process), `docs/STATUS.md` (where the release line
+is), and for non-trivial changes `docs/ARCHITECTURE.md` plus the canonical
+document of the subsystem you touch: `SUN.md`, `LIGHT.md`, `CANVAS.md`,
+`WALL-THICKNESS.md`, `UX-MODES.md`, `CONFIG-COMPATIBILITY.md`,
+`TOUCH-SUPPORT.md`.
+
+Standard commands live in `package.json` scripts, `CONTRIBUTING.md` and
+`docs/DEVELOPMENT.md`.
+
+## Canonical backlog and status
+
+[GitHub Issues](https://github.com/Matysh/houseplan-card/issues) are the canonical
+task records: problem, scope, acceptance criteria and discussion.
+
+**Status lives in labels:** `S1-new`, `S2-analysis`, `S3-spec`, `S4-spec-review`,
+`S5-ready`, `S6-in-progress`, `S7-code-review`, `S8-merged`, plus `blocked` on top
+of a status and `rejected` on a closed issue. Exactly one `S*` label per open
+issue. [GitHub Projects (v2)](https://github.com/users/Matysh/projects/1) is a
+human-facing view synchronised from the labels, not the source of truth.
+
+Two shortcuts exist for small work. `small` — the light track: the spec lives in
+the issue body and its review is a comment. `trivial` — the short track: no spec
+stage at all, `S2-analysis` straight to `S5-ready`, with the AC written into the
+issue body first. `trivial` requires a bug confined to one surface with no new UX
+contract, no migration, no i18n, no perf or touch impact, at most three checkable
+AC, **and expected behaviour already on record** — nothing left to decide. Code
+review is never skipped on either track; it is what stands in for testing.
+`PROCESS.md` §5 and §5.1 hold the criteria.
+
+An issue filed by an outsider is worked exactly like one of the owner's own, once
+the owner has decided to take it. The check sits **at the entrance**, not on every
+step: while an issue carries no status label it is outside the process and the
+invariants do not apply to it; once a label is on, the task is in flight and **who
+filed it stops mattering**.
+
+Applying that first label *is* the owner's explicit decision, and the platform
+already guarantees it — only someone with write access can label. The earlier rule
+made outside reports be refiled as the owner's own issues, which turned out to be
+work for nothing: on #123 the spec was already written by the time the guard
+refused.
+
+Specs, audits and ADRs may live under `docs/`, but must link to their issue and
+must not become a parallel task list. When repository documentation disagrees with
+Issues, the issue wins.
+
+## Rule #1
+
+> Changing product code without an issue is forbidden. Code changes only when the
+> issue exists and sits in "Ready for development" or later.
+
+Check before touching product code:
+
+```
+gh issue view <NN> --repo Matysh/houseplan-card --json number,state,labels
+```
+
+The label must be one of `S5-ready`, `S6-in-progress`, `S7-code-review`. Anything
+else — refuse and say why. "Issue #83 is in `S2-analysis`, code is off limits.
+Start with the spec?" is the correct answer, not a smaller patch.
+
+## Change classes
+
+| Class | Paths | Issue required |
+|---|---|---|
+| **A — product** | `src/**`, `custom_components/houseplan/**/*.py`, `manifest.json`, `hacs.json`, i18n, `custom_components/**/translations/**` | yes |
+| **B — gates and tooling** | `test/**`, `tests_backend/**`, `demo/**`, `scripts/**`, `.github/workflows/**`, `rollup.config.mjs`, `tsconfig*.json` | yes; may reuse the issue it covers |
+| **C — documentation** | `docs/**`, `README*`, `CHANGELOG*`, `AGENTS.md` | not if it is part of its issue's DoD |
+| **D — generated** | `dist/**`, `custom_components/houseplan/frontend/**`, `demo/srv/assets/houseplan-card.js`, `demo/golden/baselines/**` | never changes on its own |
+
+The table above is a summary; `PROCESS.md` §1 is the authority and now covers the
+configuration files this one omits — `package.json`, `package-lock.json`,
+`pytest.ini`, `.gitignore`, `.gitattributes`, `.githooks/**` and the rest of
+`.github/**` are class B. Where paths overlap, **D beats A**: the built bundle
+lives inside `custom_components/houseplan/frontend/` and would otherwise read as
+product source.
+
+## Commits
+
+Hooks install themselves: `package.json` runs `"prepare": "node
+scripts/install-hooks.mjs"`, so `npm ci` sets `core.hooksPath` in every fresh
+clone. Verify with `git config core.hooksPath` — expect `.githooks`.
+
+Every non-merge commit carries **terminal** trailers:
+
+```text
+Issue: #123
+User-Visible: yes
+```
+
+One `Issue:` line per issue if a commit closes several. `User-Visible: no` for
+tests, refactors, tooling and documentation that does not change the product.
+`User-Visible: yes` requires edits to **both** changelogs — `docs/CHANGELOG.md`
+and `docs/CHANGELOG.ru.md` — in the same commit.
+
+A commit touching `demo/golden/baselines/**` additionally requires:
+
+```text
+Release: v1.62.0-beta.9
+Baseline-Reviewed: https://github.com/Matysh/houseplan-card/actions/runs/<run-id>
+```
+
+Never invent a review link and never rewrite published history to satisfy
+trailers. `.githooks/commit-msg` and the `provenance` CI job both run
+`scripts/validate-commit-provenance.mjs`.
+
+Branch: `issue/<NN>-slug`. Direct commits to `dev`, no PR — the owner's decision;
+CI checks after the fact, and a violation is fixed with a follow-up commit, never
+a force-push.
+
+**Push after every task, not before a beta.** While work sits unpushed there is
+nothing to review, and reviewing twenty tasks at once is not review. `dev` may hold
+unreviewed code while a task is in flight; what matters is its state when the
+reviewer says it is accepted.
+
+**Standing permission: push `issue/<NN>-slug` without asking.** The reviewer runs
+in CI and can only read what is on the remote — an unpushed spec or commit means
+the review either stalls or judges the wrong tree. Pushing a task branch publishes
+nothing to users and does not touch the integration branch, so it needs no command.
+
+**Do not merge into `dev` by hand.** On a green code review the pipeline rebases
+the task branch onto `dev`, pushes it, and only then sets `S8-merged` — the label
+asserts the code is in `dev`, so the merge has to happen first or the label lies
+in between.
+
+If the rebase conflicts the pipeline says so in the issue and sends the task back
+to `S6-in-progress`. The verdict still stands: nothing needs reviewing again, the
+remaining work is the rebase. Resolve it, push the branch, re-apply
+`S7-code-review`. The second review run is not a formality — after a rebase onto a
+moved `dev` this is different code, and accepting it unchecked is how regressions
+arrive. Cycles are counted per stage, so a code review spends its own budget.
+
+Everything else still requires the owner's explicit command: pushing `main`,
+creating tags, publishing betas and releases, closing issues.
 
 ## Two-agent workflow
 
-House Plan is developed by two agents: **Codex is the author** (analysis,
-estimate, spec, implementation) and **Claude is the reviewer** (estimate, spec,
-code). They exchange remarks through a local, git-ignored message bus —
-**read `.agents/PROTOCOL.md` before acting on any task**. It defines the
-message format, the estimate scales every agent must use, the three stages
-(`estimate` → `spec` → `code`), the three-round convergence limit and what gets
-published to GitHub.
+**Codex** writes analysis, specs and all product code. **Claude** reviews specs and
+code and owns infrastructure and distribution. The owner rules on disputes, closes
+issues and commands releases.
 
-Two rules that matter even if you read nothing else:
+Author and reviewer are different models, which is what "a fresh session without
+implementation context" means in practice. The reviewer never edits product code;
+the author never grades their own work.
 
-- write only into the *other* agent's inbox, never edit a file you did not
-  create, and move a processed message to `.agents/archive/`;
-- "verified" without a command and its output is not evidence — from either side.
+**Infrastructure-only work runs outside this flow.** CI, scripts, labels, demo
+stands, the landing page and distribution are Claude's alone, and running them
+through spec-writing and review buys nothing: the spec would restate what is
+already unambiguous, and author and reviewer would be the same role. So no spec
+file, no spec review, no code review, no walk through `S1`…`S8`.
 
-## Canonical backlog
+The test for "infrastructure only" is mechanical: **not a single class A file** —
+nothing under `src/**`, no `custom_components/**/*.py`, no manifests, no i18n. A
+task that touches class A even once is not infrastructure and takes the full flow;
+there is no such thing as "mostly infrastructure". The strictness is deliberate:
+a loose reading would turn this into the route by which product changes skip
+review.
 
-GitHub is the only active backlog for House Plan:
+What stays mandatory either way: an issue exists, both trailers are on every
+commit, `typecheck`, `test` and `build` are green, and any non-obvious decision is
+written down in the code or the issue rather than kept in someone's head.
 
-- [GitHub Issues](https://github.com/Matysh/houseplan-card/issues) are the
-  canonical task records: problem, scope, acceptance criteria and discussion.
-- [GitHub Projects (v2)](https://github.com/users/Matysh/projects/1) is
-  the canonical prioritization and workflow-status view. Every open in-scope
-  issue must be present there.
+**Review starts by itself.** Applying `S4-spec-review` or `S7-code-review` fires the
+pipeline, which reviews without anyone asking and takes ten to forty-five minutes.
 
-Before starting planned work, find or create its issue and keep its description,
-labels and Project status current as decisions and implementation state change.
-Close an issue only after the result is verified. Specs, audits and ADRs may
-remain under `docs/`, but must link to their issue and must not become a parallel
-task list. When repository documentation disagrees with Issues or Project v2,
-the GitHub backlog wins.
+**Having applied one of those labels, wait for the result instead of ending the
+session.** Reporting "handed over for review" stops a conveyor that could have kept
+moving on its own. An agent has no clock — it exists only during its own turn — so
+waiting means polling: every 90 seconds, at most 30 times. A single long sleep hits
+the command timeout. Watch the **label**, not the comment: the label is the state,
+the comment only explains it. Do not wait at all while `blocked` is set — the task
+is waiting on the owner, not on the reviewer. On exhausting the attempts, stop and
+tell the owner: a failed run leaves the label where it was, forever.
 
-## Cursor Cloud specific instructions
+What the new label means:
 
-The startup update script already runs `npm ci`, provisions a Python 3.13 backend venv at `.venv-backend`, and installs Playwright Chromium. You do not need to reinstall dependencies.
+| Now reads | What happened | What you do |
+|---|---|---|
+| `S5-ready` | the spec is accepted | write the code |
+| `S3-spec` | the spec came back | read the verdict, revise, re-apply `S4-spec-review` |
+| `S6-in-progress` | the code came back | revise, re-apply `S7-code-review` — **or**, if the verdict was green and only the merge conflicted, just rebase and re-apply. The comment says which |
+| `S8-merged` | accepted and already in `dev` | nothing |
+| `review-4` | the cycle limit is spent | stop, the owner decides |
 
-- **Frontend** (from repo root): `npm run typecheck`, `npm test` (node:test, 424 tests at v1.60.0), `npm run build`. After building, keep both committed snapshots in sync — `cp dist/houseplan-card.js custom_components/houseplan/frontend/` and `cp dist/houseplan-card.js demo/srv/assets/`. CI enforces both comparisons byte-for-byte.
-- **Backend HA-harness tests need Python 3.13, not the system 3.12.** Run them with the venv: `.venv-backend/bin/python -m pytest tests_backend/ -q` (150 tests at v1.60.0: 100 pure + 50 HA harness). Running `python3 -m pytest tests_backend` without Home Assistant silently **skips** the `test_ha_*.py` harness tests (`conftest.py` ignores them when `homeassistant` is not importable) and runs only the pure set.
-- **Running the app / smoke suite**: build a fresh bundle and copy it into the demo assets first — `npm run build && cp dist/houseplan-card.js demo/srv/assets/houseplan-card.js` — then run `node demo/smoke_*.mjs`. The committed demo snapshot must remain byte-identical to `dist` (CI checks it); rebuilding first also guarantees the browser suite tests the current source in an uncommitted worktree. No real Home Assistant server is required: `demo/srv/demo.html` stubs `hass`, registries and `callService`.
-- **Golden images**: `npm run golden:capture` and `npm run golden:verify` refuse a stale demo bundle. Build and copy the current bundle first, then review `artifacts/golden/actual/` and `diff/`. Update baselines only with `npm run golden:accept -- --reviewed`, using the complete Linux CI artifact; never accept a partial scenario or images merely to make CI green. See `demo/golden/README.md`.
-- **Freshness contract**: the embedded fingerprint covers `src/` plus Rollup, TypeScript and package-lock build inputs. Benchmark and golden tooling must call `assertFreshDemoBundle` before recording any result; a missing or mismatched fingerprint is a hard failure, not a warning.
-- **Demo harness render quirk**: the fake `hass` in `demo.html` is set once, so opening the page directly in a browser renders the floor plan but **device icons only appear after a re-render** (an F5 refresh, or nudging `card.hass = {...card.hass}`). The smoke launcher `demo/serve.mjs` already does this nudge; a plain browser session does not. This is a harness limitation, not a card bug.
-- **Known environment-sensitive smoke**: `demo/smoke_opening_measure.mjs` fails two sub-checks (`place_dialog_x_magnetised`, `place_committed_x_center`) under the pinned Chromium — a `1e-6`-tolerance magnet-snap on the opening-*placement* path. It reproduces against the pristine committed bundle, so treat it as pre-existing/pixel-precision, not a regression you introduced.
-- **Owner's local Windows checkout is invisible here.** Path
-  `C:\Users\Sergey\Downloads\dev\houseplan-dev` (workflow notes + often
-  unpushed edits) is **not mounted** into managed Cloud Agent VMs. Do not
-  expect to `ls` or diff that folder. To bring local work into the cloud
-  agent: push a branch to GitHub and say its name, or run a **local** Cursor
-  Agent / My Machines worker inside that checkout. Day-to-day source of truth
-  for cloud sessions remains **`origin/dev`** (minors) and **`origin/main`**
-  (releases) — see `docs/STATUS.md`.
+**After a review run the label always changes.** If it did not, the run itself
+failed rather than the work — say so to the owner instead of polling on.
+
+**A failed pre-release gate does not send the issue back to review.** The
+implementation loop runs only typecheck, unit and build; golden, browser smokes,
+performance and the full HA harness run before a beta, which is after the code
+review has passed and the issue sits in `S8-merged`. Some defects cannot surface
+any earlier.
+
+Fix it, re-run what failed, and a green run is enough for the release to continue.
+The issue stays in `S8-merged`. Record the **exact command and its result** in the
+issue — "verified" without a command proves nothing. Trailers as usual, and
+`User-Visible: yes` still means both changelogs in the same commit.
+
+The exception covers repairing the defect the gate named, not carrying on
+development under the name of a repair. It goes through the normal flow — a new
+issue, or back to `S6-in-progress` — if the fix changes a behaviour contract, gives
+the user something new, reaches a subsystem the task never touched, or is
+comparable in size to the task itself. And editing the gate so it stops failing is
+concealment, not repair; the exception is a defect proven to be **in the fixture**,
+as on #89, where the sun sat at azimuth 180° and the only window faced north, so no
+ray was ever built.
+
+Baselines are still accepted only via `npm run golden:accept -- --reviewed` on a
+complete Linux CI artefact. "So the gate goes green" is not a reason.
+
+The exchange happens in **issue comments** — there is no local message bus. Verdict
+format:
+
+```text
+Verdict: green/yellow/red · cycle r<N>/4 · High: N · Medium: N → #… · Document: …
+```
+
+High blocks. Medium must become its own issue. Low is fixed or waived with a note
+in the review document. A yellow verdict is legitimate even when every acceptance
+criterion passes, if the change does not solve the stated scenario or degrades a
+neighbouring one.
+
+**Four review cycles** (two on the light track). The counter lives in the document
+name, `-r1`…`-r4`; the fourth adds the `review-4` label. There is no fifth attempt:
+the owner splits the task, rejects it, or arbitrates.
+
+On the light track (`small`: complexity ≤3, one surface, no config migration, no
+new UX contract, no perf or touch impact — all at once) the spec lives in the issue
+body and the spec review is a comment. Code review is never skipped.
+
+## Specs
+
+`docs/specs/<NN>-<slug>.md`, linked to its issue in both directions. Required
+sections are in `PROCESS.md` §7.1, plus two product ones: which persona meets this,
+on which surface, at what moment; and what the person sees before and after, in one
+sentence without implementation terms.
+
+**Ambiguity is asked, not guessed — but only product ambiguity.** A guess written as
+fact is the worst kind of defect: it passes review because it looks like a decision.
+
+The owner answers exactly two kinds of question: **what a person sees or does**, and
+**how much user-visible change belongs in this issue**. Behaviour in a boundary case,
+which persona wins when two conflict, what counts as acceptable degradation, whether
+a neighbouring behaviour is in scope here or becomes its own issue.
+
+Everything a user cannot observe is yours to settle: where state is stored, which
+module carries the guard, naming, file layout, test strategy, migration mechanics,
+development policy. Decide it, record it in an explicit "assumed, change freely"
+block, and let the reviewer challenge it. A technical disagreement between author and
+reviewer is settled by the verdict, not by the owner; it reaches him only when the
+cycle limit is exhausted.
+
+Split a mixed question instead of escalating all of it. "Where does this state live"
+is technical. "Does it survive a page reload and follow the plan across screens" is
+product. Ask the second, decide the first.
+
+Ask in one batched issue comment, each question carrying a proposed default, and put
+`blocked` on top of `S3-spec` while waiting. A question with a default costs the
+owner seconds; one without costs him minutes.
+
+## Gates
+
+```
+npm run typecheck
+npm test
+npm run build
+npm run inventory        # the only correct way to get test counts
+```
+
+Never copy test counts into documents by hand; they go stale in days.
+
+After building, keep all three bundle snapshots in sync — CI compares them
+byte-for-byte:
+
+```
+cp dist/houseplan-card.js custom_components/houseplan/frontend/houseplan-card.js
+cp dist/houseplan-card.js demo/srv/assets/houseplan-card.js
+```
+
+During the implementation cycle only the fast gates run. `smoke`, `golden` and
+`performance_smoke` spin up Chromium and belong to the pre-beta run — which is then
+mandatory and complete.
+
+**Backend.** A full Home Assistant harness cannot run on native Windows at all:
+Home Assistant imports the Unix-only `fcntl` module. Its canon is Linux CI or WSL.
+Locally only the pure subset runs; `python -m pytest tests_backend/ -q` without
+Home Assistant **silently skips** `test_ha_*.py` (`conftest.py` ignores them when
+`homeassistant` is not importable), so a green result proves nothing. Say so in the
+report instead of claiming the backend was verified. Cloud agents have the harness
+at `.venv-backend/bin/python`.
+
+**Running the app / smoke suite**: build a fresh bundle and copy it into the demo
+assets first, then run `node demo/smoke_*.mjs`. No real Home Assistant server is
+required: `demo/srv/demo.html` stubs `hass`, registries and `callService`.
+
+**Golden images**: `npm run golden:capture` and `npm run golden:verify` refuse a
+stale demo bundle. Build and copy first, then review `artifacts/golden/actual/` and
+`diff/`. Update baselines only with `npm run golden:accept -- --reviewed`, using the
+complete Linux CI artifact; never accept a partial scenario or images merely to make
+CI green. See `demo/golden/README.md`.
+
+**Freshness contract**: the embedded fingerprint covers `src/` plus Rollup,
+TypeScript and package-lock build inputs. Benchmark and golden tooling must call
+`assertFreshDemoBundle` before recording any result; a missing or mismatched
+fingerprint is a hard failure, not a warning.
+
+**CI is pinned to an exact SHA.** The release gate accepts only a `completed
+success` run for the candidate's SHA, not "the last green one"; a new push cancels
+an unfinished Validate for the same branch. Jobs: `provenance`, `hacs`, `hassfest`,
+`frontend`, `smoke`, `golden`, `performance_smoke`, `backend`.
+
+**"Verified" without a named command and its result is not evidence.**
+
+## Environments
+
+**Local Windows checkout** is the day-to-day environment: Node 22 as in CI, Python
+3.13 in a venv, `gh` authenticated. `.venv-backend` does **not** exist there — it is
+provisioned only by cloud agent startup scripts, which also run `npm ci` and install
+Playwright Chromium.
+
+Known environment-sensitive smoke: `demo/smoke_opening_measure.mjs` fails two
+sub-checks (`place_dialog_x_magnetised`, `place_committed_x_center`) under the pinned
+Chromium — a `1e-6`-tolerance magnet-snap on the opening-*placement* path. It
+reproduces against the pristine committed bundle, so treat it as
+pre-existing/pixel-precision, not a regression you introduced.
+
+## Labs flags
+
+`src/labs.ts` is the single registry and resolver for hidden presentation
+experiments. Activate a live flag through `?hp-labs=<id>` or the shared hash
+grammar, remove it with `-<id>`, and use `off` to clear the set. Do not add a
+YAML/config switch for a Labs-only experiment. A new entry needs a unique
+lowercase id, issue, numeric-core `since`, numeric-core `expires`, summary and
+unit/browser coverage. Invalid or duplicate registry entries fail closed.
+
+Expiry is exclusive and ignores prerelease suffixes: an entry expiring at
+`1.65.0` is unavailable in `1.65.0-beta.1`. Before that cycle, either remove the
+experiment or graduate it through its own reviewed issue; never extend expiry as
+an incidental change. Labs may alter presentation only and must not gate data,
+migrations, stores, HA actions or network calls. Current renderer details are in
+`docs/ISOMETRIC.md`.
+
+Demo harness render quirk: the fake `hass` in `demo.html` is set once, so opening the
+page directly in a browser renders the floor plan but **device icons only appear
+after a re-render** (an F5 refresh, or nudging `card.hass = {...card.hass}`). The
+smoke launcher `demo/serve.mjs` already does this nudge; a plain browser session does
+not. This is a harness limitation, not a card bug.
 
 ## Promotion rule
 
@@ -69,3 +376,10 @@ stable release commit is promotion-only: version fields, generated bundle
 snapshots and changelog/release metadata. Do not add feature source code in
 that commit. An explicit owner-requested emergency hotfix is the only exception
 and must be called out in the release handoff.
+
+A `Release vX.Y.Z-beta.N candidate` commit is **not** promotion-only: it carries
+the work itself and follows the ordinary rules, trailers included.
+
+Issues are closed in a batch when a beta ships, not when implementation ends: that
+way a bug found in the beta returns to the same task, and the beta announcement can
+list what went in. Status labels are stripped as the issues close.

CONTRIBUTING.md

@@ -35,6 +35,7 @@ npm run typecheck         # tsc --noEmit (strict)
 npm test                  # node:test — pure logic, i18n parity, tap-action security
 npm run build             # tsc + rollup → dist/houseplan-card.js
 pip install pytest voluptuous && python -m pytest tests_backend -q   # pure backend tests
+npm install                # also installs .githooks through the prepare script
 ```
 
 The HA-harness backend tests (`tests_backend/test_ha_*.py`) need Python ≥3.13 and
@@ -50,7 +51,8 @@ every push — locally they are skipped when `homeassistant` is not importable.
 - The built card must be committed in sync: `cp dist/houseplan-card.js
   custom_components/houseplan/frontend/` (CI compares them byte-for-byte).
 - Tap actions have a security model (locks/alarms never toggle from the plan) —
-  see `resolveTapAction` in `src/logic.ts`; don't weaken it.
+  see `resolveToggleIntent` in `src/device-toggle.ts`; don't weaken it.
+- Every commit follows the issue and trailer contract in `PROCESS.md`.
 - Follow the Integration Quality Scale where applicable —
   `custom_components/houseplan/quality_scale.yaml` tracks the self-assessment.
 

PROCESS.md

@@ -0,0 +1,860 @@
+# Процесс работы над House Plan
+
+> **Статус документа: канон** (редакция 2026-08-13). Решения владельца, на
+> которых он стоит: прямые коммиты в `dev` **без PR** · канон статуса — **метки**,
+> имена английские · лёгкий трек **включён** · автор и ревьюер — разные модели ·
+> инфраструктурные задачи идут **вне** флоу.
+>
+> **Область действия:** обязателен для владельца и для любого агента. Читается
+> сразу после `docs/SCOPE.md` и `AGENTS.md`, до `docs/STATUS.md`. Живёт в
+> репозитории: до августа 2026 канон лежал только в папке владельца, и свежий клон
+> его не содержал вовсе.
+>
+> **Приоритет источников.** Канонический бэклог — GitHub Issues; статус живёт в
+> метках, Project v2 остаётся человеческим представлением. При расхождении
+> документации с GitHub побеждает GitHub. При расхождении этого документа с
+> `.github/workflows/*.yml` и `scripts/*` побеждает **фактическая автоматизация**:
+> она исполняется, а описание — нет. Расхождение при этом не игнорируется, а
+> заводится issue с меткой `process`.
+>
+> При расхождении процесса и привычки побеждает процесс.
+
+---
+
+## 1. Основное правило
+
+**Изменение продуктового кода без issue запрещено.** Код меняется только тогда,
+когда issue существует и находится в статусе «Готово к разработке» или дальше.
+Исключения — только §11, и каждое оставляет след.
+
+Правило работает лишь при точной границе «продуктового кода», иначе спор
+переносится на границу:
+
+| Класс | Что входит | Нужен ли issue |
+|---|---|---|
+| **A. Продукт** | `src/**`, `custom_components/houseplan/**/*.py`, `manifest.json`, `hacs.json`, `src/i18n/*.json`, `custom_components/**/translations/*` | **Да, обязательно.** Только из «Готово к разработке» или дальше |
+| **B. Гейты и инструменты** | `test/**`, `tests_backend/**`, `demo/**`, `scripts/**`, весь `.github/**`, `.githooks/**`, `rollup.config.mjs`, `tsconfig*.json`, `package.json`, `package-lock.json`, `pytest.ini`, `.gitignore`, `.gitattributes` | **Да.** Может использовать issue того изменения, которое покрывает; самостоятельная работа над гейтом получает свой issue (тип `tech-debt`) |
+| **C. Документация** | `docs/**`, `README*`, `CHANGELOG*`, `AGENTS.md`, `CONTRIBUTING.md`, `PROCESS*.md`, `LICENSE`, `(CODE\|SPEC)-REVIEW-*.md` | Документирование A/B в том же коммите — часть DoD своего issue. Самостоятельная работа над документацией — свой issue |
+| **D. Сгенерированное** | `dist/**`, `custom_components/houseplan/frontend/**`, `demo/srv/assets/houseplan-card.js`, `demo/golden/baselines/**` | Никогда не меняется само по себе. Коммит **только** класса D допустим лишь как релизный промоушен или как принятие эталонов с доказательством ревью |
+
+Практический смысл таблицы: «я только поправил тест» и «я только пересобрал
+бандл» перестают быть лазейками.
+
+Классы неупорядочены, но при пересечении путей **D сильнее A**: собранный бандл
+лежит внутри `custom_components/houseplan/frontend/`, и без этого правила он
+считался бы продуктовым исходником.
+
+**Инфраструктурная задача идёт вне флоу** (решение владельца 2026-08-13,
+issue #118). Признак механический: **ни одного файла класса A**. Такая задача
+делается без ТЗ, ревью ТЗ, код-ревью и без прохода по статусам — флоу построен
+для изменений, у которых есть персона и видимое поведение, а в инфраструктуре ТЗ
+пересказывало бы очевидное, и автор с ревьюером оказались бы одной ролью.
+Проверкой служат гейты и CI. Обязательным остаётся issue, трейлеры и зелёные
+`typecheck`, `test`, `build`.
+
+Задача, задевающая класс A хотя бы одним файлом, инфраструктурной **не
+является** и идёт полным флоу. «В основном инфраструктурная» не бывает: иначе
+это дорога, по которой продуктовые правки минуют ревью. Признак задан через
+класс файлов, а не через самоощущение исполнителя, именно поэтому.
+
+---
+
+## 2. Жизненный цикл
+
+Восемь рабочих статусов и два служебных. Фазы тестирования в цикле сознательно
+**нет**: найденные позже дефекты заводятся отдельными issue и проходят цикл
+заново. Issue закрывается после выпуска беты.
+
+```
+S1-new → S2-analysis → S3-spec → S4-spec-review ⟲ → S5-ready →
+       → S6-in-progress → S7-code-review ⟲ → S8-merged → закрыт при выпуске беты
+
+служебные:  blocked (поверх статуса)   rejected (закрыт)
+⟲ — возврат на правки, не более 4 циклов (§4), на лёгком и коротком треке 2
+короткий трек (`trivial`, §5.1) идёт S2-analysis → S5-ready, минуя S3 и S4
+```
+
+Переходы `S4-spec-review` и `S7-code-review` выполняются **автоматически**: метка
+порождает событие, событие запускает ревью (§10.4). Остальные ставит исполнитель.
+
+### 2.1 Новое — заведение задачи
+
+- **Кто:** любой — владелец, агент, пользователь (Telegram, GitHub).
+- **Вход:** проблема в пользовательских терминах; как проявляется или зачем нужно.
+  Решение **не требуется** и не приветствуется.
+- **Запрещено:** ставить приоритет, оценивать, писать ТЗ, начинать код.
+
+### 2.2 Аналитика и оценка
+
+Задача разбирается, продуктовое «да» ещё не дано.
+
+- **Кто:** агент-аналитик готовит, владелец решает.
+- **Чек-лист**, результат — комментарием в issue:
+  1. дубликаты проверены (ссылки на похожие issue);
+  2. в скоупе по `docs/SCOPE.md` и `docs/TOUCH-SUPPORT.md`;
+  3. **пользовательская ценность 1–10** и **ценность для разработки** — что
+     упрощает или разблокирует;
+  4. **сложность и риск 1–10** — трудоёмкость плюс вероятность задеть смежное;
+  5. приоритет **P1/P2/P3**;
+  6. тип: баг / фича / техдолг;
+  7. затронутые поверхности (модули, диалоги, бэкенд, i18n);
+  8. лёгкий трек — да/нет по критериям §5.
+- **Приоритет и ценность — поля владельца.** Агент предлагает, владелец
+  утверждает; иначе агенты приоритизируют сами и P1 разрастается.
+- **Выход:** «ТЗ в работе» либо «Отклонено» с записанной причиной.
+
+### 2.3 ТЗ в работе — написание ТЗ
+
+- **Кто:** автор ТЗ, назначает себя. Статус означает «занято».
+- **Артефакт:** `docs/specs/<NN>-<slug>.md`, где `NN` — **номер issue**.
+  Многоэтапная задача: `<NN>-<slug>-stage<N>.md`.
+- **Лёгкий трек:** ТЗ пишется в теле issue, файл не создаётся (§5).
+- **Выход:** полная первая редакция по §7.
+
+### 2.4 ТЗ на ревью
+
+- **Ревьюер ≠ автор.** Ревьюер получает issue и ТЗ, без устных пояснений автора.
+  Его задача — не согласиться, а найти, где ТЗ не выполнимо или не проверяемо.
+- **Артефакт:** `docs/reviews/SPEC-REVIEW-<NN>-r<N>.md`, вердикт
+  зелёный / жёлтый / красный. Лёгкий трек — комментарий в issue.
+- **High-находки блокируют.** Medium/Low — либо правятся, либо становятся
+  отдельными issue со ссылкой; «оставили в тексте ревью» не считается закрытием.
+- **Выход:** «Готово к разработке» либо возврат в «ТЗ в работе» — не более
+  4 циклов (§4).
+
+### 2.5 Готово к разработке (DoR)
+
+Не работа, а **очередь**: единственный статус, из которого можно трогать код.
+Все пункты обязательны:
+
+- ТЗ существует, ревью ТЗ зелёное, ссылки issue ↔ ТЗ на месте;
+- **AC1…ACn** — пронумерованные проверяемые критерии приёмки; у каждого указано,
+  чем он доказывается: `unit` / `backend` / `smoke` / `golden` / «ревью кода»;
+- перечислены затронутые файлы и модули;
+- i18n: ключи en + ru перечислены;
+- миграция и compatibility-поля решены по `docs/CONFIG-COMPATIBILITY.md`;
+- влияние на производительность и бюджеты названо (или явно «нет»);
+- влияние на touch по `docs/TOUCH-SUPPORT.md` (View и киоск — блокирующие);
+- release-артефакты по правилу `docs/specs/README.md` (changelog RU+EN,
+  документация, golden/скриншоты, performance/security);
+- **откат**: как выключить или вернуть назад (флаг Labs, обратная миграция);
+- открытых продуктовых вопросов нет; риски перечислены.
+
+Если хоть один пункт не выполнен — статус не «Готово к разработке», как бы ни
+хотелось начать.
+
+### 2.6 В разработке — реализация
+
+- **Занятие (claim):** назначить себя, поставить метку, комментарий
+  «Взял: <роль> · сессия <id> · ветка `issue/<NN>-<slug>`».
+- **WIP-лимиты:** не более **1** issue в «В разработке» на исполнителя, не более
+  **3** одновременно на цикл релиза, не более **2** в «Код-ревью».
+- **Трассируемость:** ветка `issue/<NN>-<slug>`; каждый коммит несёт трейлеры
+  `Issue: #<NN>` и `User-Visible: yes|no`.
+- **Автотесты — часть реализации, а не отдельная фаза.** Каждый AC, помеченный
+  `unit`/`backend`/`smoke`/`golden`, получает свою проверку здесь же.
+  «Тестирование вне жизненного цикла» означает отсутствие фазы ручного
+  тестирования, а не отсутствие тестов.
+- **Скоуп не расширяется.** Найденное по пути становится новым issue в «Новое».
+  Если находка блокирует — текущий issue уходит в «Заблокировано» со ссылкой.
+  Попутных правок «раз уж я здесь» не бывает.
+- **Документация — в том же коммите,** что и поведение (действующая политика
+  `docs/STATUS.md`): changelog RU+EN для пользовательского, `STATUS.md` для
+  состояния, `DEVELOPMENT.md` для новых грабель, `ARCHITECTURE.md` для дизайна.
+- **Выход:** локальный гейт зелёный (§8), хендофф-комментарий (§7.2).
+
+### 2.7 Код-ревью
+
+- **Ревьюер ≠ исполнитель**, свежая сессия без контекста реализации.
+- **Артефакт:** `docs/reviews/CODE-REVIEW-<tag|NN>-r<N>.md` в действующем
+  формате: скоуп, как проверялось (таблица гейтов с результатами), находки
+  High/Medium/Low с воспроизведением, что проверено и корректно, чего не проверял.
+- **Ревьюер отвечает за AC.** Раз ручного тестирования в цикле нет, именно ревью
+  кода отвечает на вопрос «оно вообще работает»: каждый AC либо доказан
+  автотестом — и ревьюер убедился, что **тест умеет падать**, — либо разобран по
+  коду с явной записью «проверено чтением, не исполнением».
+- **High блокируют.** Medium **обязаны** превратиться в issue.
+- **Выход:** очередь на пре-релиз либо возврат в «В разработке», не более
+  4 циклов (§4).
+
+### 2.8 Закрытие после выпуска беты
+
+- **Вход:** изменение вошло в опубликованную бету/RC, CI Validate зелёный на
+  **точном SHA** тега (промоушен-правило: ни одна фича не попадает в стабильный
+  релиз, не побывав в бете).
+- **Закрывает** релиз-менеджер, не исполнитель. Комментарий закрытия: тег беты,
+  ссылка на прогон CI, ссылка на бюллетень changelog.
+- **Стабильный релиз статусов не двигает** — issue уже закрыты; релизный коммит
+  promotion-only, changelog ссылается на закрытые issue.
+- **Что приходит потом:** дефект, найденный на стенде, дома или пользователем, —
+  **новый issue** типа «баг» со ссылкой на исходный. Исходный не переоткрывается.
+
+### 2.9 Заблокировано / Отклонено
+
+- **Заблокировано:** обязательна ссылка на блокирующий issue или внешнюю причину
+  и дата пересмотра. Без причины статус не ставится.
+- **Отклонено:** закрытие с записанной причиной (вне скоупа, дубликат, цена не
+  оправдана). Тихое закрытие без причины запрещено.
+
+---
+
+## 3. Правила
+
+Продолжение черновика владельца. Каждое правило проверяемо — глазами или машиной.
+
+1. **Никаких изменений в код, если нет issue** и он не помечен «Готово к
+   разработке» или дальше.
+2. **Issue не может быть взят в разработку**, пока у него нет ТЗ с зелёным ревью,
+   пронумерованных AC с указанием доказательства и назначенного исполнителя.
+3. **Issue не может быть взят дважды.** Занятие фиксируется назначением, меткой и
+   комментарием с именем ветки. У одного исполнителя одновременно не более одного
+   issue в разработке.
+4. **Статус меняется до действия, а не после.** Взял — поставил метку; отдал на
+   ревью — поставил метку. Метка, поставленная задним числом, — дефект процесса.
+5. **Ровно одна метка статуса** на issue в любой момент. Ноль или две — дефект,
+   еженедельная гигиена его показывает.
+6. **Автор не ревьюит своё** — ни ТЗ, ни код. Никто не переводит свою работу через
+   ревью-гейт.
+7. **Ревью возвращает не более 4 раз.** Пятый заход — решение владельца: разделить,
+   отклонить или арбитраж (§4).
+8. **High блокирует. Medium становится issue.** Low либо правится, либо снимается
+   решением ревьюера с записью в документе.
+9. **Скоуп не расширяется.** Всё найденное вне ТЗ — новый issue, а не попутная
+   правка. Блокирующая находка отправляет текущий issue в «Заблокировано».
+10. **Каждый коммит класса A и B несёт трейлер `Issue: #NN`**, ветка называется
+    `issue/NN-slug`, а `User-Visible: yes` требует правок в **обоих** changelog в
+    том же коммите.
+11. **Документация — в том же коммите, что поведение.** Отдельным «допишу потом»
+    коммитом документация не бывает.
+12. **Сгенерированное не коммитится само по себе.** Только релизный промоушен или
+    принятие эталонов со ссылкой на прогон CI.
+13. **Golden-эталоны принимаются только** `npm run golden:accept -- --reviewed` по
+    полному Linux-артефакту. Принятие ради зелёного CI — нарушение процесса.
+14. **Issue закрывается после выпуска беты** с зелёным CI на точном SHA. Не
+    раньше, не «по факту наличия кода», не исполнителем.
+15. **Закрытый issue не переоткрывается.** Новый дефект — новый issue со ссылкой.
+16. **Стабильный релиз — promotion-only:** версии, сгенерированные бандлы,
+    changelog и release-метаданные. Продуктового кода там нет.
+17. **История `dev` не перезаписывается.** На неё ссылаются теги. Нарушение
+    исправляется следующим коммитом плюс issue с меткой `process` — не
+    force-push'ем.
+18. **AC доказывает автотест или запись ревьюера.** Фразы «проверил локально, всё
+    работает» в процессе не существует: либо тест, который умеет падать, либо
+    честное «проверено чтением, не исполнением».
+19. **Параллельных бэклогов нет.** Планы, разборы и приоритеты живут в issue;
+    файловые отчёты — разовые и датированные.
+20. **Аварийный хотфикс — только решением владельца** и только по §11.2.
+
+---
+
+## 4. Лимит циклов ревью: 4
+
+Оба ревью-гейта возвращают задачу на правки не более **4 раз**. Счётчик виден в
+имени документа: `-r1` … `-r4`; на четвёртом заходе ставится метка `review-4`.
+
+- **Что считается циклом:** отправка на ревью → вердикт с блокирующими находками
+  → возврат. Уточняющий вопрос без вердикта циклом не считается.
+- **Исчерпание лимита — не «пятая попытка», а разбор.** Задача уходит владельцу,
+  решение одно из трёх:
+  1. **разделить** — issue закрывается как «заменён», вместо него 2–3 меньших с
+     ясным скоупом (частый настоящий диагноз: ТЗ было слишком большим);
+  2. **отклонить** — цена решения оказалась выше ценности;
+  3. **арбитраж владельца** — владелец фиксирует решение в issue, оно принимается
+     как есть; несогласие ревьюера записывается, но не блокирует.
+- **Граница между «циклом» и «новым багом»:** до закрытия беты находка ревьюера —
+  возврат на правки; после закрытия — новый issue. Иначе лимит 4 обходится
+  заведением issue вместо возврата.
+- Для лёгкого трека лимит ревью ТЗ — **2** цикла: задача на три часа, которую
+  переписывают трижды, лёгкой не была.
+
+---
+
+## 5. Лёгкий трек (метка `small`)
+
+**Критерии — все одновременно:**
+
+- сложность и риск ≤ 3;
+- одна поверхность (один диалог, один модуль, один эндпоинт);
+- нет миграции конфига и новых compatibility-полей;
+- нет нового UX-контракта — меняется поведение в рамках уже описанного;
+- нет влияния на производительность и на touch-контракт.
+
+**Что упрощается:**
+
+- ТЗ пишется **в теле issue** по шаблону: проблема · контракт · AC1…ACn с
+  доказательством · откат. Файл в `docs/specs/` не создаётся;
+- ревью ТЗ — комментарий второго агента, отдельный документ не нужен;
+- лимит ревью ТЗ — 2 цикла.
+
+**Что не упрощается:** issue, оценка, статусы, трейлеры коммитов, changelog,
+**код-ревью и его документ**, закрытие после беты. Код-ревью не пропускается
+никогда — именно оно в этом процессе заменяет тестирование. Единственное
+исключение — починка упавшего предрелизного гейта, §11.4.
+
+Если по ходу выясняется, что критерий нарушен (появилась миграция, задело второй
+модуль) — метка `small` снимается, issue возвращается в `S3-spec` и получает
+нормальный файл ТЗ. Это не провал, это ранняя диагностика.
+
+### 5.1 Короткий трек (метка `trivial`)
+
+Решение владельца 2026-08-13, issue #128. Лёгкий трек делает ТЗ дешёвым; короткий
+обходится без него совсем.
+
+**Маршрут:** `S1-new` → `S2-analysis` → `S5-ready` → `S6-in-progress` →
+`S7-code-review` → `S8-merged`. Стадии `S3-spec` и `S4-spec-review` пропускаются.
+
+`S2-analysis` остаётся: это комментарий, а не прогон CI, и именно там владелец
+решает приоритет и ценность. AC пишет автор в теле issue при переводе в
+`S5-ready` — до перехода, иначе ревьюеру нечего будет сверять.
+
+**Критерии, все обязательны:**
+
+- тип `bug`;
+- правка ограничена одной поверхностью, нового UX-контракта нет;
+- нет миграции конфига, новых ключей i18n, влияния на перф и touch;
+- AC выражаются тремя проверяемыми утверждениями или меньше;
+- **ожидаемое поведение уже зафиксировано** — в `docs/USER-GUIDE.ru.md`, в
+  каноническом документе подсистемы либо однозначно в самом отчёте. Решать нечего.
+  Если есть что решать, это `S3-spec`, и никакая экономия этого не отменяет.
+
+Метка ставится в `S2-analysis` вместе с остальными оценками, одним комментарием,
+где владелец утверждает и приоритет.
+
+**Что не упрощается:** issue, оценка, статусы, трейлеры, changelog и **код-ревью**.
+Лимит циклов код-ревью — 2, как на лёгком треке.
+
+Если по ходу выясняется, что критерий нарушен, метка снимается и issue уходит в
+`S3-spec` за нормальным ТЗ. Как и на лёгком треке, это не провал, а ранняя
+диагностика.
+
+**Чем этот трек опасен.** Он убирает единственное место, где решение проверялось
+до написания кода. Признак «решать нечего» держит всю конструкцию, и его нельзя
+подтверждать ощущением — только ссылкой на уже зафиксированное поведение.
+
+---
+
+## 6. Роли
+
+Один агент может исполнять несколько ролей в разных issue, но **не две роли в
+одном артефакте**.
+
+| Роль | Делает | Не имеет права |
+|---|---|---|
+| Аналитик | разбор, оценки, поверхности | окончательно ставить приоритет |
+| Автор ТЗ | `docs/specs/NN-*.md` или ТЗ в issue | ревьюить своё ТЗ |
+| Ревьюер ТЗ | `docs/reviews/SPEC-REVIEW-NN-rN.md` | править ТЗ вместо автора |
+| Разработчик | код, автотесты, документация, changelog | ревьюить свой код, принимать golden |
+| Ревьюер кода | `docs/reviews/CODE-REVIEW-*-rN.md`, проверка AC | править продуктовый код |
+| Релиз-менеджер | пре-релиз, стабильный релиз, закрытие issue | добавлять код в релизный коммит |
+| Владелец | приоритет, ценность, скоуп, отклонение, арбитраж, хотфикс | — |
+
+**Правило разделения:** ревьюер работает состязательно. Ему передаётся тег или
+диапазон коммитов и ТЗ — не рассказ автора о том, как всё хорошо.
+
+**Роли закреплены за исполнителями** (решение владельца 2026-08-12):
+
+| Исполнитель | Роли |
+|---|---|
+| **Codex** | аналитик, автор ТЗ, разработчик, релиз-инженер по команде владельца |
+| **Claude** | ревьюер ТЗ, ревьюер кода, вся инфраструктура и дистрибуция |
+| **Владелец** | приоритет, скоуп, арбитраж, закрытие issue, команда на выпуск |
+
+Автор и ревьюер — **разные модели**, и это сильнее требования «другая сессия»:
+одна модель, читая свой же артефакт заново, повторяет свои же слепые пятна.
+
+Ревью ТЗ и код-ревью держатся в **разных сессиях** Claude: ревьюер кода не должен
+приходить с контекстом того, как обсуждали ТЗ.
+
+---
+
+## 7. Артефакты и трассируемость
+
+### 7.1 Цепочка
+
+```
+issue #NN
+  ↔ ТЗ            docs/specs/NN-slug.md              (или тело issue при `small`)
+  ↔ ревью ТЗ      docs/reviews/SPEC-REVIEW-NN-rN.md  (или комментарий при `small`)
+  ↔ ветка         issue/NN-slug
+  ↔ коммиты       трейлеры  Issue: #NN · User-Visible: yes|no
+  ↔ ревью кода    docs/reviews/CODE-REVIEW-<tag|NN>-rN.md
+  ↔ changelog     бюллетень RU+EN со ссылкой на #NN
+  ↔ бета          тег, зелёный CI на точном SHA → закрытие
+```
+
+Обязательные разделы ТЗ: **сценарий** · **что человек увидит до и после** ·
+проблема · скоуп и **не-скоуп** · контракт поведения · UX · модель данных и
+миграция · i18n · критерии приёмки AC1…ACn с указанием доказательства · план
+автотестов · риски · откат · release-артефакты.
+
+Два первых раздела — продуктовые, и они идут первыми не случайно. **Сценарий:**
+какая персона (`docs/SCOPE.md`), на какой поверхности, в какой момент это
+встретит. **Что человек увидит:** одной фразой, без терминов реализации. ТЗ,
+которое не может ответить на эти два вопроса, описывает работу, а не изменение
+продукта.
+
+**Размытое место не додумывается, а выносится владельцу.** Догадка, записанная
+как факт, — худший вид дефекта: она проходит ревью, потому что выглядит решением.
+
+Но спрашивать обо всём нельзя: владелец один, и анкета из двадцати пунктов хуже
+угадывания. Порог такой (решение владельца 2026-08-13).
+
+**Владельцу задаются только продуктовые вопросы** — что человек видит или делает
+и какой объём видимых изменений входит в этот issue. Поведение в пограничном
+случае; какая из персон важнее в конфликте; что считать приемлемой деградацией;
+относится ли смежное поведение сюда или становится отдельной задачей.
+
+**Всё, чего пользователь не наблюдает, агенты решают сами** либо согласовывают
+между собой: где хранится состояние, в каком модуле стоит гвард, именование,
+раскладка файлов, стратегия тестов, механика миграции. Решение записывается явным
+блоком в конце ТЗ — «принято предположительно, поменять свободно», и ревьюер
+вправе его оспорить. Технический спор автора и ревьюера решается вердиктом, а не
+владельцем; до него он доходит только при исчерпании лимита циклов (§4).
+
+**Смешанный вопрос делится, а не эскалируется целиком.** «Где живёт это
+состояние» — техническое. «Переживает ли оно перезагрузку страницы и общее ли оно
+для всех экранов» — продуктовое.
+
+Вопросы задаются **одним комментарием, пачкой**, каждый в форме: что неясно ·
+что изменится от ответа · **предлагаемый вариант по умолчанию**. Вопрос с готовым
+вариантом стоит владельцу пяти секунд, вопрос без него — пяти минут. Пока ждём
+ответа, issue остаётся в `S3-spec` и получает `blocked`: статус не подменяется,
+`blocked` его дополняет, иначе конвейер считает задачу в работе, а она стоит.
+
+### 7.2 Шаблоны комментариев
+
+Короткие и однообразные, чтобы читались и человеком, и машиной.
+
+- **Аналитика:** `Оценка: ценность N/10 · сложность N/10 · P<1-3> · тип ·
+  поверхности: … · дубликаты: … · лёгкий трек: да/нет`
+- **Занятие:** `Взял: <роль> · сессия <id> · ветка issue/NN-slug`
+- **Хендофф:** `Сделано: … · Файлы: … · Гейты: <команда → результат> ·
+  НЕ сделано: … · Риски: … · Следующий статус: … · Новые issue: #…`
+- **Вердикт ревью:** `Вердикт: зелёный/жёлтый/красный · цикл r<N>/<лимит> ·
+  High: N · Medium: N → #… · Документ: docs/reviews/…`
+- **Закрытие:** `Выпущено в <тег беты> · CI: <ссылка> · Changelog: <ссылка>`
+
+**Вперёд двигает только зелёный вердикт.** Жёлтый и красный возвращают автору;
+разница между ними содержательна для человека, но не для маршрута. Первая
+редакция конвейера (§10.4) пропускала жёлтый при `High: 0`, и первый же живой
+прогон показал, почему это неверно: жёлтый там означал, что AC описывает неверное
+изменение контракта — реализовать такое ТЗ значило бы сделать ошибку по инструкции.
+
+### 7.3 Расхождения с текущим состоянием, которые надо закрыть
+
+1. **Статус ТЗ дублирует статус issue.** `docs/specs/README.md` держит колонку
+   «Статус ТЗ» со своим словарём («черновик решения», «в реализации»,
+   «реализовано»). Два источника статуса уже расходятся. Колонку убрать, оставить
+   таблицу «issue ↔ ТЗ».
+2. **Ревью до релиза 1.62 живут вне репозитория.** Документы `CODE-REVIEW-*.md` и
+   `SPEC-REVIEW-*.md` за прежний период лежат в папке владельца, и переносить их
+   задним числом смысла нет: они описывают код, которого уже нет. Новые документы
+   ревью кладёт в `docs/reviews/` сам конвейер, в ветку задачи.
+
+---
+
+## 8. Гейты
+
+**Локальный гейт перед выходом из «В разработке»** — минимальный набор,
+покрывающий изменённые поверхности (действующее правило владельца):
+
+```
+npx tsc --noEmit
+npm test
+npm run build && cmp dist/houseplan-card.js custom_components/houseplan/frontend/houseplan-card.js \
+              && cmp dist/houseplan-card.js demo/srv/assets/houseplan-card.js
+node demo/smoke_<целевые>.mjs
+npm run golden:verify                 # если менялся визуал
+python -m pytest tests_backend -q     # py3.13, если менялся бэкенд
+```
+
+**Объём гейтов на код-ревью соразмерен задаче** (issue #127). Всегда:
+`typecheck`, `npm test`, `npm run build` со сверкой трёх копий бандла. По
+необходимости, определяемой diff'ом и AC: браузерные смоки (их 127 — прогон всех
+уместен только когда задача задевает всё), `golden:verify` при изменении видимого
+результата, `pytest tests_backend` при правках в Python, performance-профили при
+названном в AC влиянии. **Полные наборы — предрелизный гейт, а не гейт ревью.**
+
+Условие честности такого сужения: ревьюер обязан перечислить, какие гейты прогнал,
+какие нет и почему. Непрогнанный гейт становится видимым решением, а не молчаливым
+пропуском.
+
+**Гейт беты** (условие закрытия issue): CI Validate зелёный на точном SHA тега.
+
+Часть гейтов запускается только здесь, то есть **после** пройденного код-ревью.
+Упавший предрелизный гейт автор чинит и повторно прогоняет; зелёный прогон
+достаточен для продолжения релиза, повторное код-ревью не требуется — §11.4.
+
+**Гейт стабильного релиза:** полный локальный прогон плюс Validate и Full
+Performance зелёные на точном SHA; статусов issue не касается.
+
+---
+
+## 9. Метки — канонический статус
+
+Статус читается из меток: их видно в списке issue и их читает любой токен с
+доступом к Issues, в отличие от Project v2, который требует отдельного скоупа.
+Project v2 остаётся человеческим представлением и синхронизируется по меткам.
+
+**Имена меток английские** (решение владельца 2026-08-12). Русские имена в этом
+документе были только на бумаге; репозиторий с самого начала жил на английских.
+
+| Метка | Статус |
+|---|---|
+| `S1-new` | Новое, не разобрано |
+| `S2-analysis` | Аналитика и оценка |
+| `S3-spec` | ТЗ в работе |
+| `S4-spec-review` | ТЗ на ревью |
+| `S5-ready` | Готово к разработке — единственный статус, из которого можно начать трогать код |
+| `S6-in-progress` | В разработке, занято исполнителем |
+| `S7-code-review` | Код-ревью |
+| `S8-merged` | Ревью пройдено, код в `dev`, ждёт беты. Issue закрывается пачкой при выпуске |
+| `blocked` | Ждём внешнего или владельца, **поверх** статусной метки |
+| `rejected` | Отклонено, issue закрыт |
+
+Модификаторы: `small` (лёгкий трек, сложность ≤3), `trivial` (короткий трек,
+§5.1), `hotfix`, `process`, `review-4`; приоритет `P1`/`P2`/`P3`; тип `bug`/`feature`/`tech-debt`.
+Тематические метки (`polish`, `infra`, `tests`, `docs`, `security`, `vacuum`)
+ортогональны процессу.
+
+Инварианты: **ровно одна `S*`-метка** на открытом issue; закрытый issue статусных
+меток не несёт; `blocked` не заменяет статус, а дополняет его.
+
+**Чужой issue берётся в работу так же, как свой — после явного решения
+владельца** (решение владельца 2026-08-13, уточнено в тот же день). Репозиторий
+публичный, отчёты заводят и посторонние; проверка стоит **на входе**, а не на
+каждом шаге.
+
+Входом служит присвоение первой статусной метки: пока меток нет, issue вне
+процесса и инварианты на него не распространяются. Как только метка стоит, задача
+в работе, и **кто её завёл, дальше не имеет значения** — статусы, ревью и лимиты
+работают одинаково.
+
+Присвоение метки и есть то самое явное решение, причём проверенное платформой:
+метки может ставить только тот, у кого есть право записи в репозиторий. Прежняя
+редакция требовала переоформлять чужой отчёт своим issue со ссылкой на исходный;
+это оказалось работой впустую — на #123 к моменту отказа ТЗ уже было написано.
+
+`S8-merged` появился позже остальных и закрывает разрыв, который раньше
+закрывался памятью человека: код принят, но бета ещё не вышла, и issue закрывать
+рано. Без него принятая задача либо висела в `S7-code-review`, либо закрывалась
+досрочно.
+
+---
+
+## 10. Механизация при прямых коммитах в `dev`
+
+Решение владельца — работать без PR. Значит, GitHub не может ничего заблокировать
+на своей стороне: **основной гейт переезжает на клиента, CI остаётся страховкой.**
+
+### 10.1 Хуки, которые невозможно забыть поставить
+
+`.githooks/` в репозитории, `core.hooksPath` выставляется автоматически при
+установке зависимостей:
+
+```json
+"scripts": { "prepare": "node scripts/install-hooks.mjs" }
+```
+
+`npm ci` вызывает `prepare` сам — значит, хуки появляются в каждом окружении,
+включая свежий контейнер облачного агента, без отдельного шага в инструкции.
+
+- **`commit-msg`** — есть, работает. Отклоняет коммит без терминального
+  `Issue: #NN`, требует ровно один `User-Visible: yes|no`, а для коммитов,
+  трогающих `demo/golden/baselines/**`, — `Release:` плюс `Baseline-Reviewed:`.
+  Реализация — `scripts/validate-commit-provenance.mjs`, тот же скрипт вызывается
+  job `provenance` в `validate.yml`.
+- **`pre-push`** — есть, работает. Прогоняет `scripts/process-gate.mjs` по каждому
+  пушимому ref и останавливает push при нарушении. Это и есть блокирующий гейт
+  вместо PR. Удаление ветки и теги пропускаются: в первом случае проверять нечего,
+  во втором коммит уже проверен, когда его пушили. Для новой ветки диапазон
+  считается от `merge-base` с `origin/dev`, а не от начала истории — иначе в него
+  попали бы все нарушения, совершённые до появления гейта.
+
+  Проверка статуса issue требует `gh`, поэтому при его отсутствии хук печатает
+  предупреждение и выполняет только офлайн-часть. Это сознательная уступка: хук,
+  который не работает в самолёте, отключают целиком, а строгий проход всё равно
+  делает CI.
+
+**Хук обязан быть исполняемым, и это тише всего ломается.** Git **молча** не
+запускает файл без бита `+x`: гейт сообщает об успехе тем, что его нет. Проверено
+на настоящем push — при `644` от гейта ноль строк и push проходит, при `755` он
+останавливается.
+
+Через GitHub API режим не выставляется: файл, отправленный так, приезжает
+`100644`. Поэтому `scripts/install-hooks.mjs` восстанавливает бит при каждой
+установке зависимостей, а `assertHookMode` дополнительно проверяет бит
+`.githooks/commit-msg` в индексе. Правится вручную:
+`git update-index --chmod=+x .githooks/<хук>`.
+
+### 10.2 Что проверяет `process-gate.mjs`
+
+Реализовано, `scripts/process-gate.mjs`, issue #105. Офлайн, без GitHub API:
+
+1. трейлер `Issue: #NN` у каждого коммита класса A/B, допускается несколько;
+2. имя ветки `issue/NN-slug` соответствует трейлерам;
+3. для класса A существует `docs/specs/NN-*.md` — **или** issue помечен `small`.
+   Офлайн это предупреждение: лёгкий трек держит ТЗ в теле issue, и без чтения
+   меток «ТЗ в issue» неотличимо от «ТЗ не написано». С `--issues` — отказ;
+4. `User-Visible: yes` → правки в обоих changelog в том же коммите;
+5. коммит только класса D невалиден без `Release: vX.Y.Z` либо
+   `Baseline-Reviewed: <ссылка на прогон CI>`;
+6. релизный коммит не содержит изменений в `src/` и `custom_components/**/*.py`;
+7. документов ревью на один issue не больше четырёх (`-r1`…`-r4`).
+
+С токеном GitHub:
+
+8. `--issues` тянет каждый упомянутый issue и требует метку из
+   {`S5-ready`, `S6-in-progress`, `S7-code-review`, `S8-merged`}; закрытый,
+   недоступный или помеченный `blocked` — отказ (**fail closed**).
+
+ Три оговорки к проверке 8 выяснились при реализации.
+
+**`S8-merged` входит в множество**, хотя по смыслу задача уже принята. Причина
+механическая: конвейер (§10.4) сливает ветку в `dev` **раньше**, чем ставит метку,
+Validate стартует от этого push и успевает прочитать issue уже в `S8-merged`.
+Строгое множество красило бы каждую принятую задачу. Локальная строгость
+возвращается флагом `--no-merged`.
+
+**Статус спрашивается только у коммитов класса A/B.** Правило №1 говорит о
+продуктовом коде и инструментах, а не о документации. Иначе краснел бы каждый
+документ ревью: он ложится в ветку задачи, пока та в `S4-spec-review` или
+`S7-code-review`, то есть заведомо вне рабочего множества.
+
+**При продвижении в `main` не перепроверяются коммиты, уже достижимые из
+prerelease-тега.** После выпуска беты их issue по §2.8 должны быть закрыты, а
+stable fast-forward снова включает эти коммиты в диапазон `old-main..candidate`.
+Pre-push передаёт целевую remote ref через `--target-ref`, а Validate — через
+`TARGET_REF`; оба исключают только уже опубликованную prerelease-историю. Любой
+post-beta коммит остаётся в проверке и по закрытому issue отклоняется fail-closed.
+
+Не реализовано и остаётся долгом:
+
+9. `npm run release:prerelease -- --issues=…` не проверяет, есть ли у issue
+   зелёный вердикт код-ревью;
+10. закрытие issue и снятие статусных меток при публикации беты делаются руками —
+    `node process-labels/apply.mjs cleanup --apply`, а не `publish-prerelease.yml`.
+    Пропуск этого шага уже ломал инвариант «закрытый issue без статусной метки».
+
+### 10.3 Страховка и разбор
+
+- **`process-gate.mjs` — job `process-gate` в `validate.yml`**, без `needs`:
+  краснеет сам и не роняет остальные. При прямом push проверка догоняющая: код уже
+  в `dev`, CI краснеет после. Это принятая цена отказа от PR: `pre-push` ловит
+  нарушение до отправки, а этот job — то, что прошло мимо хука, включая
+  `--no-verify` и окружение без установленных зависимостей.
+- **Нарушение не откатывается force-push'ем** (правило 17): исправляющий коммит
+  плюс issue с меткой `process`. Починить надо проверку, а не только симптом.
+- **Еженедельная гигиена** (workflow): issue в `S1-new` дольше 14 дней и в
+  `S6-in-progress` дольше 7; issue класса A в `S5-ready` без ТЗ; issue с нулём или
+  двумя `S*`-метками; коммиты без трейлера за неделю — **цель 0**; rework rate и
+  число issue, дошедших до `review-4`; **баги, заведённые после закрытия беты** —
+  прямая цена отказа от фазы тестирования.
+
+### 10.4 Событийный конвейер: метка как триггер
+
+`.github/workflows/process.yml`, issue #114. Смена статусной метки — не запись в
+журнал, а **сообщение**: она порождает событие, событие запускает следующий шаг.
+
+```
+S4-spec-review → ревью ТЗ  → S5-ready  либо возврат в S3-spec
+S7-code-review → код-ревью → слияние в dev → S8-merged либо возврат в S6-in-progress
+```
+
+Ревьюер — `anthropics/claude-code-action`. Он читает `docs/SCOPE.md`, `AGENTS.md`,
+этот документ и тело issue, публикует разбор комментарием, заводит issue на каждую
+Medium-находку, кладёт документ в `docs/reviews/` ветки задачи и возвращает вердикт
+структурированным JSON. **Метку переставляет отдельный детерминированный шаг по
+вердикту, а не модель.**
+
+Четыре вещи, без которых конвейер молча не работает:
+
+1. метки переставляет **PAT**, а не `GITHUB_TOKEN`: GitHub намеренно не порождает
+   события от `GITHUB_TOKEN`, чтобы не было циклов, и цепочка обрывалась бы после
+   первого шага без ошибок в логах;
+2. `process.yml` обязан лежать в **ветке по умолчанию**: для события `issues`
+   GitHub берёт workflow только оттуда, независимо от содержимого `dev`;
+3. слияние в `dev` происходит **до** простановки `S8-merged`, иначе метка врёт в
+   промежутке — она утверждает, что код в `dev`;
+4. многострочный текст внутри `run:` — только через heredoc: строка с нулевым
+   отступом обрывает блок YAML, и скрипт обрезается без ошибки парсера.
+
+**Автор обязан дождаться вердикта, а не заканчивать сессию.** Ревью идёт от десяти
+минут до сорока пяти. Отчёт «передал на ревью» останавливает конвейер там, где он
+мог идти сам: вердикт придёт, а подхватить его будет некому. У агента нет часов —
+он существует только в момент своего хода, поэтому ожидание это опрос: раз в 90
+секунд, не более 30 попыток. Смотреть на метку, а не на комментарий: метка и есть
+состояние. При `blocked` не ждать — задача ждёт владельца.
+
+**После прогона ревью метка меняется всегда.** Инвариант появился не сразу: первая
+редакция при конфликте слияния оставляла метку на месте, и это оказалось тупиком —
+автор ждёт смену метки, метка не менялась, и он тридцать раз опрашивал впустую,
+чтобы отчитаться «лимит исчерпан» при зелёном вердикте. Состояние, из которого
+никто не может выйти и о котором никто не узнает, для конвейера хуже громкой
+ошибки.
+
+Поэтому зелёное код-ревью с неудавшимся слиянием ведёт не в `S8-merged`, а в
+`S6-in-progress`: работа действительно вернулась к автору, только осталась не
+правка кода, а ребейз. Вердикт при этом в силе, переделывать нечего. После ребейза
+метка `S7-code-review` возвращается и ревью идёт заново — не формальность:
+после ребейза на ушедший вперёд `dev` это другой код.
+
+Если метка не сменилась, значит упал сам прогон, а не работа: смотреть логи и
+сообщать владельцу, а не продолжать опрос.
+
+Цикл считается **по этапу**: вердикт по ТЗ не расходует бюджет код-ревью. Раньше
+считались все вердикты подряд, и первое код-ревью #89 получило `r2/4`.
+
+---
+
+## 11. Исключения
+
+### 11.1 Лёгкий трек
+
+См. §5 — это не исключение из правила №1, а более дешёвый путь по тем же статусам.
+
+### 11.2 Аварийный хотфикс (метка `hotfix`, решение владельца)
+
+Разрешено писать код до появления issue. Обязательно:
+
+- issue создан в **той же сессии до коммита**, метка `hotfix`;
+- ТЗ «как сделано» + раздел «почему нельзя было ждать»;
+- в течение 24 часов задача ретроспективно проходит код-ревью;
+- аварийность названа явно в релизном хендоффе (действующее правило `AGENTS.md`).
+
+### 11.3 Гигиена репозитория
+
+Механические изменения без изменения поведения (форматирование, мёртвые файлы)
+идут под квартальный umbrella-issue «Гигиена репозитория»; каждый коммит
+ссылается на него. Трассируемость 1:1 сохраняется.
+
+### 11.4 Починка предрелизных гейтов без повторного код-ревью
+
+Решение владельца 2026-08-13.
+
+В цикле реализации гоняется только лёгкий набор — typecheck, unit, build (§8).
+Golden, браузерные смоки, performance и полный HA-харнесс запускаются перед бетой,
+то есть **после** того, как код-ревью пройдено и issue в `S8-merged`. Часть
+проблем физически не может быть найдена раньше.
+
+**Если предрелизный гейт упал, автор правит, повторно прогоняет упавшее, и
+зелёного прогона достаточно, чтобы релиз продолжился.** Issue остаётся в
+`S8-merged` и на повторное код-ревью не отправляется.
+
+Причина: полный цикл ревью в момент выпуска стоит дороже, чем риск, который он
+здесь снимает. Гейт уже назвал дефект точно, а исправление проверяется тем же
+гейтом — то есть проверка объективна и не зависит от чьего-либо суждения.
+
+**Что при этом обязательно:**
+
+- прогон упавшего гейта записан в issue: **точная команда и её результат**.
+  «Verified» без команды доказательством не является (§8);
+- трейлеры на коммите как обычно, `Issue: #NN` того же issue;
+- при `User-Visible: yes` — правки в оба changelog в том же коммите;
+- эталоны golden принимаются только через `npm run golden:accept -- --reviewed`
+  на полном артефакте Linux CI. «Чтобы гейт позеленел» основанием не является.
+
+**Границы, за которыми исключение не действует.** Оно про починку названного
+гейтом дефекта, а не про продолжение разработки под видом починки. Правка идёт
+обычным путём — новым issue либо возвратом в `S6-in-progress` — если она:
+
+- меняет контракт поведения или добавляет пользователю что-то новое;
+- задевает подсистему, которой в исходной задаче не было;
+- по объёму сопоставима с самой задачей;
+- меняет сам гейт вместо кода — правка теста, чтобы он перестал падать, это не
+  починка, а сокрытие. Исключение — когда дефект **в фикстуре** и это доказано
+  разбором, как на #89: солнце на азимуте 180° и единственное окно на северной
+  стене, поэтому луч честно не строился.
+
+Границу определяет автор, и здесь процесс сознательно отдаёт ему то, что в
+остальных местах не доверяет — оценку собственной работы. Плата за скорость в
+единственной точке, где цикл ревью стоит дороже всего. Компенсируется тем, что
+запись в issue публична и релиз-менеджер видит, что именно было сделано перед
+выпуском.
+
+Это исключение из правила «код-ревью не пропускается никогда» (§5, §7.1) —
+единственное, и относится только к окну между `S8-merged` и выпуском.
+
+---
+
+## 12. Запрещено
+
+- код без issue или из статуса раньше «Готово к разработке»;
+- ТЗ, написанное после кода (кроме §11.2, и тогда с пометкой «как сделано»);
+- ревью своей работы; перевод своей работы через ревью-гейт;
+- пятый цикл ревью вместо разбора по §4;
+- заведение issue вместо возврата на правки, чтобы обойти лимит циклов;
+- принятие golden-эталонов ради зелёного CI или по частичному артефакту;
+- закрытие issue до выпуска беты с зелёным CI;
+- переоткрытие закрытого issue вместо нового бага;
+- Medium-находки, оставленные как TODO в документе ревью;
+- **параллельные бэклоги** в файлах (`BACKLOG-*.md`, «планы» в docs);
+- ревью-документы вне репозитория;
+- попутные правки «раз уж я здесь»;
+- фича или материальное изменение поведения в стабильном релиз-коммите;
+- force-push в `dev`;
+- ручное копирование на домашний инстанс.
+
+**Нарушение процесса — тоже issue** (метка `process`): если правило удалось
+нарушить незаметно, виновата проверка.
+
+---
+
+## 13. Внедрение
+
+Состояние на 2026-08-13.
+
+1. ✅ **Метки созданы, бэклог размечен.** У всех открытых issue владельца ровно
+   одна `S*`-метка, инварианты чистые.
+2. ⏳ **Колонку «Статус ТЗ» из `docs/specs/README.md` убрать** — не сделано, §7.3
+   п.1. Перенос старых документов ревью в `docs/reviews/` отменён: они описывают
+   код, которого уже нет.
+3. ✅ **Гейт написан** — `scripts/process-gate.mjs` плюс job в `validate.yml`,
+   issue #105. Прошёл **вне** флоу как инфраструктурная задача (§1, issue #118), а
+   не через ТЗ и ревью, как предполагала прежняя редакция этого пункта.
+4. ✅ **Долг ревью списан решением владельца.** Беты `beta.2`…`beta.10` сделаны по
+   прежнему процессу и не пересматриваются. Точка отсчёта — релиз 1.62.0; отсчёт
+   начинается с первой беты следующей линии.
+5. ⏳ Завести issue на находку «смок `visual_continuity` не умеет падать» — это
+   ровно тот класс дефектов, который в процессе без ручного тестирования стоит
+   дороже всего.
+6. ✅ `BACKLOG-2026-08-11.md` — разовый отчёт, решения живут в issue.
+7. ✅ `AGENTS.md` переписан целиком, шире блока §14.
+8. ✅ **Канон перенесён в репозиторий** (issue #112). До этого полный процесс жил
+   только в папке владельца, а в репозитории лежал файл на 51 строку про трейлеры
+   коммитов — из свежего клона канон не был виден вообще.
+9. ✅ **`pre-push` написан** (§10.1, issue #121). Блокирующая проверка на клиенте
+   есть; обойти её можно только `--no-verify`, и тогда то же найдёт CI.
+
+---
+
+## 14. Блок для AGENTS.md
+
+```markdown
+## Процесс: код только через issue
+
+Изменение продуктового кода без issue запрещено. Код меняется только из статуса
+«Готово к разработке» или дальше. Полные правила, критерии статусов и гейты —
+`docs/PROCESS.md`, читать до начала работы.
+
+Жизненный цикл (статус = метка issue): `S1-new` → `S2-analysis` → `S3-spec` →
+`S4-spec-review` → `S5-ready` → `S6-in-progress` → `S7-code-review` → `S8-merged`
+→ закрытие пачкой при выпуске беты. Оба ревью возвращают на правки не более 4
+циклов; пятый заход — разбор у владельца (разделить / отклонить / арбитраж).
+
+Ревью запускается **само** от меток `S4-spec-review` и `S7-code-review` и идёт до
+45 минут. Поставив такую метку, автор не заканчивает работу, а ждёт смены метки
+опросом и продолжает по тому, чем она стала.
+
+- ветка `issue/<NN>-<slug>`, коммиты с трейлерами `Issue: #NN` и `User-Visible: yes|no`;
+- работаем прямыми коммитами в `dev`, без PR: блокирующий гейт — локальный
+  `pre-push` (ставится автоматически через `npm ci`), CI — страховка. Force-push
+  в `dev` запрещён;
+- автор ≠ ревьюер, ни для ТЗ, ни для кода;
+- фазы ручного тестирования нет: автотесты пишутся в реализации, AC проверяет
+  код-ревью, найденные позже дефекты — новые issue типа «баг»;
+- мелкие задачи (метка `small`, сложность ≤3): ТЗ в теле issue, ревью ТЗ
+  комментарием, код-ревью — как обычно;
+- найденное вне скоупа — новый issue, а не попутная правка;
+- issue закрывает релиз-менеджер после выпуска беты, не исполнитель.
+```

README.md

@@ -312,6 +312,17 @@ Always source is deliberately constant-on. With several own `light.*`/`switch.*`
 entities, Always also offers a leading-entity selector; a missing saved choice
 is warned about and retained while a deterministic fallback is used.
 
+To make that virtual lamp manually switchable without creating a Home
+Assistant helper, also choose **Tap action → Toggle state** on the lamp itself.
+This exact combination — virtual binding, **Light source → Always**, and
+**Toggle state** — stores a shared on/off state in the House Plan integration.
+It survives page reloads and Home Assistant restarts and updates Glow, room
+fill/statistics, full cards and `houseplan-space-card` together. Any signed-in
+dashboard viewer may toggle it. While this manual mode is active, saved
+**Controls other light sources** remain intact but are not called; changing the
+role, binding or tap action restores their normal behaviour. This operational
+state is deliberately not part of plan exports or Home Assistant entities.
+
 The same dialog controls how the device looks on the plan. **Display** switches between the
 icon badge, an animated **presence ripple** (pulsing rings while the entity is active, a faint
 dot when idle — great for motion sensors) or both, with a per-device ring colour and size. The

custom_components/houseplan/__init__.py

@@ -24,7 +24,12 @@ from .const import (
 from .geometry_migration import migrate_config, migrate_layout, pending_from_config
 from .plans import collect_attachments, collect_plans, sweep_upload_temps
 from .repairs import async_check_plan_files
-from .store import HouseplanConfigEntry, async_save_layout_state, create_data
+from .store import (
+    HouseplanConfigEntry,
+    async_save_config_state,
+    async_save_layout_state,
+    create_data,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -60,6 +65,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: HouseplanConfigEntry) ->
         await data.config_store.async_load()
     except Exception as err:  # noqa: BLE001 — corrupt/unreadable .storage
         raise ConfigEntryNotReady(f"House Plan storage is not readable: {err}") from err
+    try:
+        await data.virtual_light_store.async_load()
+    except Exception:  # noqa: BLE001 — operational state fails safe to default on
+        _LOGGER.exception("House Plan: virtual-light storage is not readable; using default on")
     entry.runtime_data = data
 
     # server-side vacuum trails: the integration records the path itself
@@ -152,7 +161,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: HouseplanConfigEntry) ->
             rev = int(stored.get("rev", 0))
             if cfg and migrate_config(cfg):  # 2. the config half
                 rev += 1
-                await data.config_store.async_save({"config": cfg, "rev": rev})
+                await async_save_config_state(data, cfg, rev, previous_rev=rev - 1)
             migrate_layout(layout, merged)  # 3. the layout half + intent cleared
             await async_save_layout_state(
                 data, lay_stored, layout, lay_rev + 1, remove=("geom_pending",)
@@ -186,11 +195,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: HouseplanConfigEntry) ->
                 "layout_rev", layout_rev + (lay_stored.get("layout", {}) != target_layout)
             ))
             if stored.get("config") != target_config or config_rev < target_config_rev:
+                previous_config_rev = config_rev
                 config_rev = max(config_rev, target_config_rev)
-                await data.config_store.async_save({
-                    "config": target_config,
-                    "rev": config_rev,
-                })
+                await async_save_config_state(
+                    data,
+                    target_config,
+                    config_rev,
+                    previous_rev=previous_config_rev,
+                )
             if lay_stored.get("layout", {}) != target_layout or layout_rev < target_layout_rev:
                 layout_rev = max(layout_rev, target_layout_rev)
             exact_metadata = pending.get("final_metadata")

custom_components/houseplan/const.py

@@ -3,6 +3,7 @@
 DOMAIN = "houseplan"
 STORAGE_KEY = f"{DOMAIN}.layout"
 STORAGE_CONFIG_KEY = f"{DOMAIN}.config"
+STORAGE_VIRTUAL_LIGHTS_KEY = f"{DOMAIN}.virtual_lights"
 STORAGE_VERSION = 1
 STORAGE_MINOR_VERSION = 1
 FRONTEND_URL = "/houseplan_files/houseplan-card.js"
@@ -45,7 +46,7 @@ PLAN_ORPHAN_TTL_S = 3600
 SCHEDULED_GRACE_S = 30 * 24 * 3600
 FILES_DIR = "houseplan/files"
 CONF_ADMIN_ONLY = "admin_only"
-VERSION = "1.62.0-beta.7"
+VERSION = "1.64.0-beta.1"
 
 # Portable backup format.  This is deliberately independent from the Home
 # Assistant Store version above: storage migrations and files exported by a

custom_components/houseplan/http_api.py

@@ -86,27 +86,30 @@ class HouseplanImportPreviewView(HomeAssistantView):
             blocks.append(block)
         owner_id = str(getattr(user, "id", ""))
         try:
+            # Hold the global writer only while taking one coherent store
+            # snapshot. Parsing up to 8 MiB, schema validation and space remap
+            # are CPU work and apply will revalidate both revisions anyway.
             async with runtime.write_lock:
                 config_data = await runtime.config_store.async_load() or {}
                 layout_data = await runtime.store.async_load() or {}
-                try:
-                    registry_snapshot = import_registry_snapshot(hass)
-                except Exception:  # noqa: BLE001 - summary must not block a valid backup
-                    _LOGGER.debug("House Plan import registry summary unavailable", exc_info=True)
-                    registry_snapshot = None
-                result = await hass.async_add_executor_job(
-                    partial(
-                        create_preview,
-                        runtime,
-                        b"".join(blocks),
-                        owner_id=owner_id,
-                        duplicate_policy=policy,
-                        current_config_data=config_data,
-                        current_layout_data=layout_data,
-                        config_root=Path(hass.config.path("")),
-                        registry_snapshot=registry_snapshot,
-                    )
+            try:
+                registry_snapshot = import_registry_snapshot(hass)
+            except Exception:  # noqa: BLE001 - summary must not block a valid backup
+                _LOGGER.debug("House Plan import registry summary unavailable", exc_info=True)
+                registry_snapshot = None
+            result = await hass.async_add_executor_job(
+                partial(
+                    create_preview,
+                    runtime,
+                    b"".join(blocks),
+                    owner_id=owner_id,
+                    duplicate_policy=policy,
+                    current_config_data=config_data,
+                    current_layout_data=layout_data,
+                    config_root=Path(hass.config.path("")),
+                    registry_snapshot=registry_snapshot,
                 )
+            )
         except ImportFailure as err:
             status = 413 if err.code == "too_large" else 400
             return web.json_response({"error": err.code, "message": err.message}, status=status)

custom_components/houseplan/import_export.py

@@ -45,6 +45,7 @@ from .validation import (
     sanitize_filename,
     sanitize_marker_id,
     validate_marker_controls,
+    validate_marker_light_entities,
     validate_marker_value_badges,
     MarkerControlError,
 )
@@ -719,6 +720,7 @@ def build_space_merge(
         raise ImportFailure("invalid_config", str(err)) from err
     try:
         validate_marker_controls(merged_config, current_config)
+        validate_marker_light_entities(merged_config, current_config)
         validate_marker_value_badges(merged_config, current_config)
     except MarkerControlError as err:
         raise ImportFailure(err.code, str(err)) from err
@@ -891,6 +893,7 @@ def create_preview(
         details["dropped_marker_links"] = dropped_marker_links
         try:
             validate_marker_controls(incoming_config, validate_all=True)
+            validate_marker_light_entities(incoming_config, validate_all=True)
             validate_marker_value_badges(incoming_config, validate_all=True)
         except MarkerControlError as err:
             raise ImportFailure(err.code, str(err)) from err

custom_components/houseplan/manifest.json

@@ -16,5 +16,5 @@
   "issue_tracker": "https://github.com/Matysh/houseplan-card/issues",
   "requirements": [],
   "single_config_entry": true,
-  "version": "1.62.0-beta.7"
+  "version": "1.64.0-beta.1"
 }

custom_components/houseplan/store.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from typing import Any
@@ -10,7 +11,17 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.storage import Store
 
-from .const import DOMAIN, STORAGE_CONFIG_KEY, STORAGE_KEY, STORAGE_MINOR_VERSION, STORAGE_VERSION
+from .const import (
+    DOMAIN,
+    STORAGE_CONFIG_KEY,
+    STORAGE_KEY,
+    STORAGE_MINOR_VERSION,
+    STORAGE_VERSION,
+    STORAGE_VIRTUAL_LIGHTS_KEY,
+)
+
+
+_LOGGER = logging.getLogger(__name__)
 
 
 class HouseplanStore(Store):
@@ -40,6 +51,7 @@ class HouseplanData:
 
     store: HouseplanStore
     config_store: HouseplanStore
+    virtual_light_store: HouseplanStore
     # One lock for every load→modify→save cycle of both stores: prevents
     # lost updates from concurrent WS calls and makes the rev check atomic.
     write_lock: asyncio.Lock = field(default_factory=asyncio.Lock)
@@ -71,6 +83,12 @@ def create_data(hass: HomeAssistant) -> HouseplanData:
         config_store=HouseplanStore(
             hass, STORAGE_VERSION, STORAGE_CONFIG_KEY, minor_version=STORAGE_MINOR_VERSION
         ),
+        virtual_light_store=HouseplanStore(
+            hass,
+            STORAGE_VERSION,
+            STORAGE_VIRTUAL_LIGHTS_KEY,
+            minor_version=STORAGE_MINOR_VERSION,
+        ),
     )
 
 
@@ -88,6 +106,7 @@ def get_entry(hass: HomeAssistant) -> ConfigEntry | None:
 
 OPTIMIZE_BACKUP = "optimize_backup"
 OPTIMIZE_PENDING = "optimize_pending"
+LAYOUT_STORE_CORE_KEYS = frozenset({"layout", "rev"})
 
 
 def layout_store_payload(
@@ -106,7 +125,7 @@ def layout_store_payload(
     the next drag.  All writers now express only the metadata they intentionally
     add/remove and this helper preserves the rest.
     """
-    excluded = {"layout", "rev", *remove}
+    excluded = {*LAYOUT_STORE_CORE_KEYS, *remove}
     out = {} if replace_metadata else {
         key: value for key, value in stored.items() if key not in excluded
     }
@@ -138,3 +157,43 @@ async def async_save_layout_state(
     )
     await runtime.store.async_save(payload)
     return payload
+
+
+async def async_save_config_state(
+    runtime: HouseplanData,
+    config: dict[str, Any],
+    rev: int,
+    *,
+    previous_rev: int | None = None,
+) -> dict[str, Any]:
+    """Persist configuration and reconcile dependent operational state.
+
+    Callers already hold ``runtime.write_lock``.  Reading the previous
+    revision here keeps less common writers (import recovery and undo) on the
+    same path as ordinary editor saves without duplicating lifecycle rules.
+    """
+    if previous_rev is None:
+        previous = await runtime.config_store.async_load() or {}
+        try:
+            previous_rev = int(previous.get("rev", 0))
+        except (TypeError, ValueError):
+            previous_rev = 0
+
+    payload = {"config": config, "rev": rev}
+    await runtime.config_store.async_save(payload)
+
+    # The config is already durable at this point.  Reconciliation remains a
+    # separate Store write; an interrupted pair is detected from config_rev on
+    # the next read and fails safe to the compatibility default (all on).
+    from .virtual_lights import async_reconcile_virtual_lights
+
+    try:
+        await async_reconcile_virtual_lights(
+            runtime.virtual_light_store,
+            config,
+            rev,
+            previous_config_rev=previous_rev,
+        )
+    except Exception:  # noqa: BLE001 - config commit already stands
+        _LOGGER.exception("House Plan: virtual-light state reconciliation failed")
+    return payload

custom_components/houseplan/validation.py

@@ -41,6 +41,7 @@ VALUE_BADGE_POSITIONS = {"right", "bottom", "left", "top"}
 VALUE_BADGE_SOURCE_KINDS = {
     "entity_state", "entity_attribute", "derived_lqi", "derived_marker_state",
 }
+_LIGHT_ENTITY_RE = re.compile(r"^(?:light|switch)\.[a-z0-9_]+\Z")
 
 
 def _matching_previous_marker(
@@ -131,6 +132,38 @@ def validate_marker_value_badges(
                 raise MarkerControlError("value_badge_marker_not_light", "Marker value badge target is not a forced light")
 
 
+def validate_marker_light_entities(
+    config: dict, previous: dict | None = None, *, validate_all: bool = False
+) -> None:
+    """Validate new/changed leading-light choices without rejecting dormant data.
+
+    The top-level schema must stay lossless: an old or future literal that the
+    current frontend cannot edit may round-trip unchanged. Imports validate the
+    whole incoming document because every imported value is new to this plan.
+    """
+    markers = config.get("markers") or []
+    old_markers = (previous or {}).get("markers") or []
+    old_by_id = {str(marker.get("id")): marker for marker in old_markers}
+    new_ids = {str(marker.get("id")) for marker in markers}
+    consumed_old_ids: set[str] = set()
+    for marker in markers:
+        marker_id = str(marker.get("id"))
+        old_marker = _matching_previous_marker(
+            marker, marker_id, old_by_id, old_markers, new_ids,
+            consumed_old_ids, validate_all,
+        )
+        value = marker.get("light_entity")
+        old_value = None if validate_all else (old_marker or {}).get("light_entity")
+        if not validate_all and value == old_value:
+            continue
+        if value is None:
+            continue
+        if not isinstance(value, str) or not _LIGHT_ENTITY_RE.fullmatch(value):
+            raise MarkerControlError(
+                "invalid_light_entity", "Leading light entity must be light.* or switch.*"
+            )
+
+
 def validate_marker_controls(
     config: dict, previous: dict | None = None, *, validate_all: bool = False
 ) -> None:
@@ -849,10 +882,9 @@ MARKER_SCHEMA = vol.Schema(
         # Explicit leading entity for composite Always sources. It is kept
         # literally when temporarily absent; runtime falls back without
         # deleting the user's choice.
-        vol.Optional("light_entity"): vol.Any(
-            None,
-            vol.All(str, vol.Length(max=MAX_TEXT), vol.Match(r"^(?:light|switch)\.[a-z0-9_]+\Z")),
-        ),
+        # Semantic delta validation below the schema preserves unknown/future
+        # literals until that exact field is edited (lossless config doctrine).
+        vol.Optional("light_entity"): object,
         vol.Optional("value_badge"): vol.Any(
             None,
             vol.Schema(

custom_components/houseplan/virtual_lights.py

@@ -0,0 +1,125 @@
+"""Persistent operational state for manual virtual lights."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .store import HouseplanStore
+
+
+EVENT_VIRTUAL_LIGHT_UPDATED = "houseplan_virtual_light_updated"
+
+
+def is_manual_virtual_light(marker: Any) -> bool:
+    """Return whether a marker uses the exact persistent manual-light mode."""
+    return (
+        isinstance(marker, dict)
+        and isinstance(marker.get("id"), str)
+        and bool(marker["id"])
+        and marker.get("binding") == "virtual"
+        and marker.get("is_light") is True
+        and marker.get("tap_action") == "toggle"
+        and marker.get("removed") is not True
+    )
+
+
+def eligible_virtual_light_ids(config: Any) -> set[str]:
+    """Collect live marker ids eligible for persistent manual state."""
+    if not isinstance(config, dict):
+        return set()
+    markers = config.get("markers")
+    if not isinstance(markers, list):
+        return set()
+    return {marker["id"] for marker in markers if is_manual_virtual_light(marker)}
+
+
+def _integer(value: Any, default: int = 0) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return default
+    return max(0, parsed)
+
+
+def _read_state(stored: Any) -> tuple[int, int, set[str]]:
+    if not isinstance(stored, dict):
+        return 0, 0, set()
+    raw_off = stored.get("off")
+    off = (
+        {item for item in raw_off if isinstance(item, str) and item}
+        if isinstance(raw_off, list)
+        else set()
+    )
+    return _integer(stored.get("rev")), _integer(stored.get("config_rev")), off
+
+
+def _wire(rev: int, config_rev: int, off: set[str]) -> dict[str, Any]:
+    return {"rev": rev, "config_rev": config_rev, "off": sorted(off)}
+
+
+async def async_virtual_light_snapshot(
+    store: HouseplanStore,
+    config: dict[str, Any],
+    config_rev: int,
+) -> dict[str, Any]:
+    """Return a coherent snapshot, repairing stale or interrupted state.
+
+    A revision gap means an older writer may have changed eligibility without
+    knowing about this Store.  Clearing every manual-off bit is conservative:
+    it restores the pre-feature/default-on behaviour and cannot resurrect an
+    old off state for a marker whose role changed in the meantime.
+    """
+    stored = await store.async_load() or {}
+    rev, state_config_rev, stored_off = _read_state(stored)
+    eligible = eligible_virtual_light_ids(config)
+    off = stored_off & eligible if state_config_rev == config_rev else set()
+    if off != stored_off:
+        rev += 1
+    payload = _wire(rev, config_rev, off)
+    if payload != stored:
+        await store.async_save(payload)
+    return payload
+
+
+async def async_reconcile_virtual_lights(
+    store: HouseplanStore,
+    config: dict[str, Any],
+    config_rev: int,
+    *,
+    previous_config_rev: int,
+) -> dict[str, Any]:
+    """Carry eligible state across one known configuration transition."""
+    stored = await store.async_load() or {}
+    rev, state_config_rev, stored_off = _read_state(stored)
+    eligible = eligible_virtual_light_ids(config)
+    off = stored_off & eligible if state_config_rev == previous_config_rev else set()
+    if off != stored_off:
+        rev += 1
+    payload = _wire(rev, config_rev, off)
+    if payload != stored:
+        await store.async_save(payload)
+    return payload
+
+
+async def async_toggle_virtual_light(
+    store: HouseplanStore,
+    config: dict[str, Any],
+    config_rev: int,
+    marker_id: str,
+) -> dict[str, Any] | None:
+    """Atomically invert one eligible marker and persist before returning."""
+    if marker_id not in eligible_virtual_light_ids(config):
+        return None
+    snapshot = await async_virtual_light_snapshot(store, config, config_rev)
+    off = set(snapshot["off"])
+    if marker_id in off:
+        off.remove(marker_id)
+    else:
+        off.add(marker_id)
+    payload = _wire(_integer(snapshot["rev"]) + 1, config_rev, off)
+    await store.async_save(payload)
+    return {
+        "marker_id": marker_id,
+        "on": marker_id not in off,
+        "rev": payload["rev"],
+    }

custom_components/houseplan/websocket_api.py

@@ -28,6 +28,7 @@ from .const import (
 from .auth import may_write
 from .import_export import (
     ImportFailure,
+    content_manifest,
     create_export,
     get_candidate,
     live_layout,
@@ -39,18 +40,26 @@ from .plans import (
     plan_basename, plan_refs, reserve_filename,
 )
 from .store import (
+    LAYOUT_STORE_CORE_KEYS,
     OPTIMIZE_BACKUP as _OPTIMIZE_BACKUP,
     OPTIMIZE_PENDING as _OPTIMIZE_PENDING,
     HouseplanData,
+    async_save_config_state,
     async_save_layout_state,
     get_data,
     get_entry,
 )
+from .virtual_lights import (
+    EVENT_VIRTUAL_LIGHT_UPDATED,
+    async_toggle_virtual_light,
+    async_virtual_light_snapshot,
+)
 from .registry_snapshot import import_registry_snapshot
 from .validation import (
     CONFIG_SCHEMA, LAYOUT_SCHEMA, MAX_CONFIG_BYTES, MAX_PLAN_BYTES,
     PLAN_EXTENSIONS, POS_SCHEMA, MarkerControlError, sanitize_filename,
-    validate_marker_controls, validate_marker_value_badges, valid_space_id,
+    validate_marker_controls, validate_marker_light_entities,
+    validate_marker_value_badges, valid_space_id,
 )
 
 
@@ -123,6 +132,7 @@ def async_register(hass: HomeAssistant) -> None:
     websocket_api.async_register_command(hass, ws_layout_update)
     websocket_api.async_register_command(hass, ws_layout_delete)
     websocket_api.async_register_command(hass, ws_config_get)
+    websocket_api.async_register_command(hass, ws_virtual_light_toggle)
     websocket_api.async_register_command(hass, ws_config_set)
     websocket_api.async_register_command(hass, ws_plan_optimize)
     websocket_api.async_register_command(hass, ws_plan_optimize_undo)
@@ -167,7 +177,7 @@ def _layout_metadata(stored: dict[str, Any]) -> dict[str, Any]:
     """Return the exact non-layout portion of a layout-store document."""
     return {
         key: value for key, value in stored.items()
-        if key not in {"layout", "rev"}
+        if key not in LAYOUT_STORE_CORE_KEYS
     }
 
 
@@ -191,10 +201,11 @@ async def _persist_pair_intent(
 
 async def _converge_pair(rt: HouseplanData, pending: dict[str, Any]) -> None:
     """Write both target halves and remove the durable intent last."""
-    await rt.config_store.async_save({
-        "config": pending["config"],
-        "rev": int(pending["config_rev"]),
-    })
+    await async_save_config_state(
+        rt,
+        pending["config"],
+        int(pending["config_rev"]),
+    )
     stored = await rt.store.async_load() or {}
     await async_save_layout_state(
         rt,
@@ -397,6 +408,14 @@ async def ws_import_apply(hass: HomeAssistant, connection, msg: dict[str, Any])
                     "missing_plan",
                     "Plan file no longer exists: " + ", ".join(sorted(missing)),
                 )
+            missing_attachments = _missing_internal_attachments(
+                Path(hass.config.path("")), target_config, config_data.get("config")
+            )
+            if missing_attachments:
+                raise ImportFailure(
+                    "missing_content",
+                    "Attachment no longer exists: " + ", ".join(sorted(missing_attachments)),
+                )
             new_config_rev = config_rev + 1
             new_layout_rev = layout_rev + 1
             backup = None
@@ -410,9 +429,12 @@ async def ws_import_apply(hass: HomeAssistant, connection, msg: dict[str, Any])
                     "after_layout_rev": new_layout_rev,
                 }
             original_metadata = _layout_metadata(layout_data)
+            replaced_metadata = {_OPTIMIZE_PENDING, _OPTIMIZE_BACKUP}
+            if kind == "full":
+                replaced_metadata.update({"repair_backup", "geom_pending"})
             final_metadata = {
                 key: value for key, value in original_metadata.items()
-                if key not in {_OPTIMIZE_PENDING, _OPTIMIZE_BACKUP}
+                if key not in replaced_metadata
             }
             if backup is not None:
                 final_metadata[_OPTIMIZE_BACKUP] = backup
@@ -621,6 +643,7 @@ async def ws_layout_update(hass: HomeAssistant, connection, msg: dict[str, Any])
         vol.Required("aspect"): vol.All(vol.Coerce(float), vol.Range(min=0.05, max=20)),
         vol.Optional("dry_run"): bool,
         vol.Optional("undo"): bool,
+        vol.Optional("expected_rev"): int,
     }
 )
 @websocket_api.async_response
@@ -653,6 +676,12 @@ async def ws_geometry_repair(hass: HomeAssistant, connection, msg: dict[str, Any
         data = await rt.store.async_load() or {}
         layout = data.get("layout") or {}
         current_rev = int(data.get("rev", 0))
+        if "expected_rev" in msg and msg["expected_rev"] != current_rev:
+            connection.send_error(
+                msg["id"], "conflict",
+                f"Layout was changed in another window (rev {current_rev} != {msg['expected_rev']})",
+            )
+            return
         if msg.get("undo"):
             backup = data.get("repair_backup")
             if not isinstance(backup, dict) or backup.get("space") != space_id:
@@ -1037,14 +1066,28 @@ async def ws_config_get(hass: HomeAssistant, connection, msg: dict[str, Any]) ->
     rt = _runtime(hass, connection, msg["id"])
     if rt is None:
         return
-    data = await rt.config_store.async_load() or {}
-    layout_data = await rt.store.async_load() or {}
-    config = {**DEFAULT_CONFIG, **data.get("config", {})}
+    async with rt.write_lock:
+        data = await rt.config_store.async_load() or {}
+        layout_data = await rt.store.async_load() or {}
+        config = {**DEFAULT_CONFIG, **data.get("config", {})}
+        config_rev = int(data.get("rev", 0))
+        try:
+            virtual_lights = await async_virtual_light_snapshot(
+                rt.virtual_light_store,
+                config,
+                config_rev,
+            )
+        except Exception:  # noqa: BLE001 - config remains independently readable
+            _LOGGER.exception("House Plan: reading virtual-light state failed")
+            # Never expose a stale off bit after an unreadable/revision-gap
+            # operational store. Compatibility/default on is the safe frame.
+            virtual_lights = {"rev": 0, "config_rev": config_rev, "off": []}
     connection.send_result(
         msg["id"],
         {
             "config": config,
-            "rev": data.get("rev", 0),
+            "rev": config_rev,
+            "virtual_lights": virtual_lights,
             "can_write": may_write(hass, getattr(connection, "user", None)),
             "can_optimize_undo": _optimizer_backup_is_current(data, layout_data),
             "undo_kind": _undo_kind(data, layout_data),
@@ -1052,6 +1095,42 @@ async def ws_config_get(hass: HomeAssistant, connection, msg: dict[str, Any]) ->
     )
 
 
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "houseplan/virtual_light/toggle",
+        vol.Required("marker_id"): vol.All(str, vol.Length(min=1, max=500)),
+    }
+)
+@websocket_api.async_response
+async def ws_virtual_light_toggle(
+    hass: HomeAssistant, connection, msg: dict[str, Any]
+) -> None:
+    """Atomically toggle one eligible virtual light for any signed-in user."""
+    rt = _runtime(hass, connection, msg["id"])
+    if rt is None:
+        return
+    async with rt.write_lock:
+        data = await rt.config_store.async_load() or {}
+        config = {**DEFAULT_CONFIG, **data.get("config", {})}
+        result = await async_toggle_virtual_light(
+            rt.virtual_light_store,
+            config,
+            int(data.get("rev", 0)),
+            msg["marker_id"],
+        )
+        if result is None:
+            connection.send_error(
+                msg["id"],
+                "not_toggleable",
+                "Marker is not an active virtual light with tap_action=toggle",
+            )
+            return
+    # Both the reply and event follow the durable Store write.  There is no
+    # optimistic client state, so all cards converge on this revision.
+    connection.send_result(msg["id"], result)
+    hass.bus.async_fire(EVENT_VIRTUAL_LIGHT_UPDATED, result)
+
+
 
 def _internal_plan_names(config: dict[str, Any]) -> set[str]:
     """Plan file names a configuration names through OUR urls.
@@ -1093,6 +1172,30 @@ def _missing_internal_plans(
     }
 
 
+def _missing_internal_attachments(
+    config_root: Path, config: dict[str, Any], previous: dict[str, Any] | None = None
+) -> set[str]:
+    """New local attachments that vanished between import preview and apply.
+
+    Existing broken references stay writable for the same reason as historical
+    plan URLs: refusing every unrelated write would prevent the user from
+    detaching or repairing them.
+    """
+    known = {
+        str(item["url"])
+        for item in content_manifest(previous or {}, config_root)
+        if item.get("kind") == "attachment" and item.get("storage") == "internal"
+    }
+    return {
+        str(item["url"])
+        for item in content_manifest(config, config_root)
+        if item.get("kind") == "attachment"
+        and item.get("storage") == "internal"
+        and item.get("exists_at_export") is False
+        and str(item["url"]) not in known
+    }
+
+
 @websocket_api.websocket_command(
     {
         vol.Required("type"): "houseplan/config/set",
@@ -1147,6 +1250,7 @@ async def ws_config_set(hass: HomeAssistant, connection, msg: dict[str, Any]) ->
         # write so an unrelated edit can still round-trip a legacy broken ref.
         try:
             validate_marker_controls(msg["config"], data.get("config"))
+            validate_marker_light_entities(msg["config"], data.get("config"))
             validate_marker_value_badges(msg["config"], data.get("config"))
         except MarkerControlError as err:
             connection.send_error(msg["id"], err.code, str(err))
@@ -1169,7 +1273,12 @@ async def ws_config_set(hass: HomeAssistant, connection, msg: dict[str, Any]) ->
             )
             return
         new_rev = current_rev + 1
-        await rt.config_store.async_save({"config": msg["config"], "rev": new_rev})
+        await async_save_config_state(
+            rt,
+            msg["config"],
+            new_rev,
+            previous_rev=int(current_rev),
+        )
         try:
             await _discard_optimizer_snapshot(rt)
         except Exception:  # noqa: BLE001 — stale backup cleanup is best-effort
@@ -1251,6 +1360,7 @@ async def ws_plan_optimize(hass: HomeAssistant, connection, msg: dict[str, Any])
         # as config/set; otherwise a crafted client can persist a new cycle.
         try:
             validate_marker_controls(msg["config"], config_data.get("config"))
+            validate_marker_light_entities(msg["config"], config_data.get("config"))
             validate_marker_value_badges(msg["config"], config_data.get("config"))
         except MarkerControlError as err:
             connection.send_error(msg["id"], err.code, str(err))
@@ -1293,11 +1403,16 @@ async def ws_plan_optimize(hass: HomeAssistant, connection, msg: dict[str, Any])
             metadata={_OPTIMIZE_BACKUP: backup, _OPTIMIZE_PENDING: pending},
             remove=(_OPTIMIZE_BACKUP, _OPTIMIZE_PENDING),
         )
-        await rt.config_store.async_save({"config": msg["config"], "rev": new_config_rev})
+        await async_save_config_state(
+            rt,
+            msg["config"],
+            new_config_rev,
+            previous_rev=config_rev,
+        )
         await async_save_layout_state(
             rt, layout_data, msg["layout"], new_layout_rev,
             metadata={_OPTIMIZE_BACKUP: backup},
-            remove=(_OPTIMIZE_BACKUP, _OPTIMIZE_PENDING),
+            remove=(_OPTIMIZE_BACKUP, _OPTIMIZE_PENDING, "repair_backup", "geom_pending"),
         )
 
     hass.bus.async_fire("houseplan_config_updated", {"rev": new_config_rev})
@@ -1363,7 +1478,12 @@ async def ws_plan_optimize_undo(hass: HomeAssistant, connection, msg: dict[str,
             metadata={_OPTIMIZE_BACKUP: backup, _OPTIMIZE_PENDING: pending},
             remove=(_OPTIMIZE_BACKUP, _OPTIMIZE_PENDING),
         )
-        await rt.config_store.async_save({"config": restored_config, "rev": new_config_rev})
+        await async_save_config_state(
+            rt,
+            restored_config,
+            new_config_rev,
+            previous_rev=config_rev,
+        )
         await async_save_layout_state(
             rt, layout_data, restored_layout, new_layout_rev,
             remove=(_OPTIMIZE_BACKUP, _OPTIMIZE_PENDING, "repair_backup"),

demo/benchmark_large_house.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /** Reproducible browser benchmark and report producer for HP-PERF-01. */
-import { mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { launch } from './serve.mjs';
 import { LARGE_HOUSE_COUNTS, makeLargeHouseFixture } from './fixtures/large-house.mjs';
@@ -13,6 +13,11 @@ const samples = Math.max(1, Math.min(20, Number(valueArg('samples')) || 7));
 const warmups = Math.max(0, Math.min(5, Number(valueArg('warmups')) || 1));
 const output = valueArg('output') ? resolve(valueArg('output')) : null;
 const targetRoot = resolve(valueArg('target-root') ?? '.');
+const profile = valueArg('profile') ?? 'large-house-v1';
+if (!['large-house-v1', 'large-house-isometric-v1'].includes(profile))
+  throw new Error(`unknown large-house profile: ${profile}`);
+const isometric = profile === 'large-house-isometric-v1';
+const requiresIsometric = isometric && existsSync(resolve(targetRoot, 'src/iso-projection.ts'));
 const fixture = makeLargeHouseFixture();
 const viewport = { width: 1440, height: 1000 };
 
@@ -43,7 +48,7 @@ const rows = [];
 try {
   for (let iteration = 0; iteration < warmups + samples; iteration++) {
     const measuredSample = iteration - warmups;
-    const row = await page.evaluate(async ({ fixture, sample, cardContract }) => {
+    const row = await page.evaluate(async ({ fixture, sample, cardContract, isometric, requiresIsometric }) => {
       const frame = () => new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)));
       const until = async (predicate, timeout = 10000) => {
         const started = performance.now();
@@ -98,10 +103,18 @@ try {
         wallUnion: card._wallUnionCache ? 1 : 0,
         openingTunnel: card._openingTunnelCache ? 1 : 0,
         openingWallIndex: card._openingWallIndexCache ? 1 : 0,
+        isoGeometry: card._isoGeometryCache?.size ?? 0,
       });
 
       window.__card?.remove?.();
       localStorage.clear();
+      if (isometric) {
+        localStorage.setItem('houseplan_card_labs_v1', JSON.stringify(['iso']));
+        localStorage.setItem('houseplan_card_view_v1', JSON.stringify(Object.fromEntries(
+          fixture.config.spaces.map((space) => [space.id, 'iso']),
+        )));
+        history.replaceState(null, '', '?hp-labs=iso');
+      } else history.replaceState(null, '', location.pathname);
       const host = document.getElementById('host');
       const card = document.createElement('houseplan-card');
       card.setConfig({
@@ -144,6 +157,10 @@ try {
       host.replaceChildren(card);
       card.hass = hassFor(fixture.states);
       window.__hpAssertCardContract(card, cardContract);
+      if (requiresIsometric && (typeof card._setProjection !== 'function'
+          || !(card._isoGeometryCache instanceof Map))) {
+        throw new Error('large-house-isometric-v1 candidate has no renderer contract');
+      }
       await until(() => card._loadOk && card._model?.length === fixture.counts.floors);
       await card.updateComplete;
       await frame();
@@ -152,6 +169,18 @@ try {
       await frame();
       const firstStableRenderMs = Number((performance.now() - loadStarted).toFixed(2));
       const loadLongTaskResult = await loadLongTasks.stop();
+      const viewToggle = isometric ? await duration(async () => {
+        if (typeof card._setProjection === 'function') {
+          card._setProjection('flat');
+          await card.updateComplete;
+          card._setProjection('iso');
+          await card.updateComplete;
+        } else {
+          // Comparison SHAs before #89 intentionally ignore the Labs operation.
+          card.requestUpdate();
+          await card.updateComplete;
+        }
+      }) : null;
       const spaceSwitch = await duration(async () => {
         card._pickSpace('perf-floor-2');
         await card.updateComplete;
@@ -249,6 +278,7 @@ try {
         sample,
         modelReadyMs,
         firstStableRenderMs,
+        ...(viewToggle ? { viewToggleMs: viewToggle.ms } : {}),
         spaceSwitchMs: spaceSwitch.ms,
         stateUpdateMs: stateUpdate.ms,
         resizePreviewMs: resizePreview.ms,
@@ -257,6 +287,7 @@ try {
         switchCycleMs: switchCycle.ms,
         longTasks: {
           load: loadLongTaskResult,
+          ...(viewToggle ? { viewToggle: viewToggle.longTasks } : {}),
           spaceSwitch: spaceSwitch.longTasks,
           stateUpdate: stateUpdate.longTasks,
           resizePreview: resizePreview.longTasks,
@@ -273,7 +304,10 @@ try {
       card.remove();
       await frame();
       return result;
-    }, { fixture, sample: measuredSample, cardContract: LARGE_HOUSE_CARD_CONTRACT });
+    }, {
+      fixture, sample: measuredSample, cardContract: LARGE_HOUSE_CARD_CONTRACT,
+      isometric, requiresIsometric,
+    });
     if (measuredSample >= 0) rows.push(row);
   }
 } finally {
@@ -284,9 +318,10 @@ const metricNames = [
   'modelReadyMs', 'firstStableRenderMs', 'spaceSwitchMs', 'stateUpdateMs',
   'resizePreviewMs', 'panZoomMs', 'settingsDialogMs', 'switchCycleMs',
 ];
+if (isometric) metricNames.splice(2, 0, 'viewToggleMs');
 const report = {
   schema: 2,
-  profile: 'large-house-v1',
+  profile,
   generatedAt: new Date().toISOString(),
   buildFingerprint,
   runtime: {
@@ -304,7 +339,7 @@ const report = {
   summary: summarizeTimings(rows, metricNames),
   longTasks: summarizeLongTasks(rows),
   rows,
-  note: 'Compare with a base-SHA report captured by the same runner and evaluate demo/performance/budgets.json.',
+  note: `Compare with a base-SHA report captured by the same runner and evaluate the ${profile} budget.`,
 };
 
 const text = `${JSON.stringify(report, null, 2)}\n`;

demo/bundle-freshness.mjs

@@ -1,8 +1,24 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { sourceFingerprint } from '../scripts/source-fingerprint.mjs';
 
+const fingerprintForTree = async (root) => {
+  const modulePath = resolve(root, 'scripts/source-fingerprint.mjs');
+  if (!existsSync(modulePath)) return sourceFingerprint(root);
+  const module = await import(pathToFileURL(modulePath).href);
+  if (typeof module.sourceFingerprint !== 'function') {
+    throw new Error(`${modulePath} does not export sourceFingerprint`);
+  }
+  return module.sourceFingerprint(root);
+};
+
 /** Refuse measurements/screenshots made by a committed bundle from old source. */
 export async function assertFreshDemoBundle(page, root = process.cwd()) {
-  const expected = sourceFingerprint(root);
+  // A comparative performance run may load an older tree whose fingerprint
+  // contract is intentionally different from the candidate's. Validate that
+  // tree with the implementation that built it, not with today's algorithm.
+  const expected = await fingerprintForTree(root);
   const loaded = await page.evaluate(() => globalThis.__HOUSEPLAN_BUILD_FINGERPRINT__ ?? null);
   if (loaded !== expected) {
     throw new Error(

demo/golden/baselines/baselines-index.json

@@ -1,26 +1,37 @@
 {
   "schema": 1,
-  "matrixVersion": 13,
-  "acceptedAt": "2026-08-12T10:53:18.675Z",
-  "sourceFingerprint": "0581cf065ba06734ce9bd00277f3fbe18483ac09914323070e321cba319cdc68",
+  "matrixVersion": 19,
+  "acceptedAt": "2026-08-14T01:16:59.692Z",
+  "sourceFingerprint": "9c4070fd77873e165069512796ed2379a9abee8632afac520efbf42d0a0515ba",
   "chromium": "151.0.7922.34",
   "scenarios": {
-    "geometry-view-dark-fit": "a538deed6141b98b3e396d7da1024b18aee345312edd7954ad458751f08f48a3",
-    "geometry-view-light-fit": "0c57dee930f30a1f9c16e4e704675156f57a7623a4edf839c14a4fecbf12881c",
-    "geometry-plan-editor-dark": "9b4cf27319ec91b0d58ca9ad6f93db84938eb5ac52d92c60f18cb46741e4363d",
-    "geometry-devices-editor-dark": "c850e83f1af747f063b895109fe26d6a5804356fab505b0976073c28ad146104",
-    "geometry-decor-editor-dark": "44a95fd0b397c2729fea65c750fedcb11df10042ae198f3690151ead077c84e1",
-    "tray-wide-selection-en": "29dcae474864028eead4e661354c57340221f471c503366150e9ca6c76f65a2c",
-    "tray-wide-tool-ru": "7a5c9a9464a2efd28edde85bffcaf62dab48abde84566974c524fae19e5580b8",
-    "tray-medium-group-en": "79fcdf2815db456aa2934bce7982e09332d8d327ea7813e3f2c542e78f03ae90",
-    "tray-medium-selection-ru": "ab91e88583b2863305434ce2775e31328638414671ff0a4f8ee82c8274c04405",
-    "tray-narrow-palette-en": "fb63483e7101d457d7fb1c83ae50435410ed797771adcbfde14dc2798a000ce1",
-    "tray-narrow-tool-ru": "60ce3c75de88b72fdb5d3fe7a16790184a8265c74f0f97e5be4fd83dbe0259fd",
-    "geometry-diagonal-45-opening-dark": "a538deed6141b98b3e396d7da1024b18aee345312edd7954ad458751f08f48a3",
+    "split-corner-wall-before-dark": "3176dc67f54d5309f87c94e1077b4f69eb1db9f660469fbf97953038323430f3",
+    "split-corner-wall-thin-dark": "6da64905a3a4f8e4b4d457e5b20d2d55e0e7c2c601316a088c4bcc6557d35cc6",
+    "split-corner-wall-thick-dark": "494d559aa71ee85f90b8cfa11c1d3087fa123e963dec2b0975e7ce6c1520852a",
+    "isometric-geometry-view-dark": "4816ec4b22211c73765f9fac81741df685202d21df6b0fbc1649b23357086da3",
+    "isometric-geometry-view-light": "8ec81fc4f254ae6ebab55bc5f0ef5325a4e5d327cd1fb53bf5f293f06fbec671",
+    "isometric-live-layers-dark": "c841269f672c7ad8b208a549cc87592bd26f2a9e226f793a2b79592b65ee54c6",
+    "isometric-no-borders-dark": "36f972f95704bff81ea1a59bdf3cd2cf7b636ec7871780460e98b23e3ebc3da2",
+    "isometric-touch-kiosk-dark": "fd2e74c5966b4adcf4e66021e2cef781873f9a2b58f16ad19d57fb451ba45dc9",
+    "isometric-large-warm-remount-dark": "0afc1069d334f10be2d0ed135ee0eb52e9272a1a1ad1224e00f05753b8789d0c",
+    "geometry-view-dark-fit": "3df272f6c3c3d20e9e375ea037f3dbb885657b94b0b29d0067505f4a73741237",
+    "geometry-view-light-fit": "a7f2c9667d9872dd84a37d5318fd238c9eabcc0f413017eb19e02204587b4e1a",
+    "geometry-plan-editor-dark": "19b5c84943b70074ba1aae51d1e54f9a59c44dde34fff89e32f0babb1e90a2ca",
+    "opening-placement-door-thick-wall-dark": "395c03bbf5d968e83664fd6621f0ac25902e718022f2e92ffbcddb8ce629cf9c",
+    "geometry-devices-editor-dark": "a9e4846ce5453400b87e6ad3d575882bc23a07b59dc3eecb612ed872b0c871ec",
+    "geometry-decor-editor-dark": "435b36096bbb2996d56ff0af262ddebff4a727edd841b0fad9b8d4f507b987ac",
+    "tray-wide-selection-en": "024ac666ac4dac01a36f7d1fdbf3bb41f76a627377f7c02dc373f429dfe96d43",
+    "tray-wide-tool-ru": "669fc1cf04433b936c0e9d05799ad19eda8bc003d5ab71937d0512c8f49ba921",
+    "tray-medium-group-en": "50cd3980b21f554bec2e76f4d2e8032f4bd30c0679477eb2f5cbe22f68935b7c",
+    "tray-medium-selection-ru": "4e5f235be8ed6296e136641d172e727a6a6b7a9d061f0928a96ccc1103c19f1f",
+    "tray-narrow-palette-en": "88b9846e4b451ed95b7ae7d2c3183a2ea191d7668768992a1364c6a7a53eb0c6",
+    "tray-narrow-tool-ru": "c4130715b3cb31c68619dfc706a3aa308e86edf272bfae6833b20666764ece2b",
+    "geometry-diagonal-45-opening-dark": "01206d25631c8fd09fa077932fbb5c1ee115b65ba76b38e6f7b09315dbbf6002",
     "openings-thick-wall-dark": "5aa0b3d26894bef9ab9fca25c31bbef2f13f2c410f5f6d3f61c8d608ceb929f8",
-    "openings-filled-tunnel-dark": "074fb859d2ae1dc2ccd2045e2d6fb6d8389e430cbef20287419b8840cbbd5094",
+    "openings-filled-tunnel-dark": "167d92c11e6a8b3ff0f31177ac5905f8db4b5fb03ee78b4965c40bc45aeee50f",
     "openings-hidden-view-dark": "c85cc04d1d8622b98215e2bb83f5bb233a7cfb0ac684c912475ef7bc44245897",
     "lighting-glow-sun-dark": "a98eee332f25a43c8d9d126c118c8cfea4ee73752b1060227548efedaf0efcdd",
+    "device-value-badge-positions-dark": "1ad43f2bd866733aa75c34de38fb97d469661799b540a8ae22150067d788cec8",
     "lighting-sun-window-state-only-dark": "3bd581a23a2e0ebba58530db5182adea5cba6ec10bc032bee024415c19108a17",
     "lighting-fill-light-axis-split-dark": "4f867528aeb9124229f81659876b03ff297a3a7a92bc57ffb32d5c24913c4938",
     "lighting-fill-temp-axis-split-dark": "e0535b70701c9fe6753f74c943b9f288a0fb1a23a9cfc8590d4945e0a1724eb5",
@@ -34,15 +45,15 @@
     "lighting-temp-glow-room-override-dark": "0a35d3508526187ea18e44456cfb8cd9e578a1864e896fad1c3eec2892c753e0",
     "lighting-manual-auto-spill-overlap-dark": "6324dbe2079a255e7a194720c8c19f210549ac734e564270bc1373e6385b9cac",
     "hover-over-glow-dark": "fc14ba6f6b670e61c0fb5be277e67551ea2da7a06b5c167a8c2c989f1de08910",
-    "hover-nested-room-dark": "b70e385829a4fe45a77f5e1c3f8af4e18efec5282fb9594b26fab08c1f113d52",
+    "hover-nested-room-dark": "6c09526ad885c4555063def5b43287b41124a81d90972c425084dba6e622d055",
     "large-house-zoom-040-dark": "5f11c4b78318a64c2a7cf803716661eea506609d4f0a6bb3d64a709f8c49db1d",
     "large-house-zoom-250-dark": "c906426f888ff4e306c5c334c6329b387fc5ca368e229f55acc33c202351a1ac",
     "large-house-warm-remount-dark": "6baf4baed1c735c64dfe1e69d9864ca287ffc0e8452d00e801f0873e98b187ee",
-    "device-dialog-desktop-en": "87b893df5f5f2d75cbf022edcb353a519e0221595c64ced993246cfb5c9f9c22",
-    "device-dialog-mobile-ru": "69fc5f5d9640b68893e5143890b69ca63a1a7817a4aa6a3cf04b3c6162ae4510",
-    "device-help-popover-light-ru": "0fd2b02c33f9cd3af3e8bd5f326a4b1e52f02875ec4ef02255b45b215aeb76c4",
-    "decor-color-popover-mobile-ru": "16d2859d1ed3715c1c4d3d451a8428c37e91ba00da17272c59cf83420a7b6c31",
-    "backup-full-preview-desktop-en": "7f12943d1027c89f6fe46978fa1f4e1bcdbf85a1216281d850d467e68f52cbda",
-    "backup-space-preview-mobile-ru": "998c6b52c1cc95109feb440a9966cade738154ceeae387246d40f8c56f9e8a3a"
+    "device-dialog-desktop-en": "d6fcc83aa1335df1041e2b1aa445b0019d1e3567f98ef8f47a889894051f2b62",
+    "device-dialog-mobile-ru": "8cb928853ddacb61882804c3d00ead31da31bc4559ee6a8e293ef6b55cd5a463",
+    "device-help-popover-light-ru": "f1bf21d62a5dd349aa57b746069c5aef58d7a26b0b9d9e0c233fde0c1d56d7eb",
+    "decor-color-popover-mobile-ru": "46d4c2e4dd20c3a38e90efe3db59b3e878bdbcf273fbc1aa23de4b230723fa6e",
+    "backup-full-preview-desktop-en": "cc42a621f55f043b272014b9c32127823ca3573520e502966c71642027f7fdaf",
+    "backup-space-preview-mobile-ru": "16d06859ea6aac6cbed586f0d6918da972e9c95206fffd771fe43b6084f79877"
   }
 }

demo/golden/harness.mjs

@@ -1,5 +1,5 @@
 import { makeLargeHouseFixture } from '../fixtures/large-house.mjs';
-import { makeVisualMatrixFixture } from '../fixtures/visual-matrix.mjs';
+import { fixtureWallKey, makeVisualMatrixFixture } from '../fixtures/visual-matrix.mjs';
 
 const fixtureFor = (name) => name === 'large' ? makeLargeHouseFixture() : makeVisualMatrixFixture();
 
@@ -51,6 +51,34 @@ async function stableEnvironment(page, scenario) {
 /** Apply every data-only scenario override before the fixture crosses into the browser. */
 export function prepareGoldenFixture(scenario) {
   const fixture = fixtureFor(scenario.fixture);
+  if (scenario.cornerSplitWall) {
+    const stage = scenario.cornerSplitWall;
+    if (!['before', 'thin', 'thick'].includes(stage))
+      throw new Error(`unknown cornerSplitWall stage: ${stage}`);
+    const a = [0.10, 0.10], tr = [0.90, 0.10], split = [0.90, 0.50];
+    const br = [0.90, 0.90], bl = [0.10, 0.90];
+    const entry = (from, to, cm) => ({
+      key: fixtureWallKey(from, to), a: [...from], b: [...to], cm,
+    });
+    const before = stage === 'before';
+    fixture.config.spaces.push({
+      id: scenario.space,
+      name: 'Corner Split',
+      rooms: before
+        ? [{ id: 'corner-source', name: 'Before Split', area: null, poly: [a, tr, br, bl] }]
+        : [
+          { id: 'corner-source', name: 'Main room', area: null, poly: [a, tr, split] },
+          { id: 'corner-fresh', name: 'New room', area: null, poly: [split, br, bl, a] },
+        ],
+      walls: before
+        ? [entry(a, tr, 15), entry(tr, br, 15), entry(br, bl, 15), entry(bl, a, 15)]
+        : [
+          entry(a, tr, 15), entry(tr, split, 15), entry(split, br, 15),
+          entry(br, bl, 15), entry(bl, a, 15), entry(a, split, stage === 'thin' ? 15 : 100),
+        ],
+      settings: { show_borders: true, fill_mode: 'custom', custom_fill: { c: '#536b82', a: 0.42 } },
+    });
+  }
   const requireSpace = () => {
     const space = fixture.config.spaces.find((item) => item.id === scenario.space);
     if (!space) throw new Error(`golden override references missing space: ${scenario.space}`);
@@ -62,13 +90,14 @@ export function prepareGoldenFixture(scenario) {
     fixture.devices[scenario.deviceId].name = scenario.deviceName;
   }
   if (scenario.fillMode || typeof scenario.glowEnabled === 'boolean'
-      || typeof scenario.sunRays === 'boolean') {
+      || typeof scenario.sunRays === 'boolean' || typeof scenario.showBorders === 'boolean') {
     const space = requireSpace();
     space.settings = {
       ...(space.settings || {}),
       ...(scenario.fillMode ? { fill_mode: scenario.fillMode } : {}),
       ...(typeof scenario.glowEnabled === 'boolean' ? { glow_enabled: scenario.glowEnabled } : {}),
       ...(typeof scenario.sunRays === 'boolean' ? { sun_rays: scenario.sunRays } : {}),
+      ...(typeof scenario.showBorders === 'boolean' ? { show_borders: scenario.showBorders } : {}),
       ...(scenario.customFill ? { custom_fill: scenario.customFill } : {}),
     };
   }
@@ -84,6 +113,22 @@ export function prepareGoldenFixture(scenario) {
     }
     space.openings = [...(space.openings || []), ...structuredClone(scenario.extraOpenings)];
   }
+  if (scenario.openingGeometry) {
+    const space = requireSpace();
+    const opening = (space.openings || []).find(
+      (item) => item.id === scenario.openingGeometry.id,
+    );
+    if (!opening || opening.type !== scenario.openingGeometry.type
+        || Math.abs(Number(opening.angle) - scenario.openingGeometry.angle) > 0.001) {
+      throw new Error(
+        `golden openingGeometry references a missing/mismatched opening: `
+        + `${scenario.openingGeometry.id}`,
+      );
+    }
+    // This scenario must not remain byte-identical to the generic geometry
+    // capture: isolate the intended diagonal symbol in the rendered fixture.
+    space.openings = [opening];
+  }
   if (scenario.wallReplacements?.length) {
     const space = requireSpace();
     const samePoint = (a, b) => Array.isArray(a) && Array.isArray(b)
@@ -143,7 +188,13 @@ export function prepareGoldenFixture(scenario) {
   }
   if (scenario.markerOverrides) {
     const ids = new Set(scenario.markerOverrides.map((marker) => marker.id));
-    const known = new Set((fixture.config.markers || []).map((marker) => marker.id));
+    // Runtime devices without explicit marker settings are still valid saved
+    // marker targets. A visual scenario may materialize their first setting,
+    // just like the real device dialog does on save.
+    const known = new Set([
+      ...(fixture.config.markers || []).map((marker) => marker.id),
+      ...Object.keys(fixture.devices || {}),
+    ]);
     const missing = [...ids].filter((id) => !known.has(id));
     if (missing.length) throw new Error(`golden markerOverrides reference missing marker(s): ${missing.join(', ')}`);
     fixture.config.markers = [
@@ -182,10 +233,21 @@ export async function prepareGoldenScenario(page, scenario) {
     window.__goldenCard?.remove?.();
     window.__card?.remove?.();
     localStorage.clear();
+    history.replaceState(null, '', scenario.labs?.length
+      ? `?hp-labs=${encodeURIComponent(scenario.labs.join(','))}` : location.pathname);
+    if (scenario.labs?.length) {
+      localStorage.setItem('houseplan_card_labs_v1', JSON.stringify(scenario.labs));
+    }
+    if (scenario.projection && scenario.space) {
+      localStorage.setItem('houseplan_card_view_v1', JSON.stringify({
+        [scenario.space]: scenario.projection,
+      }));
+    }
     const host = document.getElementById('host');
     const cardConfig = {
       type: 'custom:houseplan-card', title: `Golden ${scenario.id}`, icon_size: 3.4,
       language: scenario.language || 'en',
+      ...(scenario.kiosk ? { kiosk: true } : {}),
     };
     const hassFor = () => ({
       language: scenario.language || 'en', locale: { language: scenario.language || 'en' },
@@ -246,11 +308,59 @@ export async function prepareGoldenScenario(page, scenario) {
       await card.updateComplete;
       await settleMode(card);
     }
+    if (scenario.projection === 'iso' && typeof card._setProjection === 'function') {
+      card._setProjection('iso');
+      await card.updateComplete;
+      await frame();
+    }
     if (Number.isFinite(scenario.zoom)) {
       card._applyView(scenario.zoom, 500, 500);
       card.requestUpdate();
       await card.updateComplete;
     }
+    if (scenario.openingPreview) {
+      const { type, pointer } = scenario.openingPreview;
+      if (!['window', 'door', 'gate'].includes(type)
+        || !Array.isArray(pointer) || pointer.length !== 2
+        || !pointer.every(Number.isFinite)) {
+        throw new Error(`invalid golden openingPreview: ${scenario.id}`);
+      }
+      card._activateOpeningPlacement(type);
+      card.requestUpdate();
+      await card.updateComplete;
+      await frame();
+      // Exercise the production pointer path after the toolbar update has
+      // settled. Writing `_cursorPt` before that update is racy: replacing the
+      // stage under Chromium's real pointer legitimately emits pointerleave
+      // and clears the preview before capture.
+      const svgRoot = card.renderRoot.querySelector('.stage svg');
+      const stage = card.renderRoot.querySelector('.stage');
+      const screen = new DOMPoint(pointer[0] * 1000, pointer[1] * card._spaceH)
+        .matrixTransform(svgRoot.getScreenCTM());
+      stage.dispatchEvent(new PointerEvent('pointermove', {
+        bubbles: true, composed: true, pointerId: 991, pointerType: 'mouse',
+        clientX: screen.x, clientY: screen.y,
+      }));
+      await card.updateComplete;
+      await frame();
+      const preview = card.renderRoot.querySelector(`.opening-preview[data-kind="${type}"]`);
+      if (!preview || !preview.querySelector('.op-leaf')) {
+        const intervals = card._openingPlacementIntervalsCache?.value || [];
+        const nearest = intervals.map((interval) => {
+          const [px, py] = card._cursorPt || [0, 0];
+          const [ax, ay] = interval.a, [bx, by] = interval.b;
+          const dx = bx - ax, dy = by - ay, length2 = dx * dx + dy * dy || 1;
+          const t = Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / length2));
+          return {
+            a: interval.a, b: interval.b, cm: interval.cm, open: interval.open,
+            kind: interval.kind,
+            distance: Math.hypot(px - (ax + dx * t), py - (ay + dy * t)),
+          };
+        }).sort((a, b) => a.distance - b.distance).slice(0, 3);
+        throw new Error(`golden opening preview did not render: ${scenario.id}; `
+          + `cursor=${JSON.stringify(card._cursorPt)} nearest=${JSON.stringify(nearest)}`);
+      }
+    }
     if (scenario.editorTray) {
       let expectedKind = '';
       if (scenario.editorTray === 'plan-selection') {

demo/golden/matrix.mjs

@@ -1,19 +1,49 @@
 import { fixtureWallKey } from '../fixtures/visual-matrix.mjs';
 
 /** Data-only HP-QA-01 capture matrix. Bump when framing or scenarios change. */
-export const GOLDEN_MATRIX_VERSION = 13;
+export const GOLDEN_MATRIX_VERSION = 19;
 
 const stage = { capture: 'stage', threshold: { maxChannelDelta: 10, maxDiffRatio: 0.0005 } };
 const page = { capture: 'page', threshold: { maxChannelDelta: 10, maxDiffRatio: 0.0008 } };
 const sunWindow = { capture: 'sun-window', threshold: { maxChannelDelta: 10, maxDiffRatio: 0.001 } };
 
 export const GOLDEN_SCENARIOS = Object.freeze([
+  { id: 'split-corner-wall-before-dark', fixture: 'visual', space: 'golden-corner-split',
+    cornerSplitWall: 'before', mode: 'view', theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
+  { id: 'split-corner-wall-thin-dark', fixture: 'visual', space: 'golden-corner-split',
+    cornerSplitWall: 'thin', mode: 'view', theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
+  { id: 'split-corner-wall-thick-dark', fixture: 'visual', space: 'golden-corner-split',
+    cornerSplitWall: 'thick', mode: 'view', theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
+  { id: 'isometric-geometry-view-dark', fixture: 'visual', space: 'golden-geometry', mode: 'view',
+    // Stage 2 material/floor-edge plus door, window, gate and nested-room coverage.
+    labs: ['iso'], projection: 'iso', theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
+  { id: 'isometric-geometry-view-light', fixture: 'visual', space: 'golden-geometry', mode: 'view',
+    labs: ['iso'], projection: 'iso', theme: 'light', viewport: { width: 1000, height: 900 }, ...stage },
+  { id: 'isometric-live-layers-dark', fixture: 'visual', space: 'golden-lighting', mode: 'view',
+    labs: ['iso'], projection: 'iso', theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
+  { id: 'isometric-no-borders-dark', fixture: 'visual', space: 'golden-lighting', mode: 'view',
+    labs: ['iso'], projection: 'iso', showBorders: false, fillMode: 'custom',
+    customFill: { c: '#486a8f', a: 0.42 }, glowEnabled: true,
+    theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
+  { id: 'isometric-touch-kiosk-dark', fixture: 'visual', space: 'golden-geometry', mode: 'view',
+    labs: ['iso'], projection: 'iso', kiosk: true,
+    theme: 'dark', viewport: { width: 390, height: 760 }, ...stage },
+  { id: 'isometric-large-warm-remount-dark', fixture: 'large', space: 'perf-floor-2', mode: 'view',
+    labs: ['iso'], projection: 'iso', warmRemount: true,
+    theme: 'dark', viewport: { width: 1180, height: 900 }, ...stage },
   { id: 'geometry-view-dark-fit', fixture: 'visual', space: 'golden-geometry', mode: 'view',
     theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
   { id: 'geometry-view-light-fit', fixture: 'visual', space: 'golden-geometry', mode: 'view',
     theme: 'light', viewport: { width: 1000, height: 900 }, ...stage },
   { id: 'geometry-plan-editor-dark', fixture: 'visual', space: 'golden-geometry', mode: 'plan',
     theme: 'dark', viewport: { width: 1180, height: 900 }, ...page },
+  { id: 'opening-placement-door-thick-wall-dark', fixture: 'visual', space: 'golden-geometry',
+    // The shared centre edge is a long 25 cm physical wall. It can contain the
+    // complete 90 cm door preset while still proving rotation, inner-face
+    // offset and ruler placement on a thick wall.
+    mode: 'plan', openingPreview: { type: 'door', pointer: [0.48, 0.65] },
+    openingPreviewPixels: { minPixels: 150, minInsideWallPixels: 8, minChannelDelta: 4 },
+    theme: 'dark', viewport: { width: 1180, height: 900 }, ...page },
   { id: 'geometry-devices-editor-dark', fixture: 'visual', space: 'golden-geometry', mode: 'devices',
     theme: 'dark', viewport: { width: 1180, height: 900 }, ...page },
   { id: 'geometry-decor-editor-dark', fixture: 'visual', space: 'golden-geometry', mode: 'decor',
@@ -39,6 +69,7 @@ export const GOLDEN_SCENARIOS = Object.freeze([
     editorTray: 'decor-tool', language: 'ru', theme: 'dark',
     viewport: { width: 390, height: 760 }, ...page },
   { id: 'geometry-diagonal-45-opening-dark', fixture: 'visual', space: 'golden-geometry', mode: 'view',
+    openingGeometry: { id: 'geo-diagonal-window', type: 'window', angle: 45 },
     theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
   { id: 'openings-thick-wall-dark', fixture: 'visual', space: 'golden-lighting', mode: 'view',
     fillMode: 'none', glowEnabled: false, theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
@@ -52,12 +83,38 @@ export const GOLDEN_SCENARIOS = Object.freeze([
         { key: fixtureWallKey([0.5, 0.5], [0.5, 0.88]), a: [0.5, 0.5], b: [0.5, 0.88], cm: 32 },
       ],
     }],
-    tunnelContinuity: { openingId: 'light-door', insetPx: 2, maxChannelJump: 3 },
+    tunnelContinuity: { openingId: 'light-door', insetPx: 2, maxChannelJump: 3, dpr2: true },
     theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
   { id: 'openings-hidden-view-dark', fixture: 'visual', space: 'golden-lighting', mode: 'view',
     fillMode: 'none', glowEnabled: false, hideOpenings: true, theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
   { id: 'lighting-glow-sun-dark', fixture: 'visual', space: 'golden-lighting', mode: 'view',
     theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
+  { id: 'device-value-badge-positions-dark', fixture: 'visual', space: 'golden-lighting', mode: 'view',
+    glowEnabled: false, sunRays: false,
+    markerOverrides: [
+      { id: 'golden-light-one', binding: 'device:golden-light-one', value_badge: {
+        enabled: true, source: { kind: 'entity_state', entity_id: 'light.golden_light_one' }, position: 'right',
+      } },
+      { id: 'golden-light-two', binding: 'device:golden-light-two', value_badge: {
+        enabled: true, source: { kind: 'entity_state', entity_id: 'light.golden_light_two' }, position: 'left',
+      } },
+      { id: 'golden-presence', binding: 'device:golden-presence', value_badge: {
+        enabled: true, source: { kind: 'entity_state', entity_id: 'binary_sensor.golden_presence' }, position: 'top',
+      } },
+      { id: 'golden-climate', binding: 'device:golden-climate', value_badge: {
+        enabled: true,
+        source: { kind: 'entity_attribute', entity_id: 'climate.golden_climate', attribute: 'current_temperature' },
+        position: 'bottom',
+      } },
+    ],
+    stateOverrides: { 'climate.golden_climate': { attributes: { lqi: 190 } } },
+    layoutOverrides: {
+      'golden-light-one': { s: 'golden-lighting', x: 0.20, y: 0.32 },
+      'golden-light-two': { s: 'golden-lighting', x: 0.20, y: 0.72 },
+      'golden-presence': { s: 'golden-lighting', x: 0.80, y: 0.68 },
+      'golden-climate': { s: 'golden-lighting', x: 0.80, y: 0.28 },
+    },
+    theme: 'dark', viewport: { width: 1000, height: 900 }, ...stage },
   { id: 'lighting-sun-window-state-only-dark', fixture: 'visual', space: 'golden-lighting', mode: 'view',
     // The golden screenshot is backed by a second, sun-layer-hidden capture.
     // A real painted ray must account for enough changed pixels; DOM-only

demo/golden/run.mjs

@@ -135,6 +135,35 @@ async function captureWithoutSunRays(page, screenshotOptions) {
   }
 }
 
+/** Capture a control frame with only the transient opening symbol hidden.
+ * Comparing it with the actual frame proves the preview paints browser pixels;
+ * the smoke test separately locks its DOM order above the wall body. */
+async function captureWithoutOpeningPreview(page, screenshotOptions) {
+  const layerState = await page.evaluate(async () => {
+    const card = window.__goldenCard;
+    const parts = [...(card?.renderRoot?.querySelectorAll(
+      '.opening-preview, .opening-preview-dot',
+    ) || [])];
+    if (!parts.length) throw new Error('semantic golden opening preview is missing');
+    const previous = parts.map((part) => part.style.visibility);
+    for (const part of parts) part.style.visibility = 'hidden';
+    await new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)));
+    return { previous, count: parts.length };
+  });
+  try {
+    return { png: await page.screenshot(screenshotOptions), parts: layerState.count };
+  } finally {
+    await page.evaluate(async (previous) => {
+      const card = window.__goldenCard;
+      const parts = [...(card?.renderRoot?.querySelectorAll(
+        '.opening-preview, .opening-preview-dot',
+      ) || [])];
+      parts.forEach((part, index) => { part.style.visibility = previous[index] || ''; });
+      await new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)));
+    }, layerState.previous);
+  }
+}
+
 async function countChangedPixels(page, actual, control, spec) {
   return page.evaluate(async ({ actual64, control64, minChannelDelta }) => {
     const decode = async (base64) => {
@@ -143,7 +172,7 @@ async function countChangedPixels(page, actual, control, spec) {
     };
     const [actualImage, controlImage] = await Promise.all([decode(actual64), decode(control64)]);
     if (actualImage.width !== controlImage.width || actualImage.height !== controlImage.height)
-      throw new Error('semantic golden sun control has different dimensions');
+      throw new Error('semantic golden control frame has different dimensions');
     const canvas = document.createElement('canvas');
     const controlCanvas = document.createElement('canvas');
     canvas.width = controlCanvas.width = actualImage.width;
@@ -173,6 +202,82 @@ async function countChangedPixels(page, actual, control, spec) {
   });
 }
 
+/** Count preview pixels which are actually painted over the physical wall
+ * fill. A global changed-pixel threshold can pass even when the complete
+ * symbol is accidentally hidden below masonry because its swing arc remains
+ * outside the body. */
+async function countOpeningPreviewPixelsInsideWall(
+  page, actual, control, clip, minChannelDelta,
+) {
+  return page.evaluate(async ({ actual64, control64, clipRect, minDelta }) => {
+    const decode = async (base64) => {
+      const bytes = Uint8Array.from(atob(base64), (char) => char.charCodeAt(0));
+      return createImageBitmap(new Blob([bytes], { type: 'image/png' }));
+    };
+    const [actualImage, controlImage] = await Promise.all([decode(actual64), decode(control64)]);
+    const canvas = document.createElement('canvas');
+    const controlCanvas = document.createElement('canvas');
+    canvas.width = controlCanvas.width = actualImage.width;
+    canvas.height = controlCanvas.height = actualImage.height;
+    const context = canvas.getContext('2d', { willReadFrequently: true });
+    const controlContext = controlCanvas.getContext('2d', { willReadFrequently: true });
+    context.drawImage(actualImage, 0, 0);
+    controlContext.drawImage(controlImage, 0, 0);
+    const pixels = context.getImageData(0, 0, canvas.width, canvas.height).data;
+    const controls = controlContext.getImageData(0, 0, canvas.width, canvas.height).data;
+    const card = window.__goldenCard;
+    const preview = card?.renderRoot?.querySelector('.opening-preview');
+    const walls = [...(card?.renderRoot?.querySelectorAll('.wallbody-fill') || [])]
+      .map((wall) => {
+        const matrix = wall.getScreenCTM?.();
+        return matrix ? { wall, rect: wall.getBoundingClientRect(), inverse: matrix.inverse() } : null;
+      })
+      .filter(Boolean);
+    if (!preview || !walls.length) return { changed: 0, sampled: 0 };
+    const previewRect = preview.getBoundingClientRect();
+    const candidates = walls.filter(({ rect }) => rect.right >= previewRect.left
+      && rect.left <= previewRect.right && rect.bottom >= previewRect.top
+      && rect.top <= previewRect.bottom);
+    if (!candidates.length) return { changed: 0, sampled: 0 };
+    const left = Math.ceil(previewRect.left);
+    const top = Math.ceil(previewRect.top);
+    const right = Math.floor(previewRect.right);
+    const bottom = Math.floor(previewRect.bottom);
+    const originX = clipRect?.x || 0;
+    const originY = clipRect?.y || 0;
+    let changed = 0;
+    let sampled = 0;
+    for (let y = top; y <= bottom; y++) {
+      for (let x = left; x <= right; x++) {
+        const screenPoint = new DOMPoint(x + 0.5, y + 0.5);
+        const insideWall = candidates.some(({ wall, rect, inverse }) => {
+          if (x < rect.left || x > rect.right || y < rect.top || y > rect.bottom) return false;
+          return wall.isPointInFill(screenPoint.matrixTransform(inverse));
+        });
+        if (!insideWall) continue;
+        const px = Math.round(x - originX);
+        const py = Math.round(y - originY);
+        if (px < 0 || py < 0 || px >= canvas.width || py >= canvas.height) continue;
+        sampled += 1;
+        const offset = (py * canvas.width + px) * 4;
+        const delta = Math.max(
+          Math.abs(pixels[offset] - controls[offset]),
+          Math.abs(pixels[offset + 1] - controls[offset + 1]),
+          Math.abs(pixels[offset + 2] - controls[offset + 2]),
+          Math.abs(pixels[offset + 3] - controls[offset + 3]),
+        );
+        if (delta >= minDelta) changed += 1;
+      }
+    }
+    return { changed, sampled };
+  }, {
+    actual64: actual.toString('base64'),
+    control64: control.toString('base64'),
+    clipRect: clip || null,
+    minDelta: minChannelDelta,
+  });
+}
+
 /** Assert scenario semantics against the actual capture, not only its data.
  *  This protects a reviewed-but-empty baseline from becoming the reference. */
 async function countWarmPixels(page, png, region) {
@@ -237,10 +342,10 @@ async function countHelpTextPixels(page, png, clip, spec) {
   }, { png64: png.toString('base64'), clip, spec });
 }
 
-/** Detect one-pixel SVG seams inside a room-coloured opening tunnel. The
- * opening symbol is hidden by the scenario, so both centre lines should be a
- * locally constant translucent surface. Sampling both axes catches the wall
- * centre split as well as boundaries between atomic wall-profile pieces. */
+/** Detect one-pixel SVG seams inside a room-coloured opening tunnel. Sample a
+ * narrow strip around local y=0: this crosses the join between both tunnel
+ * half-faces at any opening angle while excluding legitimate outer-profile
+ * steps where adjacent wall intervals have different physical thicknesses. */
 async function inspectTunnelContinuity(page, png, clip, spec) {
   return page.evaluate(async ({ png64, clip, spec }) => {
     const card = window.__goldenCard;
@@ -249,6 +354,10 @@ async function inspectTunnelContinuity(page, png, clip, spec) {
     );
     if (!tunnel) throw new Error(`semantic golden tunnel missing: ${spec.openingId}`);
     const rect = tunnel.getBoundingClientRect();
+    const matrix = tunnel.getScreenCTM();
+    if (!matrix) throw new Error(`semantic golden tunnel has no screen transform: ${spec.openingId}`);
+    const inverse = matrix.inverse();
+    const localBounds = tunnel.getBBox();
     const bytes = Uint8Array.from(atob(png64), (char) => char.charCodeAt(0));
     const image = await createImageBitmap(new Blob([bytes], { type: 'image/png' }));
     const canvas = document.createElement('canvas');
@@ -257,10 +366,19 @@ async function inspectTunnelContinuity(page, png, clip, spec) {
     const context = canvas.getContext('2d', { willReadFrequently: true });
     context.drawImage(image, 0, 0);
     const originX = clip?.x || 0, originY = clip?.y || 0;
-    const left = Math.max(0, Math.ceil(rect.left - originX) + spec.insetPx);
-    const top = Math.max(0, Math.ceil(rect.top - originY) + spec.insetPx);
-    const right = Math.min(image.width - 1, Math.floor(rect.right - originX) - spec.insetPx);
-    const bottom = Math.min(image.height - 1, Math.floor(rect.bottom - originY) - spec.insetPx);
+    // Screenshots may be captured at DPR > 1. DOMRect/clip are CSS pixels,
+    // image coordinates are device pixels, so derive the scale instead of
+    // silently sampling the wrong strip at high DPI.
+    const cssWidth = clip?.width || document.documentElement.clientWidth;
+    const cssHeight = clip?.height || document.documentElement.clientHeight;
+    const scaleX = image.width / Math.max(1, cssWidth);
+    const scaleY = image.height / Math.max(1, cssHeight);
+    const insetX = Math.max(1, Math.round(spec.insetPx * scaleX));
+    const insetY = Math.max(1, Math.round(spec.insetPx * scaleY));
+    const left = Math.max(0, Math.ceil((rect.left - originX) * scaleX) + insetX);
+    const top = Math.max(0, Math.ceil((rect.top - originY) * scaleY) + insetY);
+    const right = Math.min(image.width - 1, Math.floor((rect.right - originX) * scaleX) - insetX);
+    const bottom = Math.min(image.height - 1, Math.floor((rect.bottom - originY) * scaleY) - insetY);
     if (right - left < 3 || bottom - top < 3)
       throw new Error(`semantic golden tunnel is too small: ${left},${top},${right},${bottom}`);
     const pixels = context.getImageData(0, 0, image.width, image.height).data;
@@ -268,17 +386,45 @@ async function inspectTunnelContinuity(page, png, clip, spec) {
       const offset = (y * image.width + x) * 4;
       return [pixels[offset], pixels[offset + 1], pixels[offset + 2]];
     };
-    let maxJump = 0, samplePairs = 0;
-    const compare = (a, b) => {
-      maxJump = Math.max(maxJump,
+    let maxJump = 0, maxPair = null, samplePairs = 0;
+    const compare = (a, b, x, y, direction) => {
+      const jump = Math.max(
         Math.abs(a[0] - b[0]), Math.abs(a[1] - b[1]), Math.abs(a[2] - b[2]));
+      if (jump > maxJump) {
+        maxJump = jump;
+        maxPair = { x, y, direction, a, b };
+      }
       samplePairs++;
     };
-    const centreX = Math.round((left + right) / 2);
-    const centreY = Math.round((top + bottom) / 2);
-    for (let x = left + 1; x <= right; x++) compare(rgb(x - 1, centreY), rgb(x, centreY));
-    for (let y = top + 1; y <= bottom; y++) compare(rgb(centreX, y - 1), rgb(centreX, y));
-    return { maxJump, samplePairs, bounds: [left, top, right, bottom] };
+    const localXScale = Math.max(1e-6, Math.hypot(matrix.a, matrix.b));
+    const localYScale = Math.max(1e-6, Math.hypot(matrix.c, matrix.d));
+    const endInset = Math.max(1, spec.insetPx) / localXScale;
+    const axisBand = Math.max(1.5, spec.axisBandPx || 2.5) / localYScale;
+    const insideAxisBand = (x, y) => {
+      const cssX = originX + (x + 0.5) / scaleX;
+      const cssY = originY + (y + 0.5) / scaleY;
+      const local = new DOMPoint(cssX, cssY).matrixTransform(inverse);
+      return local.x >= localBounds.x + endInset
+        && local.x <= localBounds.x + localBounds.width - endInset
+        && Math.abs(local.y) <= axisBand;
+    };
+    for (let y = top; y <= bottom; y++) {
+      for (let x = left + 1; x <= right; x++) {
+        if (insideAxisBand(x - 1, y) && insideAxisBand(x, y))
+          compare(rgb(x - 1, y), rgb(x, y), x, y, 'horizontal');
+      }
+    }
+    for (let x = left; x <= right; x++) {
+      for (let y = top + 1; y <= bottom; y++) {
+        if (insideAxisBand(x, y - 1) && insideAxisBand(x, y))
+          compare(rgb(x, y - 1), rgb(x, y), x, y, 'vertical');
+      }
+    }
+    if (!samplePairs) throw new Error(`semantic golden tunnel axis strip is empty: ${spec.openingId}`);
+    return {
+      maxJump, maxPair, samplePairs, bounds: [left, top, right, bottom],
+      scale: [scaleX, scaleY],
+    };
   }, { png64: png.toString('base64'), clip, spec });
 }
 
@@ -289,11 +435,13 @@ if (existsSync(baselineManifestPath)) {
   catch { baselineManifest = { invalid: true }; }
 }
 
+const browserArgs = ['--force-color-profile=srgb', '--font-render-hinting=none', '--disable-lcd-text'];
+const browserContext = { locale: 'en-US', timezoneId: 'UTC', colorScheme: 'dark', reducedMotion: 'reduce' };
 const { page, browser } = await launch(
   { width: 1000, height: 900 },
   1,
-  ['--force-color-profile=srgb', '--font-render-hinting=none', '--disable-lcd-text'],
-  { locale: 'en-US', timezoneId: 'UTC', colorScheme: 'dark', reducedMotion: 'reduce' },
+  browserArgs,
+  browserContext,
 );
 const chromium = await browser.version();
 const results = [];
@@ -313,6 +461,42 @@ try {
       pageErrors.length = 0;
       result.runtime = await prepareGoldenScenario(page, scenario);
       if (pageErrors.length) throw new Error(`browser exception: ${pageErrors.join(' | ')}`);
+      if (scenario.openingGeometry) {
+        result.openingGeometry = await page.evaluate((expected) => {
+          const card = window.__goldenCard;
+          const opening = card?.renderRoot?.querySelector(
+            `.opening[data-id="${CSS.escape(expected.id)}"]`,
+          );
+          if (!opening) return null;
+          const transform = opening.getAttribute('transform') || '';
+          const angle = Number(transform.match(/rotate\(([-+0-9.eE]+)\)/)?.[1]);
+          const painted = [...opening.querySelectorAll('.op-leaf, .op-arc, .op-glass')]
+            .map((part) => part.getBoundingClientRect())
+            .filter((rect) => rect.width > 0 || rect.height > 0);
+          const bounds = painted.length ? {
+            width: Math.max(...painted.map((rect) => rect.right))
+              - Math.min(...painted.map((rect) => rect.left)),
+            height: Math.max(...painted.map((rect) => rect.bottom))
+              - Math.min(...painted.map((rect) => rect.top)),
+          } : { width: 0, height: 0 };
+          return {
+            type: opening.getAttribute('data-kind'), angle,
+            width: bounds.width, height: bounds.height,
+            visibleParts: opening.querySelectorAll('.op-leaf, .op-arc, .op-glass').length,
+          };
+        }, scenario.openingGeometry);
+        const expected = scenario.openingGeometry;
+        const actualOpening = result.openingGeometry;
+        if (!actualOpening || actualOpening.type !== expected.type
+            || Math.abs(actualOpening.angle - expected.angle) > 0.001
+            || actualOpening.width <= 0 || actualOpening.height <= 0
+            || actualOpening.visibleParts <= 0) {
+          throw new Error(
+            `semantic golden opening geometry failed for ${expected.id}: `
+            + JSON.stringify(actualOpening),
+          );
+        }
+      }
       const clip = await goldenClip(page, scenario.capture);
       const screenshotOptions = {
         ...(clip ? { clip } : {}),
@@ -338,6 +522,38 @@ try {
           );
         }
       }
+      if (scenario.openingPreviewPixels) {
+        const control = await captureWithoutOpeningPreview(page, screenshotOptions);
+        const sample = await countChangedPixels(
+          page, actual, control.png, scenario.openingPreviewPixels,
+        );
+        result.openingPreviewParts = control.parts;
+        result.openingPreviewChangedPixels = sample.changed;
+        result.openingPreviewMaxChannelDelta = sample.maxDelta;
+        const insideWall = await countOpeningPreviewPixelsInsideWall(
+          page, actual, control.png, clip, scenario.openingPreviewPixels.minChannelDelta,
+        );
+        result.openingPreviewPixelsInsideWall = insideWall.changed;
+        result.openingPreviewWallSamples = insideWall.sampled;
+        if (control.parts < 2) {
+          throw new Error(
+            `semantic golden assertion failed: opening preview is incomplete (${control.parts} parts)`,
+          );
+        }
+        if (sample.changed < scenario.openingPreviewPixels.minPixels) {
+          throw new Error(
+            `semantic golden assertion failed: opening preview paints ${sample.changed} pixels, `
+            + `expected at least ${scenario.openingPreviewPixels.minPixels}`,
+          );
+        }
+        if (insideWall.changed < scenario.openingPreviewPixels.minInsideWallPixels) {
+          throw new Error(
+            `semantic golden assertion failed: opening preview paints ${insideWall.changed} pixels `
+            + `inside the wall body, expected at least `
+            + `${scenario.openingPreviewPixels.minInsideWallPixels}`,
+          );
+        }
+      }
       if (scenario.warmPixelRegion) {
         const sample = await countWarmPixels(page, actual, scenario.warmPixelRegion);
         result.warmPixels = sample.warm;
@@ -365,8 +581,10 @@ try {
           page, actual, clip, scenario.tunnelContinuity,
         );
         result.tunnelMaxChannelJump = sample.maxJump;
+        result.tunnelMaxJumpPair = sample.maxPair;
         result.tunnelSamplePairs = sample.samplePairs;
         result.tunnelPixelBounds = sample.bounds;
+        result.tunnelImageScale = sample.scale;
         if (sample.maxJump > scenario.tunnelContinuity.maxChannelJump) {
           throw new Error(
             `semantic golden assertion failed: opening ${scenario.tunnelContinuity.openingId} `
@@ -374,6 +592,38 @@ try {
             + `${scenario.tunnelContinuity.maxChannelJump}`,
           );
         }
+        if (scenario.tunnelContinuity.dpr2) {
+          // A CSS-pixel capture cannot prove that half-device-pixel joins are
+          // clean. Run the same semantic assertion once at DPR 2 without
+          // adding a second reviewed baseline to the matrix.
+          const highDpi = await launch(
+            scenario.viewport, 2, browserArgs, browserContext,
+          );
+          try {
+            await assertFreshDemoBundle(highDpi.page, ROOT);
+            await prepareGoldenScenario(highDpi.page, scenario);
+            const highDpiClip = await goldenClip(highDpi.page, scenario.capture);
+            const highDpiPng = await highDpi.page.screenshot({
+              ...(highDpiClip ? { clip: highDpiClip } : {}),
+              animations: 'disabled', caret: 'hide', scale: 'device',
+            });
+            const highDpiSample = await inspectTunnelContinuity(
+              highDpi.page, highDpiPng, highDpiClip, scenario.tunnelContinuity,
+            );
+            result.tunnelDpr2MaxChannelJump = highDpiSample.maxJump;
+            result.tunnelDpr2SamplePairs = highDpiSample.samplePairs;
+            result.tunnelDpr2PixelBounds = highDpiSample.bounds;
+            if (highDpiSample.maxJump > scenario.tunnelContinuity.maxChannelJump) {
+              throw new Error(
+                `semantic golden assertion failed at DPR 2: opening ${scenario.tunnelContinuity.openingId} `
+                + `has a ${highDpiSample.maxJump}-channel local jump, expected at most `
+                + `${scenario.tunnelContinuity.maxChannelJump}`,
+              );
+            }
+          } finally {
+            await highDpi.browser.close();
+          }
+        }
       }
       const baselinePath = resolve(baselineRoot, `${scenario.id}.png`);
       result.baseline = baselinePath;

demo/performance/README.md

@@ -4,6 +4,14 @@
 fixture. The fixture has 60 rooms, 200 devices, 100 openings, 60 partitions,
 40 columns and 500 decor objects on three floors.
 
+Issue #89 adds `large-house-isometric-v1` through the same runner. It enables
+`hp-labs=iso`, selects iso per fixture space, measures the View toggle and
+records the capped `isoGeometry` cache. A comparison SHA predating #89 remains
+flat while reporting the same profile. The dedicated
+`budgets-large-house-isometric.json` applies the reviewed 20% relative allowance
+plus absolute noise/ceiling checks. Only the exact-SHA Linux workflow is gate
+evidence; a local report is diagnostic.
+
 The runner records seven measured samples after one discarded warm-up. With
 this intentionally small CI sample, the nearest-rank `p95` is the observed
 maximum; reports keep the conventional field name but should be read as a

demo/performance/budgets-large-house-isometric.json

@@ -0,0 +1,50 @@
+{
+  "schema": 1,
+  "profile": "large-house-isometric-v1",
+  "minimumSamples": 7,
+  "timings": {
+    "modelReadyMs": { "stat": "median", "maxRegressionRatio": 0.2, "noiseAllowanceMs": 200, "hardMaxMs": 3000 },
+    "firstStableRenderMs": { "stat": "median", "maxRegressionRatio": 0.2, "noiseAllowanceMs": 250, "hardMaxMs": 3500 },
+    "viewToggleMs": { "stat": "median", "maxRegressionRatio": 0.2, "noiseAllowanceMs": 100, "hardMaxMs": 1500 },
+    "spaceSwitchMs": { "stat": "median", "maxRegressionRatio": 0.2, "noiseAllowanceMs": 100, "hardMaxMs": 1800 },
+    "stateUpdateMs": { "stat": "median", "maxRegressionRatio": 0.2, "noiseAllowanceMs": 75, "hardMaxMs": 1000 },
+    "resizePreviewMs": { "stat": "median", "maxRegressionRatio": 0.2, "noiseAllowanceMs": 150, "hardMaxMs": 2200 },
+    "panZoomMs": { "stat": "median", "maxRegressionRatio": 0.2, "noiseAllowanceMs": 60, "hardMaxMs": 600 },
+    "settingsDialogMs": { "stat": "median", "maxRegressionRatio": 0.2, "noiseAllowanceMs": 100, "hardMaxMs": 1200 },
+    "switchCycleMs": { "stat": "median", "maxRegressionRatio": 0.2, "noiseAllowanceMs": 250, "hardMaxMs": 8000 }
+  },
+  "longTasks": {
+    "maxSingleMs": 3000,
+    "maxSingleRegressionRatio": 0.2,
+    "maxSingleNoiseAllowanceMs": 250,
+    "maxCountP95": 30,
+    "maxCountRegressionRatio": 0.2,
+    "countNoiseAllowance": 3,
+    "maxTotalP95Ms": 12000,
+    "maxTotalRegressionRatio": 0.2,
+    "noiseAllowanceMs": 150
+  },
+  "heap": {
+    "required": true,
+    "hardMaxGrowthBytes": 67108864,
+    "maxRegressionRatio": 0.2,
+    "noiseAllowanceBytes": 16777216
+  },
+  "cacheEntries": {
+    "cleanFloor": 160,
+    "glowClip": 200,
+    "wallUnion": 1,
+    "openingTunnel": 1,
+    "openingWallIndex": 1,
+    "isoGeometry": 8
+  },
+  "cacheGrowth": {
+    "cleanFloor": 0,
+    "glowClip": 0,
+    "wallUnion": 0,
+    "openingTunnel": 0,
+    "openingWallIndex": 0,
+    "isoGeometry": 0
+  },
+  "renderedDevices": 200
+}

demo/performance/card-contract.mjs

@@ -37,7 +37,9 @@ export const LARGE_HOUSE_CARD_CONTRACT = Object.freeze({
     '_settingsDialog',
     '_tool',
   ]),
-  optionalFields: Object.freeze([]),
+  // A comparison SHA before #89 is intentionally flat; the isometric runner
+  // checks these two members only when the target source tree supports Stage 1.
+  optionalFields: Object.freeze(['_isoGeometryCache', '_setProjection']),
   fieldTypes: Object.freeze({
     _booting: 'boolean',
     _cleanFloorCache: 'map',
@@ -46,6 +48,8 @@ export const LARGE_HOUSE_CARD_CONTRACT = Object.freeze({
     _gridPitch: 'number',
     _loadOk: 'boolean',
     _model: 'array',
+    _isoGeometryCache: 'map',
+    _setProjection: 'function',
     _tool: 'string',
   }),
 });

demo/shot_cover_move.mjs

@@ -17,7 +17,7 @@ await page.evaluate(async () => {
   c.requestUpdate();
   await c.updateComplete;
   const st = document.createElement('style');
-  st.textContent = '.activity-ring.transition i:first-child{animation-delay:-1.1s!important;animation-play-state:paused!important;}';
+  st.textContent = '.device-pulse.continuous.transition i:first-child{animation-delay:-1.1s!important;animation-play-state:paused!important;}';
   (c.shadowRoot || c.renderRoot).appendChild(st);
 });
 await page.waitForTimeout(400);

demo/shot_cover_states.mjs

@@ -38,7 +38,7 @@ await page.evaluate(async (STATES) => {
   c.requestUpdate();
   await c.updateComplete;
   const st = document.createElement('style');
-  st.textContent = '.activity-ring.transition i:first-child{animation-delay:-1.1s!important;animation-play-state:paused!important;}';
+  st.textContent = '.device-pulse.continuous.transition i:first-child{animation-delay:-1.1s!important;animation-play-state:paused!important;}';
   (c.shadowRoot || c.renderRoot).appendChild(st);
 }, STATES);
 await page.waitForTimeout(500);

demo/shot_motion_sense.mjs

@@ -17,7 +17,7 @@ await page.evaluate(async () => {
   await set('on');
   // freeze the pulse at a visible frame for a deterministic capture
   const st = document.createElement('style');
-  st.textContent = '.activity-ring.event i{animation-delay:-0.4s!important;animation-play-state:paused!important;}';
+  st.textContent = '.device-pulse.short.event i{animation-delay:-0.4s!important;animation-play-state:paused!important;}';
   (c.shadowRoot || c.renderRoot).appendChild(st);
 });
 await page.waitForTimeout(300);

demo/shot_opening_place.mjs

@@ -6,7 +6,7 @@ await page.evaluate(() => {
   const c = window.__card;
   const sp = c._serverCfg.spaces.find((s) => s.id === 'f1');
   sp.openings = [];
-  c._setMode('plan'); c._tool = 'opening';
+  c._setMode('plan'); c._activateOpeningPlacement('door');
   c._cfgEpoch++; c.requestUpdate();
   return c.updateComplete && true;
 });

demo/smoke_backdrop.mjs

@@ -257,7 +257,12 @@ const layers = await page.evaluate(() => {
   const c = window.__card;
   const m = c._spaceModel();
   const svgEl = c.renderRoot.querySelector('.stage svg');
-  const kids = [...svgEl.children];
+  // Stage 2 keeps the flat floor DOM byte-for-byte equivalent but places it
+  // in one transformable scene group shared with Iso. Ordering is therefore
+  // measured inside the group that actually owns paper/image/rooms.
+  const layerRoot = [...svgEl.children].find((node) =>
+    node.querySelector?.('.hp-paperg') && node.querySelector?.('.room')) || svgEl;
+  const kids = [...layerRoot.children];
   const idx = (sel) => kids.findIndex((n) => n.matches(sel) || n.querySelector?.(sel));
   const papers = [...svgEl.querySelectorAll('.hp-paper')];
   return {

demo/smoke_bg_color.mjs

@@ -197,7 +197,10 @@ const paper = await page.evaluate(async () => {
       && cs.fill !== 'none' && !/rgba\(.*,\s*0\)/.test(cs.fill);
   }
   // …and the picture is drawn ON that paper: image after paper, before walls
-  const kids = [...sr().querySelector('.stage svg').children];
+  const svgEl = sr().querySelector('.stage svg');
+  const layerRoot = [...svgEl.children].find((node) =>
+    node.querySelector?.('.hp-paperg') && node.querySelector?.('.room')) || svgEl;
+  const kids = [...layerRoot.children];
   const idxOf = (sel) => kids.findIndex((n) => n.matches(sel) || n.querySelector?.(sel));
   out.imageAbovePaper = idxOf('image') > idxOf('.hp-paper') && idxOf('image') >= 0;
   out.imageBelowRooms = idxOf('image') < idxOf('.room, .room-outline');
@@ -266,7 +269,9 @@ const drawn = await page.evaluate(async () => {
   });
   // paper first, everything else on top of it (one .hp-paperg group wraps
   // all paper shapes so the daynight drop shadow composites without seams)
-  const first = sr().querySelector('.stage.noplan svg').firstElementChild;
+  const noplanSvg = sr().querySelector('.stage.noplan svg');
+  const noplanLayers = [...noplanSvg.children].find((node) => node.querySelector?.('.hp-paperg')) || noplanSvg;
+  const first = [...noplanLayers.children].find((node) => node.tagName.toLowerCase() !== 'defs');
   out.paperUnderneath = !!first && first.classList.contains('hp-paperg')
     && !!first.firstElementChild && first.firstElementChild.classList.contains('hp-paper');
   // live resize preview: drag the L's right wall 0.625 -> 0.6875 — the paper

demo/smoke_cover_no_plate.mjs

@@ -103,7 +103,7 @@ const out = await page.evaluate(async () => {
   plateIsNeutral('opening');
   o.openingRings = cls().includes('activity-transition');
   o.openingRingIsTheBreathingOne = (() => {
-    const ring = devEl()?.querySelector('.activity-ring.transition i:first-child');
+    const ring = devEl()?.querySelector('.device-pulse.continuous.transition i:first-child');
     const cs = ring ? getComputedStyle(ring) : null;
     return !!cs && cs.animationName === 'hp-pulse-continuous' && cs.animationDuration === '2.4s';
   })();

demo/smoke_cover_tap.mjs

@@ -161,7 +161,7 @@ const out = await page.evaluate(async () => {
 
   // ---- the indication ----------------------------------------------------
   const afterAnim = () => {
-    const el = devEl()?.querySelector('.activity-ring.transition i:first-child');
+    const el = devEl()?.querySelector('.device-pulse.continuous.transition i:first-child');
     if (!el) return null;
     const cs = getComputedStyle(el);
     return { name: cs.animationName, dur: cs.animationDuration };

demo/smoke_device_preview_parity.mjs

@@ -105,9 +105,53 @@ const res = await page.evaluate(async () => {
       && badge.top >= stage.top + gap && badge.bottom <= stage.bottom - gap;
   }
 
+  // One persisted bottom badge is then projected through all three renderers.
+  // It intentionally coexists with LQI to guard the vertical stack contract.
+  const persistedBadge = {
+    id: 'd_temp', binding: 'device:d_temp',
+    value_badge: {
+      enabled: true,
+      source: { kind: 'entity_state', entity_id: 'sensor.living_temp' },
+      position: 'bottom',
+    },
+  };
+  c._serverCfg.markers = [
+    ...(c._serverCfg.markers || []).filter((marker) => marker.id !== 'd_temp'),
+    persistedBadge,
+  ];
+  c._regSignature = '';
+  c._maybeRebuildDevices();
+  c._setMode('view');
+  c.requestUpdate();
+  await c.updateComplete;
+  const planBadgeNode = sr().querySelector('.dev[data-id="d_temp"]');
+  const planBadgeFace = face(planBadgeNode);
+  const planBadgeRect = planBadgeNode?.querySelector('.value-badge')?.getBoundingClientRect();
+  const planLqiRect = planBadgeNode?.querySelector('.lqi')?.getBoundingClientRect();
+  const bottomBadgeLqiStacked = !!planBadgeRect && !!planLqiRect
+    && planLqiRect.top >= planBadgeRect.bottom - 1;
+
+  c._openMarkerDialog(c._devices.find((item) => item.id === 'd_temp'));
+  await c.updateComplete;
+  const persistedPreview = sr().querySelector('hp-device-preview');
+  await persistedPreview?.updateComplete;
+  const persistedPreviewFace = face(persistedPreview?.renderRoot?.querySelector('.dev'));
+
   await customElements.whenDefined('houseplan-space-card');
   const card = document.createElement('houseplan-space-card');
   card.setConfig({ type: 'custom:houseplan-space-card', space: 'f1' });
+  // A real static card reads the latest complete server/cache snapshot. Inject
+  // that same revision explicitly here so this smoke compares renderers, not
+  // the demo server's intentionally non-persistent websocket fixture.
+  card._snap = {
+    config: structuredClone(c._serverCfg),
+    rev: c._cfgRev,
+    configFingerprint: `fixture-${c._cfgRev}`,
+    layout: structuredClone(c._layout),
+    layoutRev: c._layoutRev,
+    layoutFingerprint: `fixture-${c._layoutRev}`,
+  };
+  card._loadedOnce = true;
   card.hass = c.hass;
   document.body.appendChild(card);
   const started = Date.now();
@@ -115,6 +159,7 @@ const res = await page.evaluate(async () => {
   await card.updateComplete;
   const staticNode = card.renderRoot.querySelector('.dev[data-id="d_light1"]');
   const staticFace = face(staticNode);
+  const staticBadgeFace = face(card.renderRoot.querySelector('.dev[data-id="d_temp"]'));
 
   return {
     allFacesPresent: !!planFace && !!previewFace && !!staticFace,
@@ -128,6 +173,9 @@ const res = await page.evaluate(async () => {
     savedBadgePreviewMatches,
     savedBadgeUntouched,
     badgeBounds,
+    valueBadgePlanPreviewParity: JSON.stringify(planBadgeFace) === JSON.stringify(persistedPreviewFace),
+    valueBadgePlanStaticParity: JSON.stringify(planBadgeFace) === JSON.stringify(staticBadgeFace),
+    bottomBadgeLqiStacked,
     staticBindingHook: staticNode?.getAttribute('data-binding-status') === 'active',
   };
 });

demo/smoke_editor_tabs.mjs

@@ -25,6 +25,22 @@ const res = await page.evaluate(async () => {
   const barCloseIcon = barClose?.querySelector('ha-icon');
   const barCloseRect = barClose?.getBoundingClientRect();
   const barCloseIconRect = barCloseIcon?.getBoundingClientRect();
+  const enteringChrome = sr().querySelector('.editorchrome');
+  // Regression #95 follow-up: the bar is already painted during the 220 ms
+  // mode transition, so its explicit Close command must not be inert together
+  // with the editing tools.
+  out.closeRemainsInteractiveDuringEnter = c._modeTransitionBusy
+    && enteringChrome?.inert === false
+    && sr().querySelector('.editbar-tools')?.inert === true
+    && getComputedStyle(barClose).pointerEvents === 'auto';
+  const enteringStage = sr().querySelector('.stage');
+  const editorSceneLayer = enteringStage?.querySelector('.hp-editor-only-layer');
+  const enteringVisual = c._modeTransitionVisual;
+  out.sceneLayersUseTransitionWeights = c._modeTransitionBusy && !!enteringVisual
+    && !!editorSceneLayer
+    && Math.abs(Number(editorSceneLayer.getAttribute('opacity')) - enteringVisual.editorWeight) < 0.001
+    && Math.abs(Number(getComputedStyle(enteringStage).getPropertyValue('--hp-mode-view-weight'))
+      - enteringVisual.viewWeight) < 0.001;
   out.planBarCloseIconIsCentered = !!barCloseRect && !!barCloseIconRect
     && Math.abs((barCloseIconRect.left + barCloseIconRect.width / 2)
       - (barCloseRect.left + barCloseRect.width / 2)) <= 1
@@ -54,8 +70,9 @@ const res = await page.evaluate(async () => {
   out.contextDoesNotMoveClose = Math.abs(closeWithContext.left - closeBeforeContext.left) <= 1
     && Math.abs(closeWithContext.top - closeBeforeContext.top) <= 1;
   out.closeHasPinnedEndCap = !!sr().querySelector('.editbar > .editbar-end > .barclose');
-  // No current tools are grouped automatically. Inject one declarative group
-  // to pin the generic launcher/keyboard/restore contract for future editors.
+  // Replace the real Opening group with a side-effect-free command group to
+  // pin the generic launcher/keyboard/restore contract independently of any
+  // one editor tool's business logic.
   let groupInvokes = 0;
   Object.defineProperty(c, '_editorToolbarGroups', { configurable: true, get: () => [{
     id: 'smoke-group', label: 'Smoke group', icon: 'mdi:dots-grid', items: [{
@@ -107,6 +124,23 @@ const res = await page.evaluate(async () => {
   out.dismissTailDoesNotEatUnrelatedClick = unrelatedInvokes === 1;
   outsideTool.remove();
   unrelatedTool.remove();
+  // An open grouped submenu still consumes ordinary outside clicks, but an
+  // explicit editor navigation command has higher priority and must close both
+  // surfaces in the same pointer sequence.
+  groupLauncher?.click(); await c.updateComplete;
+  const closeWithOpenGroup = sr().querySelector('.editbar .barclose');
+  closeWithOpenGroup?.dispatchEvent(new PointerEvent('pointerdown', {
+    pointerId: 302, pointerType: 'mouse', button: 0,
+    bubbles: true, composed: true, cancelable: true,
+  }));
+  closeWithOpenGroup?.dispatchEvent(new MouseEvent('click', {
+    button: 0, bubbles: true, composed: true, cancelable: true,
+  }));
+  await c.updateComplete;
+  out.editorNavigationOutranksGroupDismiss = c._mode === 'view'
+    && c._editorSecondary.hasOpenGroup === false;
+  await settleMode();
+  tabs()[0].click(); await settleMode();
   delete c._editorToolbarGroups;
   c._tool = 'select'; c.requestUpdate(); await c.updateComplete;
   // 4) прямое переключение План → Устройства

demo/smoke_general_settings.mjs

@@ -38,6 +38,13 @@ const res = await page.evaluate(async () => {
     settings: { ...(s.settings||{}), show_lqi: false } })) };
   c.requestUpdate(); await c.updateComplete;
   out.lqiAfter = sr().querySelectorAll('.dev .lqi').length;
+  // The space value is an explicit override, not another condition ANDed with
+  // the card default. This is the projection shared by preview/static cards.
+  c._config = { ...c._config, show_signal: false };
+  c._serverCfg = { ...c._serverCfg, spaces: c._serverCfg.spaces.map((s) => s.id !== 'f1' ? s : ({ ...s,
+    settings: { ...(s.settings||{}), show_lqi: true } })) };
+  c.requestUpdate(); await c.updateComplete;
+  out.spaceLqiOverridesCardDefault = sr().querySelectorAll('.dev .lqi').length > 0;
   return out;
 });
 // CARD_VERSION из собранного бандла (тот же текст уходит в console-баннер).

demo/smoke_glow.mjs

@@ -282,6 +282,20 @@ const rasterFixture = await page.evaluate(async () => {
   if (!source || !sourceEid || !current) return { ready: false };
 
   const edgeKey = (a, b) => `${a.join(',')}/${b.join(',')}`;
+  const wallKey = (a, b) => {
+    const pitch = 1 / 240;
+    const q = (value) => Math.round(value / pitch) * pitch;
+    let dx = b[0] - a[0], dy = b[1] - a[1];
+    const length = Math.hypot(dx, dy) || 1;
+    dx /= length; dy /= length;
+    if (dx < -1e-12 || (Math.abs(dx) <= 1e-12 && dy < 0)) {
+      dx = -dx; dy = -dy;
+    }
+    let angle = Math.atan2(dy, dx);
+    if (angle < 0) angle += Math.PI;
+    const angleBucket = Math.round(angle * 1800) / 1800;
+    return `${q((a[0] + b[0]) / 2).toFixed(6)},${q((a[1] + b[1]) / 2).toFixed(6)}@${angleBucket.toFixed(4)}`;
+  };
   const edges = new Map();
   for (const room of current.rooms || []) {
     for (let index = 0; index < room.poly.length; index++) {
@@ -291,13 +305,21 @@ const rasterFixture = await page.evaluate(async () => {
       if (!edges.has(reverse) && !edges.has(edgeKey(a, b))) edges.set(edgeKey(a, b), { a, b });
     }
   }
-  const walls = [...edges.values()].map(({ a, b }, index) => ({
-    key: `glow-raster-wall-${index}`, a, b, cm: 15,
+  const walls = [...edges.values()].map(({ a, b }) => ({
+    key: wallKey(a, b), a, b, cm: 15,
   }));
   const openings = [
     { id: 'glow-raster-east', type: 'door', x: 0.55, y: 0.32, angle: 90, length: 0.09 },
     { id: 'glow-raster-south', type: 'door', x: 0.32, y: 0.58, angle: 0, length: 0.09 },
   ];
+  const wallSource = [...edges.values()]
+    .map(({ a, b }) => ({
+      point: [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2],
+      clearance: Math.min(...openings.map((opening) => Math.hypot(
+        (a[0] + b[0]) / 2 - opening.x, (a[1] + b[1]) / 2 - opening.y,
+      ))),
+    }))
+    .sort((left, right) => right.clearance - left.clearance)[0]?.point;
   c._serverCfg = {
     ...c._serverCfg,
     settings: { ...(c._serverCfg.settings || {}), glow_radius_cm: 600 },
@@ -425,7 +447,7 @@ const rasterFixture = await page.evaluate(async () => {
       }),
     };
   }
-  return { ready: true, litParts, sourceEid, doors, shadow };
+  return { ready: true, litParts, sourceEid, sourceId: source.id, wallSource, doors, shadow };
 });
 
 if (rasterFixture.ready) {
@@ -531,6 +553,39 @@ if (rasterFixture.ready) {
   res.shadowEdgeIsCrisp = !!metrics.shadow
     && metrics.shadow.high - metrics.shadow.low >= 8
     && metrics.shadow.edgeWidth <= 4;
+  const sourceInsideWall = await page.evaluate(async ({ sourceEid, sourceId, wallSource }) => {
+    if (!wallSource) return false;
+    const c = window.__card;
+    const state = c.hass.states[sourceEid];
+    c._layout = {
+      ...c._layout,
+      [sourceId]: { s: c._space, x: wallSource[0], y: wallSource[1] },
+    };
+    c.hass = {
+      ...c.hass,
+      states: { ...c.hass.states, [sourceEid]: { ...state, state: 'on' } },
+    };
+    c._glowClipCache.clear();
+    c.requestUpdate();
+    await c.updateComplete;
+    // The continuity contract may keep the last complete device frame briefly
+    // while the moved source and its HA snapshot are staged atomically. Wait
+    // for that bounded hand-off instead of mistaking the allowed stale frame
+    // for a geometry leak.
+    const root = c.shadowRoot || c.renderRoot;
+    const selector = `[data-glow-source="${CSS.escape(sourceEid)}"] .glow-pool`;
+    const deadline = performance.now() + 1800;
+    while (root.querySelector(selector) && performance.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 40));
+      await c.updateComplete;
+    }
+    return !root.querySelector(selector);
+  }, {
+    sourceEid: rasterFixture.sourceEid,
+    sourceId: rasterFixture.sourceId,
+    wallSource: rasterFixture.wallSource,
+  });
+  res.sourceInsideWallSuppressed = sourceInsideWall;
 } else {
   res.litPartsMatchClip = false;
   res.doorwayCarriesLight = false;
@@ -538,6 +593,7 @@ if (rasterFixture.ready) {
   res.apertureItselfLit = false;
   res.occluderCastsShadow = false;
   res.shadowEdgeIsCrisp = false;
+  res.sourceInsideWallSuppressed = false;
 }
 // значения зафиксированы прогоном на v1.43.1 и сверены с кодом (audit T1)
 checkAll(res, {

demo/smoke_grid_snap.mjs

@@ -106,7 +106,7 @@ const out = await page.evaluate(async () => {
 
   // ---- 1e) an OPENING is WALL-bound: on its wall, whole steps along it ---
   c._setMode('plan'); await c.updateComplete;
-  c._tool = 'opening';
+  c._activateOpeningPlacement('door');
   const spm = c._spaceModel(c._space);
   const wall = (() => {
     for (const r of spm.rooms) {

demo/smoke_help_affordance.mjs

@@ -66,6 +66,20 @@ const res = await page.evaluate(async () => {
   const restoredTrigger = incompleteHelp.shadowRoot?.querySelector('.trigger');
   out.circledQuestionIcon = restoredTrigger?.querySelector('svg[viewBox="0 0 24 24"] path')
     ?.getAttribute('d')?.length > 0;
+  incompleteHelp.text = Array.from({ length: 320 }, (_, index) => `Line ${index + 1}`).join(' · ');
+  await incompleteHelp.updateComplete;
+  const overflowTrigger = incompleteHelp.shadowRoot?.querySelector('.trigger');
+  overflowTrigger?.click();
+  await incompleteHelp.updateComplete;
+  await frame();
+  const longSurface = incompleteHelp.shadowRoot?.querySelector('.tooltip');
+  overflowTrigger?.dispatchEvent(new KeyboardEvent('keydown', {
+    key: 'PageDown', bubbles: true, composed: true, cancelable: true,
+  }));
+  await frame();
+  out.overflowHelpScrollsFromTrigger = !!longSurface
+    && longSurface.scrollHeight > longSurface.clientHeight && longSurface.scrollTop > 0;
+  overflowTrigger?.click();
   incompleteHelp.remove();
 
   card._setMode('devices');

demo/smoke_hidden_flag.mjs

@@ -154,7 +154,7 @@ Object.assign(out, await page.evaluate(async () => {
   const ghosts = [...sr().querySelectorAll('.dev.ghost')];
   o.rippleGhostHasIcon = ghosts.length > 0 && ghosts.every((x) => !!x.querySelector('ha-icon'));
   o.rippleGhostNoNoicon = ghosts.every((x) => !x.classList.contains('noicon'));
-  o.rippleGhostNoRipple = ghosts.every((x) => !x.querySelector('.activity-ring'));
+  o.rippleGhostNoRipple = ghosts.every((x) => !x.querySelector('.device-pulse'));
   c._serverCfg.markers = c._serverCfg.markers.filter((m) => m.id !== lamp.id);
   c._cfgEpoch++; c._regSignature = ''; c._maybeRebuildDevices();
   c._setMode('view'); c._showHidden = false;
@@ -197,7 +197,13 @@ Object.assign(out, await page.evaluate(async () => {
   },
   // модульный кэш конфига инвалидируется только через это событие — стаб
   // сохраняет колбэк, чтобы следующий тест мог сбросить кэш
-  connection: { subscribeEvents: async (cb) => { window.__hpInvalidate = cb; return () => {}; } } };
+  connection: { subscribeEvents: async (cb, type) => {
+    // #107 added a third, virtual-light subscription. Keep the config event
+    // callback specifically; otherwise the next fixture calls the unrelated
+    // virtual-light listener and reuses this stale shared config snapshot.
+    if (type === 'houseplan_config_updated') window.__hpInvalidate = cb;
+    return () => {};
+  } } };
   const host = document.createElement('div');
   document.body.appendChild(host);
   const card = document.createElement('houseplan-space-card');

demo/smoke_isometric_contract.mjs

@@ -0,0 +1,122 @@
+// #122 Stage 2: Labs lifecycle, structural composition and flat editor boundary.
+import { launch, checkAll, finish } from './serve.mjs';
+
+const { page, browser } = await launch({ width: 1000, height: 850 });
+const out = await page.evaluate(async () => {
+  const card = window.__card;
+  const root = () => card.renderRoot;
+  const frame = () => new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)));
+  const center = (element) => {
+    const rect = element.getBoundingClientRect();
+    return [rect.left + rect.width / 2, rect.top + rect.height / 2];
+  };
+  const enable = async () => {
+    history.replaceState(null, '', '#space=f1&hp-labs=iso');
+    dispatchEvent(new HashChangeEvent('hashchange'));
+    await card.updateComplete;
+    await frame();
+  };
+  const result = {};
+  const configSpace = card._serverCfg.spaces.find((space) => space.id === 'f1');
+  configSpace.settings = {
+    ...(configSpace.settings || {}), show_borders: true, show_names: true,
+  };
+  configSpace.partitions = [{
+    id: 'iso-smoke-wall', a: [0.15, 0.12], b: [0.85, 0.12], cm: 15,
+  }];
+  card._cfgEpoch++;
+  card.requestUpdate();
+  await card.updateComplete;
+  await enable();
+  const toggle = root().querySelector('[data-hp="projection-toggle"]');
+  result.labsSnapshotFrozen = Object.isFrozen(window.__hpLabs)
+    && JSON.stringify(window.__hpLabs) === '["iso"]';
+  result.toggleShown = !!toggle;
+  result.toggleMinHitTarget = toggle && toggle.getBoundingClientRect().width >= 44
+    && toggle.getBoundingClientRect().height >= 44;
+  result.flatDefault = toggle?.getAttribute('aria-pressed') === 'false'
+    && !root().querySelector('[data-hp="iso-walls"]');
+
+  toggle?.click();
+  await card.updateComplete;
+  await frame();
+  const isoToggle = root().querySelector('[data-hp="projection-toggle"]');
+  const device = root().querySelector('[data-hp="device"]');
+  const roomLabel = root().querySelector('[data-hp="room-label"]');
+  result.isoRendered = isoToggle?.getAttribute('aria-pressed') === 'true'
+    && !!root().querySelector('[data-hp="iso-underlay"] .iso-floor-side')
+    && !!root().querySelector('[data-hp="iso-walls"] .iso-wall-top');
+  result.sharedProjectionSnapshot = ['.iso-underlay-svg', '.plan-svg', '.iso-shadows-svg', '.iso-walls-svg']
+    .map((selector) => root().querySelector(selector)?.getAttribute('viewBox'))
+    .every((value, _index, values) => !!value && value === values[0]);
+  result.stage2DefinitionsBounded = root().querySelectorAll('[id^="hp-iso-"]').length <= 5;
+  result.preferenceStored = JSON.parse(localStorage.getItem('houseplan_card_view_v1') || '{}').f1 === 'iso';
+  result.anchorsFinite = [device, roomLabel].every((node) => node
+    && center(node).every((value) => Number.isFinite(value)));
+  const deviceBefore = device ? center(device) : null;
+  card.hass = { ...card.hass, states: { ...card.hass.states } };
+  await card.updateComplete;
+  const deviceAfter = root().querySelector('[data-hp="device"]');
+  result.haUpdateKeepsGeometry = root().querySelector('[data-hp="iso-walls"]')?.dataset.fingerprint
+    && card._isoGeometryCache.size === 1;
+  result.haUpdateKeepsAnchor = !!deviceBefore && !!deviceAfter
+    && Math.hypot(...center(deviceAfter).map((value, index) => value - deviceBefore[index])) <= 1;
+
+  card._setMode('plan');
+  await card.updateComplete;
+  while (card._modeTransitionBusy) await frame();
+  result.editorIsFlat = card._mode === 'plan'
+    && !root().querySelector('[data-hp="projection-toggle"]')
+    && !root().querySelector('[data-hp="iso-walls"]');
+  card._setMode('view');
+  await card.updateComplete;
+  while (card._modeTransitionBusy) await frame();
+  result.viewRestoresIso = root().querySelector('[data-hp="projection-toggle"]')?.getAttribute('aria-pressed') === 'true'
+    && !!root().querySelector('[data-hp="iso-walls"]');
+
+  const source = card._isoSource;
+  let attempts = 0;
+  let shouldFail = true;
+  const fallbackKey = 'f1|injected-render-failure';
+  card._isoGeometryCache.clear();
+  card._isoSource = () => ({
+    key: fallbackKey,
+    build: () => {
+      attempts++;
+      if (shouldFail) throw new Error('injected isometric failure');
+      return { walls: [], floor: [], openings: [] };
+    },
+  });
+  card.requestUpdate();
+  await card.updateComplete;
+  card.hass = { ...card.hass, states: { ...card.hass.states } };
+  await card.updateComplete;
+  result.fallbackLatched = attempts === 1
+    && root().querySelector('[data-hp="projection-toggle"]')?.getAttribute('aria-pressed') === 'false'
+    && !root().querySelector('[data-hp="iso-walls"]')
+    && JSON.parse(localStorage.getItem('houseplan_card_view_v1') || '{}').f1 === 'iso';
+  shouldFail = false;
+  card._setProjection('iso');
+  await card.updateComplete;
+  result.explicitRetryRestoresIso = attempts === 2
+    && !!root().querySelector('[data-hp="iso-walls"]')
+    && root().querySelector('[data-hp="projection-toggle"]')?.getAttribute('aria-pressed') === 'true';
+  card._isoSource = source;
+  card._isoGeometryCache.delete(fallbackKey);
+  card._isoFallback.delete(fallbackKey);
+  card.requestUpdate();
+  await card.updateComplete;
+
+  history.replaceState(null, '', '#space=f1&hp-labs=-iso');
+  dispatchEvent(new HashChangeEvent('hashchange'));
+  await card.updateComplete;
+  await frame();
+  result.removalIsImmediateFlat = JSON.stringify(window.__hpLabs) === '[]'
+    && !root().querySelector('[data-hp="projection-toggle"]')
+    && !root().querySelector('[data-hp="iso-walls"]')
+    && !root().querySelector('[id^="hp-iso-"]');
+  return result;
+});
+
+checkAll(out);
+await finish(browser, out);

demo/smoke_isometric_live_touch.mjs

@@ -0,0 +1,336 @@
+// #122 Stage 2: live-floor preservation, vertical openings, touch and remount paths.
+import { launch, checkAll, finish } from './serve.mjs';
+
+const { page, browser } = await launch(
+  { width: 430, height: 820 }, 1, [], { hasTouch: true, isMobile: true },
+);
+const out = await page.evaluate(async () => {
+  const original = window.__card;
+  const root = (card) => card.renderRoot;
+  const wait = (ms) => new Promise((done) => setTimeout(done, ms));
+  const frame = () => new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)));
+  history.replaceState(null, '', '?hp-labs=iso#space=f1');
+  dispatchEvent(new HashChangeEvent('hashchange'));
+  await original.updateComplete;
+  const configSpace = original._serverCfg.spaces.find((space) => space.id === 'f1');
+  configSpace.settings = {
+    ...(configSpace.settings || {}), fill_mode: 'custom',
+    custom_fill: { c: '#31465f', a: 0.42 }, glow_enabled: true,
+    show_borders: true, show_names: true, north_deg: 0, sun_rays: true,
+  };
+  configSpace.rooms[0].settings = {
+    ...(configSpace.rooms[0].settings || {}), fill_mode: 'none', glow: true,
+  };
+  configSpace.openings = [
+    { id: 'iso-window', type: 'window', x: 0.28, y: 0.14, angle: 0, length: 0.12,
+      contact: 'binary_sensor.window' },
+    { id: 'iso-door', type: 'door', x: 0.55, y: 0.36, angle: 90, length: 0.12,
+      contact: 'binary_sensor.window', lock: 'lock.front_door' },
+    { id: 'iso-gate', type: 'gate', x: 0.72, y: 0.14, angle: 0, length: 0.16,
+      contact: 'binary_sensor.gate', lock: 'lock.front_door' },
+  ];
+  configSpace.partitions = [{
+    id: 'iso-live-wall', a: [0.15, 0.12], b: [0.85, 0.12], cm: 15,
+  }];
+  configSpace.decor = [
+    { id: 'iso-line', kind: 'line', x1: 0.12, y1: 0.7, x2: 0.45, y2: 0.7,
+      color: '#667788', opacity: 0.7, width_cm: 1 },
+    { id: 'iso-sofa', kind: 'furniture', symbol: 'sofa', x: 0.62, y: 0.55,
+      w: 0.2, h: 0.12, color: '#667788', opacity: 0.7, width_cm: 1 },
+  ];
+  original._serverCfg.markers = original._serverCfg.markers || [];
+  original._serverCfg.markers.push({
+    id: 'iso-vacuum', binding: 'device:d_mower', space: 'f1', area: 'living_room',
+    vacuum: {
+      source: 'camera.static_robot_map', trail_mode: 'always',
+      calibration: { m1: [0.5, 0, 0, 0, 0.5, 0] },
+    },
+  });
+  original._layout['iso-vacuum'] = { s: 'f1', x: 0.18, y: 0.78 };
+  original._hoverRoom = { space: 'f1', room: original._spaceModel('f1').rooms[0] };
+  original.hass = {
+    ...original.hass,
+    states: {
+      ...original.hass.states,
+      'light.floor_lamp': {
+        ...original.hass.states['light.floor_lamp'], state: 'on',
+      },
+      'vacuum.mower': {
+        ...original.hass.states['vacuum.mower'], state: 'cleaning',
+      },
+      'camera.static_robot_map': {
+        entity_id: 'camera.static_robot_map', state: 'idle',
+        attributes: {
+          map_name: 'm1', vacuum_position: { x: 650, y: 700, a: 0 },
+          path: [[200, 200], [420, 440], [650, 700]],
+        },
+      },
+      'sun.sun': {
+        entity_id: 'sun.sun', state: 'above_horizon',
+        attributes: { azimuth: 0, elevation: 24 },
+      },
+    },
+  };
+  original._cfgEpoch++;
+  original._regSignature = '';
+  original.requestUpdate();
+  await original.updateComplete;
+  await frame();
+
+  const count = (selector) => root(original).querySelectorAll(selector).length;
+  const layers = () => ({
+    rooms: count('[data-hp="room"]'),
+    roomFills: count('[data-hp="room"].filled'),
+    decor: count('.decorlayer [data-hp="decor"]'),
+    furniture: count('.decorlayer .dfurn'),
+    backdrop: count('.hp-backdrop'),
+    glowBase: count('.glow-base-layer .glow-base'),
+    glowSources: count('.glowlayer [data-glow-source]'),
+    sun: count('.sunlayer'),
+    openings: count('[data-hp="opening"]'),
+    verticalOpenings: count('[data-hp="iso-openings"] .iso-opening-panel'),
+    devices: count('[data-hp="device"]'),
+    hover: count('.room-hover-fill'),
+    vacuumPucks: count('.vacpuck'),
+    vacuumTrails: count('.vactrail .case'),
+  });
+  const flat = layers();
+  const flatSpillParts = [...root(original).querySelectorAll('.glow-pool')]
+    .map((node) => node.getAttribute('data-lit-parts'));
+  root(original).querySelector('[data-hp="projection-toggle"]')?.click();
+  await original.updateComplete;
+  await frame();
+
+  const before = layers();
+  const beforeSpillParts = [...root(original).querySelectorAll('.glow-pool')]
+    .map((node) => node.getAttribute('data-lit-parts'));
+  const wallFingerprint = root(original).querySelector('[data-hp="iso-walls"]')?.dataset.fingerprint;
+  const cachedGeometry = original._isoGeometryCache.get(wallFingerprint)?.geometry;
+  const light = original.hass.states['light.ceiling'];
+  const openingPanelBefore = root(original)
+    .querySelector('[data-hp="iso-openings"] [data-id="iso-door"]')?.getAttribute('d');
+  original.hass = {
+    ...original.hass,
+    states: {
+      ...original.hass.states,
+      'light.ceiling': {
+        ...light, attributes: { ...light.attributes, rgb_color: [255, 64, 32] },
+      },
+      'binary_sensor.window': {
+        ...original.hass.states['binary_sensor.window'], state: 'off',
+      },
+    },
+  };
+  await original.updateComplete;
+  const after = layers();
+  const afterSpillParts = [...root(original).querySelectorAll('.glow-pool')]
+    .map((node) => node.getAttribute('data-lit-parts'));
+  const ordered = [
+    root(original).querySelector('.iso-underlay-svg'),
+    root(original).querySelector('.hp-backdrop'),
+    root(original).querySelector('.decorlayer'),
+    root(original).querySelector('[data-hp="room"]'),
+    root(original).querySelector('.glow-base-layer'),
+    root(original).querySelector('.glowlayer'),
+    root(original).querySelector('.sunlayer'),
+    root(original).querySelector('.iso-shadows-svg'),
+    root(original).querySelector('.iso-walls-svg'),
+    root(original).querySelector('.vacpuck'),
+  ];
+  const result = {
+    isoOnTouch: !!root(original).querySelector('[data-hp="iso-walls"]'),
+    flatIsoLayerParity: JSON.stringify({ ...flat, openings: 0, verticalOpenings: before.verticalOpenings })
+        === JSON.stringify(before)
+      && JSON.stringify(flatSpillParts) === JSON.stringify(beforeSpillParts),
+    liveLayersPresent: before.rooms > 0 && before.roomFills > 0 && before.decor >= 2
+      && before.furniture > 0 && before.backdrop > 0 && before.glowBase > 0
+      && before.glowSources >= 2 && before.sun > 0 && before.openings === 0
+      && before.verticalOpenings === 5
+      && before.devices > 0 && before.hover > 0 && before.vacuumPucks > 0
+      && before.vacuumTrails >= 2,
+    liveLayersStable: JSON.stringify(after) === JSON.stringify(before),
+    spillBarrierStable: JSON.stringify(afterSpillParts) === JSON.stringify(beforeSpillParts)
+      && beforeSpillParts.length >= 2 && beforeSpillParts.every((parts) => Number(parts) > 0),
+    floorToOverlayOrderPreserved: ordered.every(Boolean)
+      && ordered.slice(1).every((node, index) => Boolean(
+        ordered[index].compareDocumentPosition(node) & Node.DOCUMENT_POSITION_FOLLOWING
+      )),
+    haColorUpdatePainted: [...root(original).querySelectorAll('radialGradient stop')]
+      .some((stop) => stop.getAttribute('stop-color') === '#ff4020'),
+    sameWallFingerprint: root(original).querySelector('[data-hp="iso-walls"]')?.dataset.fingerprint === wallFingerprint,
+    haUpdateReusesGeometry: original._isoGeometryCache.get(wallFingerprint)?.geometry === cachedGeometry,
+    contactUpdateMovesOnlyLivePanel: !!openingPanelBefore
+      && root(original).querySelector('[data-hp="iso-openings"] [data-id="iso-door"]')?.getAttribute('d')
+        !== openingPanelBefore
+      && original._isoGeometryCache.size === 1,
+    oneLightModel: !root(original).querySelector('.window-light,.iso-window-light,.iso-glow,.iso-sun'),
+    oldFloorSymbolsNotDuplicated: before.openings === 0,
+  };
+
+  configSpace.settings.hide_openings = true;
+  original._cfgEpoch++;
+  original.requestUpdate();
+  await original.updateComplete;
+  result.hideOpeningsKeepsStructure = !!root(original).querySelector('[data-hp="iso-walls"]')
+    && !root(original).querySelector('[data-hp="iso-openings"]')
+    && !root(original).querySelector('[data-hp="opening"]')
+    && root(original).querySelectorAll('.glowlayer [data-glow-source]').length >= 2;
+
+  configSpace.settings.hide_openings = false;
+  configSpace.settings.show_borders = false;
+  original._cfgEpoch++;
+  original.requestUpdate();
+  await original.updateComplete;
+  result.noBordersUsesFloorSymbols = !root(original).querySelector('[data-hp="iso-walls"]')
+    && !root(original).querySelector('[data-hp="iso-underlay"]')
+    && root(original).querySelectorAll('[data-hp="opening"]').length === 3;
+
+  configSpace.settings.show_borders = true;
+  original._cfgEpoch++;
+  original.requestUpdate();
+  await original.updateComplete;
+  result.visibleBordersRestoreStage2 = !!root(original).querySelector('[data-hp="iso-openings"]')
+    && original._isoGeometryCache.size === 1;
+
+  const supports = CSS.supports;
+  CSS.supports = () => false;
+  original.requestUpdate();
+  await original.updateComplete;
+  result.unsupportedDecorationKeepsIsoStructure = !!root(original).querySelector('[data-hp="iso-walls"]')
+    && !!root(original).querySelector('[data-hp="iso-openings"]')
+    && !root(original).querySelector('[data-hp="iso-shadows"]');
+  CSS.supports = supports;
+  original.requestUpdate();
+  await original.updateComplete;
+
+  const calls = [];
+  original.hass = {
+    ...original.hass,
+    callService: async (domain, service, data) => calls.push({ domain, service, data }),
+  };
+  await original.updateComplete;
+  root(original).querySelector('[data-entity="light.ceiling"]')?.click();
+  await frame();
+  original._setProjection('flat');
+  await original.updateComplete;
+  root(original).querySelector('[data-entity="light.ceiling"]')?.click();
+  await frame();
+  result.flatIsoActionParity = calls.length === 2
+    && JSON.stringify(calls[0]) === JSON.stringify(calls[1]);
+  original._setProjection('iso');
+  await original.updateComplete;
+
+  const stage = root(original).querySelector('.stage');
+  const stageRect = stage.getBoundingClientRect();
+  const zoomBefore = original._zoom;
+  const pointer = (type, id, x, y, buttons) => new PointerEvent(type, {
+    bubbles: true, composed: true, pointerId: id, pointerType: 'touch',
+    clientX: x, clientY: y, button: type === 'pointerdown' ? 0 : -1, buttons,
+  });
+  const cy = stageRect.top + stageRect.height / 2;
+  stage.dispatchEvent(pointer('pointerdown', 8902, stageRect.left + 150, cy, 1));
+  stage.dispatchEvent(pointer('pointerdown', 8903, stageRect.left + 270, cy, 1));
+  stage.dispatchEvent(pointer('pointermove', 8902, stageRect.left + 115, cy, 1));
+  stage.dispatchEvent(pointer('pointermove', 8903, stageRect.left + 305, cy, 1));
+  stage.dispatchEvent(pointer('pointerup', 8902, stageRect.left + 115, cy, 0));
+  stage.dispatchEvent(pointer('pointerup', 8903, stageRect.left + 305, cy, 0));
+  await original.updateComplete;
+  result.touchPinchKeepsIso = original._zoom > zoomBefore
+    && !!root(original).querySelector('[data-hp="iso-walls"]');
+
+  const opening = root(original).querySelector('[data-hp="opening"] .op-hit');
+  opening?.dispatchEvent(new MouseEvent('click', { bubbles: true, composed: true }));
+  result.touchOpeningIsSafe = !original._openingDialog && !original._openingInfo
+    && original._mode === 'view' && calls.length === 2;
+
+  const device = root(original).querySelector('[data-hp="device"]');
+  if (device) {
+    const rect = device.getBoundingClientRect();
+    device.dispatchEvent(new PointerEvent('pointerdown', {
+      bubbles: true, composed: true, pointerId: 8901, pointerType: 'touch',
+      clientX: rect.left + rect.width / 2, clientY: rect.top + rect.height / 2,
+      button: 0, buttons: 1,
+    }));
+    await wait(700);
+    result.touchLongPressHitsDevice = !!original._infoCard;
+    device.dispatchEvent(new PointerEvent('pointerup', {
+      bubbles: true, composed: true, pointerId: 8901, pointerType: 'touch',
+      clientX: rect.left + rect.width / 2, clientY: rect.top + rect.height / 2,
+      button: 0, buttons: 0,
+    }));
+    original._closeInfoCard();
+  } else result.touchLongPressHitsDevice = false;
+
+  original._pickSpace('garden');
+  await wait(230);
+  original._setProjection('iso');
+  await original.updateComplete;
+  const gardenIso = original._space === 'garden'
+    && root(original).querySelector('[data-hp="projection-toggle"]')?.getAttribute('aria-pressed') === 'true';
+  original._pickSpace('f1');
+  await wait(230);
+  result.touchSpaceSwitchKeepsPerSpaceIso = gardenIso && original._space === 'f1'
+    && !!root(original).querySelector('[data-hp="iso-walls"]');
+
+  const ownVisibilityState = Object.getOwnPropertyDescriptor(document, 'visibilityState');
+  Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'hidden' });
+  document.dispatchEvent(new Event('visibilitychange'));
+  Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'visible' });
+  document.dispatchEvent(new Event('visibilitychange'));
+  window.dispatchEvent(new PageTransitionEvent('pageshow', { persisted: true }));
+  await original.updateComplete;
+  await frame();
+  const recoveryStarted = performance.now();
+  while (root(original).querySelector('.recoveryoverlay')
+      && performance.now() - recoveryStarted < 2000) await wait(20);
+  result.backgroundForegroundKeepsIso = !!root(original).querySelector('[data-hp="iso-walls"]')
+    && !root(original).querySelector('.recoveryoverlay');
+  if (ownVisibilityState) Object.defineProperty(document, 'visibilityState', ownVisibilityState);
+  else delete document.visibilityState;
+
+  const host = document.getElementById('host');
+  const mount = async (kiosk = false) => {
+    const card = document.createElement('houseplan-card');
+    card.setConfig({ type: 'custom:houseplan-card', kiosk });
+    host.replaceChildren(card);
+    card.hass = window.__mkHass();
+    const started = performance.now();
+    while ((!card._loadOk || card._booting) && performance.now() - started < 9000) await wait(30);
+    await card.updateComplete;
+    await frame();
+    return card;
+  };
+  original.remove();
+  const warm = await mount(false);
+  result.warmRemountIso = !warm._booting
+    && !!root(warm).querySelector('[data-hp="iso-walls"]')
+    && root(warm).querySelector('[data-hp="projection-toggle"]')?.getAttribute('aria-pressed') === 'true';
+  warm.remove();
+  const kiosk = await mount(true);
+  result.kioskReadsPreference = !!root(kiosk).querySelector('[data-hp="iso-walls"]');
+  result.kioskHasNoToggle = !root(kiosk).querySelector('[data-hp="projection-toggle"]');
+  return result;
+});
+
+await page.setViewportSize({ width: 820, height: 430 });
+out.orientationResizeKeepsIso = await page.evaluate(async () => {
+  const card = document.querySelector('houseplan-card');
+  window.dispatchEvent(new Event('resize'));
+  await card.updateComplete;
+  await new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)));
+  const anchor = card.renderRoot.querySelector('[data-hp="device"]')?.getBoundingClientRect();
+  return !!card.renderRoot.querySelector('[data-hp="iso-walls"]')
+    && !!anchor && [anchor.left, anchor.top, anchor.width, anchor.height].every(Number.isFinite);
+});
+out.kioskEmergencyOffIsFlat = await page.evaluate(async () => {
+  const card = document.querySelector('houseplan-card');
+  history.replaceState(null, '', '?hp-labs=-iso#space=f1');
+  dispatchEvent(new HashChangeEvent('hashchange'));
+  await card.updateComplete;
+  await new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)));
+  return !card.renderRoot.querySelector('[data-hp="iso-walls"]')
+    && !card.renderRoot.querySelector('[data-hp="projection-toggle"]');
+});
+
+checkAll(out);
+await finish(browser, out);

demo/smoke_merge_split.mjs

@@ -43,8 +43,25 @@ await restore();
 // grid-aligned test room (real rooms are snapped; demo rooms are not)
 await page.evaluate(()=>{
   const c=window.__card;
-  c._serverCfg.spaces.find(s=>s.id==='f1').rooms.push(
+  const sp = c._serverCfg.spaces.find(s=>s.id==='f1');
+  const pitch = 1 / 240;
+  const wallKey = (a, b) => {
+    const q = (v) => Math.round(v / pitch) * pitch;
+    let dx = b[0] - a[0], dy = b[1] - a[1];
+    const len = Math.hypot(dx, dy) || 1;
+    dx /= len; dy /= len;
+    if (dx < -1e-12 || (Math.abs(dx) <= 1e-12 && dy < 0)) { dx = -dx; dy = -dy; }
+    let angle = Math.atan2(dy, dx);
+    if (angle < 0) angle += Math.PI;
+    angle = Math.round(angle * 1800) / 1800;
+    return `${q((a[0] + b[0]) / 2).toFixed(6)},${q((a[1] + b[1]) / 2).toFixed(6)}@${angle.toFixed(4)}`;
+  };
+  const outline = [[0.05,0.0625],[0.5,0.0625],[0.5,0.5],[0.05,0.5]];
+  sp.rooms.push(
     {id:'rg', name:'GridRoom', area:null, poly:[[0.05,0.0625],[0.5,0.0625],[0.5,0.5],[0.05,0.5]]});
+  sp.walls = [...(sp.walls || []), ...outline.map((a, index) => ({
+    key: wallKey(a, outline[(index + 1) % outline.length]), cm: 15,
+  }))];
   c._regSignature=''; c._maybeRebuildDevices(); c.requestUpdate();
 });
 // SPLIT rg vertical chord x=0.25 (all on grid nodes)
@@ -66,6 +83,12 @@ s = await S();
 out.splitRooms = s.rooms.length===6;                      // 4 базовых + rg разрезанная надвое
 out.bigKeepsLiving = s.rooms.some(r=>r.id==='r1' && r.area==='living_room');
 out.newRoom = s.rooms.find(r=>!['r1','r2','r3','r4','rg'].includes(r.id))?.name;
+out.splitKeepsLegacyWallThickness = await page.evaluate(() => {
+  const c = window.__card;
+  const y = 0.0625 * c._spaceH;
+  return Math.abs(c._intervalCm([50, y, 250, y]) - 15) < 1e-9
+    && Math.abs(c._intervalCm([250, y, 500, y]) - 15) < 1e-9;
+});
 await restore();
 
 // AUD-159B7-01: one open span crossing the Split point belongs to two room

demo/smoke_motion_sense.mjs

@@ -53,7 +53,7 @@ const res = await page.evaluate(async () => {
   const flashEl = sr().querySelector('.dev.activity-event');
   out.motionTripFlashes = !!flashEl;
   out.flashIsNotOn = !!flashEl && !flashEl.classList.contains('on') && !flashEl.classList.contains('open');
-  const waves = flashEl ? [...flashEl.querySelectorAll('.activity-ring.event i')] : [];
+  const waves = flashEl ? [...flashEl.querySelectorAll('.device-pulse.short.event i')] : [];
   const firstWave = waves[0] ? getComputedStyle(waves[0]) : null;
   out.flashAnimated = !!firstWave && firstWave.animationName.startsWith('hp-pulse-short');
   out.flashFinite = waves.length === 3
@@ -105,17 +105,17 @@ const res = await page.evaluate(async () => {
   const a3 = senseAnim(el3);
   out.rapidSecondFlashStillPlays = !!a3 && a3.playState === 'running';
   out.rapidRingVisibleAfterFirstWindow = !!el3
-    && [...el3.querySelectorAll('.activity-ring.event i')]
+    && [...el3.querySelectorAll('.device-pulse.short.event i')]
       .some((w) => parseFloat(getComputedStyle(w).opacity) > 0.03);
   // и класс уходит через полные ~3.3s после ВТОРОГО trip (flashTs/таймер обновлены)
   await sleep(1400); await c.updateComplete;
   out.rapidFlashEndsAfterSecondWindow = sr().querySelectorAll('.dev.activity-event').length === 0;
 
-  // --- occupancy: статичное кольцо presence, без анимации -----------------
+  // --- occupancy: continuous presence pulse --------------------------------
   await setMotion('on', 'occupancy');
   const holdEl = sr().querySelector('.dev.activity-presence');
   out.occupancyHolds = !!holdEl;
-  const holdRing = holdEl?.querySelector('.activity-ring.presence i:first-child');
+  const holdRing = holdEl?.querySelector('.device-pulse.continuous.presence i:first-child');
   const hAfter = holdRing ? getComputedStyle(holdRing) : null;
   out.holdAnimated = !!hAfter && hAfter.animationName === 'hp-pulse-continuous';
   out.holdAnimationCalm = !!hAfter && hAfter.animationDuration === '2.4s';
@@ -154,7 +154,7 @@ const res = await page.evaluate(async () => {
   c._showHidden = true; c._setMode('devices'); c.requestUpdate(); await c.updateComplete;
   const ghost = sr().querySelector('.dev.ghost');
   out.ghostNoSense = !!ghost && !ghost.classList.contains('activity-event') && !ghost.classList.contains('activity-presence')
-    && !ghost.querySelector('.activity-ring');
+    && !ghost.querySelector('.device-pulse');
   return out;
 });
 checkAll(res, {});

demo/smoke_nav_persist.mjs

@@ -3,19 +3,22 @@ const { page, browser } = await launch();
 const res = await page.evaluate(async () => {
   const out = {};
   const c = window.__card;
+  // Permission-delayed warm navigation must use the complete transition
+  // authority instead of assigning the private mode field directly.
+  c._setMode('view', false); await c.updateComplete;
+  const realSetMode = c._setMode.bind(c);
+  let resumedThroughSetMode = 0;
+  c._setMode = (...args) => { resumedThroughSetMode += 1; return realSetMode(...args); };
+  c._pendingNavMode = 'devices';
+  c._serverCanWrite = true;
+  out.pendingModeUsesTransitionAuthority = c._resumePendingNavMode() === true
+    && resumedThroughSetMode === 1 && c._mode === 'devices' && c._pendingNavMode == null;
+  delete c._setMode;
+  c._setMode('view', false); await c.updateComplete;
   // выбрать f2 и редактор устройств
   c._space = 'garden'; c._setMode('devices'); await c.updateComplete;
   const nav = JSON.parse(localStorage.getItem('houseplan_card_nav_v1'));
   out.saved = nav.space === 'garden' && !Object.hasOwn(nav, 'mode');
-  // #95: during a same-route remount Lit may still present the old editor DOM
-  // while the new instance fails closed to View and holds the editor only as a
-  // pending intent until can_write arrives. The visible close button is a
-  // newer user command and must cancel that pending intent even though the
-  // runtime field already equals View.
-  c._mode = 'view';
-  c._pendingNavMode = 'devices';
-  c._setMode('view');
-  out.sameModeCloseCancelsPendingEditor = c._mode === 'view' && c._pendingNavMode === null;
   c._setMode('devices'); await c.updateComplete;
   // пересоздать карточку (эмуляция закрытия вкладки; кэш конфига в LS уже есть)
   const c2 = document.createElement('houseplan-card');

demo/smoke_opening_binding.mjs

@@ -0,0 +1,140 @@
+// #104 pre-beta smoke: an opening owns exact contact/lock references
+// independently of the standalone marker tombstone. This file is added during
+// implementation but intentionally runs only in the pre-beta smoke gate.
+import { launch, checkAll, finish } from './serve.mjs';
+
+const { page, browser } = await launch();
+const out = await page.evaluate(async () => {
+  const c = window.__card;
+  const sr = () => c.shadowRoot || c.renderRoot;
+  const settle = async () => {
+    c.requestUpdate();
+    await c.updateComplete;
+    await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+  };
+  const openingRefs = () => c._serverCfg.spaces
+    .find((space) => space.id === 'f1').openings
+    .map(({ id, contact, lock }) => ({ id, contact, lock }));
+
+  const space = c._serverCfg.spaces.find((item) => item.id === 'f1');
+  space.openings = [
+    {
+      id: 'hp104-a', type: 'door', x: 0.22, y: 0.14, angle: 0, length: 0.09,
+      contact: 'binary_sensor.window', lock: 'lock.front_door',
+    },
+    {
+      id: 'hp104-b', type: 'door', x: 0.40, y: 0.14, angle: 0, length: 0.09,
+      contact: 'binary_sensor.window', lock: 'lock.front_door',
+    },
+  ];
+  const refsBefore = JSON.stringify(openingRefs());
+  c._serverCfg = {
+    ...c._serverCfg,
+    markers: [
+      { id: 'window-gone', binding: 'entity:binary_sensor.window', removed: true, hidden: true },
+      { id: 'lock-gone', binding: 'device:d_lock', removed: true, hidden: true },
+    ],
+  };
+  c._regSignature = '';
+  c._maybeRebuildDevices();
+  c.hass = { ...c.hass };
+  await settle();
+
+  const contactValues = c._contactCandidates().map((item) => item.value);
+  const lockValues = c._lockCandidates().map((item) => item.value);
+  const openings = c._openingsR;
+  const result = {
+    entityTombstoneCandidate: contactValues.includes('binary_sensor.window'),
+    deviceTombstoneCandidate: lockValues.includes('lock.front_door'),
+    markerContributionsStaySuppressed:
+      !c._planEntityAvailable('binary_sensor.window')
+      && !c._planEntityAvailable('lock.front_door'),
+    exactOpeningReferencesStayActive:
+      c._openingEntityAvailable('binary_sensor.window')
+      && c._openingEntityAvailable('lock.front_door'),
+    sharedContactDrivesBoth: openings.length === 2
+      && openings.every((opening) => c._openingAmt(opening) === 1),
+    sharedLockRendersTwice: sr().querySelectorAll('.oplock').length === 2,
+    deletionKeepsOpeningFields: JSON.stringify(openingRefs()) === refsBefore,
+  };
+
+  // The opening info card remains the one deliberate lock surface.
+  c._openingInfo = openings[0];
+  await settle();
+  result.infoHasContactAndLock = sr().querySelectorAll('.oprow').length === 2;
+  result.infoHasOneLockAction = sr().querySelectorAll('.lockact').length === 1;
+  const calls = [];
+  c.hass = {
+    ...c.hass,
+    callService: async (domain, service, data) => calls.push({ domain, service, data }),
+  };
+  c._lockAction('lock.front_door', 'lock');
+  result.tombstonedMarkerDoesNotBlockExplicitLock = calls.length === 1
+    && calls[0].domain === 'lock' && calls[0].service === 'lock';
+
+  // Re-adding replaces only the marker record; exact opening fields remain
+  // byte-for-byte the same and therefore cannot be duplicated or retargeted.
+  c._serverCfg = {
+    ...c._serverCfg,
+    markers: [
+      { id: 'window-back', binding: 'entity:binary_sensor.window', hidden: false },
+      { id: 'lock-back', binding: 'device:d_lock', hidden: false },
+    ],
+  };
+  c._regSignature = '';
+  c._maybeRebuildDevices();
+  await settle();
+  result.readdKeepsOpeningFields = JSON.stringify(openingRefs()) === refsBefore;
+
+  // Active registry rows with unknown transport state keep the reference but
+  // expose no lock action; disabled and orphaned exact rows fail closed.
+  c.hass = {
+    ...c.hass,
+    devices: {
+      ...c.hass.devices,
+      hp104_disabled_parent: { id: 'hp104_disabled_parent', disabled_by: 'user' },
+    },
+    entities: {
+      ...c.hass.entities,
+      'lock.hp104_disabled': {
+        entity_id: 'lock.hp104_disabled', device_id: null, disabled_by: 'user',
+      },
+      'lock.hp104_disabled_parent': {
+        entity_id: 'lock.hp104_disabled_parent', device_id: 'hp104_disabled_parent', disabled_by: null,
+      },
+      'lock.hp104_orphan': {
+        entity_id: 'lock.hp104_orphan', device_id: 'hp104_missing_parent', disabled_by: null,
+      },
+    },
+    states: {
+      ...c.hass.states,
+      'lock.front_door': { ...c.hass.states['lock.front_door'], state: 'unavailable' },
+      'lock.hp104_disabled': { entity_id: 'lock.hp104_disabled', state: 'locked', attributes: {} },
+      'lock.hp104_disabled_parent': {
+        entity_id: 'lock.hp104_disabled_parent', state: 'locked', attributes: {},
+      },
+      'lock.hp104_orphan': { entity_id: 'lock.hp104_orphan', state: 'locked', attributes: {} },
+    },
+    callService: async (domain, service, data) => calls.push({ domain, service, data }),
+  };
+  await settle();
+  c._openingInfo = c._openingsR[0];
+  await settle();
+  const unavailableCandidates = c._lockCandidates().map((item) => item.value);
+  result.unavailableRemainsCandidate = unavailableCandidates.includes('lock.front_door');
+  result.unavailableShowsUnknownWithoutAction = sr().querySelector('.oplock.unknown') != null
+    && sr().querySelector('.lockact') == null;
+  result.disabledAndOrphanedAreRejected = !unavailableCandidates.includes('lock.hp104_disabled')
+    && !unavailableCandidates.includes('lock.hp104_disabled_parent')
+    && !unavailableCandidates.includes('lock.hp104_orphan');
+  const callsBeforeRejected = calls.length;
+  c._lockAction('lock.hp104_disabled', 'lock');
+  c._lockAction('lock.hp104_disabled_parent', 'lock');
+  c._lockAction('lock.hp104_orphan', 'lock');
+  result.rejectedLocksNeverCallService = calls.length === callsBeforeRejected;
+
+  return result;
+});
+
+checkAll(out);
+await finish(browser, out);

demo/smoke_opening_measure.mjs

@@ -184,19 +184,20 @@ await page.evaluate(() => {
     { id: 'r2', name: 'Kitchen', poly: [[0.55, 0.14], [0.96, 0.14], [0.96, 0.46], [0.55, 0.46]] },
   ];
   sp.openings = [];
-  c._setMode('plan'); c._tool = 'opening';
+  c._setMode('plan'); c._activateOpeningPlacement('door');
   c._cfgEpoch++; c.requestUpdate();
   return c.updateComplete && true;
 });
 await settle();
-const ghosts = () => page.evaluate(() => window.__card.renderRoot.querySelectorAll('.opghost').length);
+const previews = () => page.evaluate(() =>
+  window.__card.renderRoot.querySelectorAll('.opening-preview').length);
 
 // hover off-centre on r1's top wall (own edge 40..550, y = 140)
 {
   const [hx, hy] = await screenPt(460, 141);
   await page.mouse.move(hx, hy, { steps: 3 });
   await settle();
-  check('place_ghost_shown', await ghosts(), 1);
+  check('place_preview_shown', await previews(), 1);
   check('place_two_badges', (await badges()).length, 2);
   // edges 422.5 / 497.5 -> 382.5 u (4.59 m) left, 52.5 u (0.63 m) right
   const [a, b] = await nums();
@@ -231,12 +232,13 @@ const ghosts = () => page.evaluate(() => window.__card.renderRoot.querySelectorA
   });
   check('place_tick_perpendicular', !!g && near(g.x1, 295, 1e-6) && near(g.x2, 295, 1e-6)
     && near(g.y2 - g.y1, 30, 1e-6));
-  // the ghost itself already sits on the magnetised centre
+  // the architectural preview itself already sits on the magnetised centre
   const gh = await page.evaluate(() => {
-    const el = window.__card.renderRoot.querySelector('.opghost');
-    return el && (+el.getAttribute('x1') + +el.getAttribute('x2')) / 2;
+    const el = window.__card.renderRoot.querySelector('.opening-preview');
+    const match = /translate\(\s*([-+\d.eE]+)/.exec(el?.getAttribute('transform') || '');
+    return match ? Number(match[1]) : null;
   });
-  check('place_ghost_magnetised', near(gh, 295, 1e-6));
+  check('place_preview_magnetised', near(gh, 295, 1e-6));
 }
 
 // Shift cannot opt out of the magnet, the badges stay
@@ -248,10 +250,11 @@ const ghosts = () => page.evaluate(() => window.__card.renderRoot.querySelectorA
   check('place_tick_with_shift', await tick(), 1);
   check('place_badges_with_shift', (await badges()).length, 2);
   const gh = await page.evaluate(() => {
-    const el = window.__card.renderRoot.querySelector('.opghost');
-    return el && (+el.getAttribute('x1') + +el.getAttribute('x2')) / 2;
+    const el = window.__card.renderRoot.querySelector('.opening-preview');
+    const match = /translate\(\s*([-+\d.eE]+)/.exec(el?.getAttribute('transform') || '');
+    return match ? Number(match[1]) : null;
   });
-  check('place_ghost_magnetised_with_shift', near(gh, 295, 1e-6));
+  check('place_preview_magnetised_with_shift', near(gh, 295, 1e-6));
   await page.keyboard.up('Shift');
 }
 
@@ -266,7 +269,7 @@ const ghosts = () => page.evaluate(() => window.__card.renderRoot.querySelectorA
   check('place_dialog_x_magnetised', near(await page.evaluate(() => window.__card._openingDialog.x), 295, 1e-6));
   check('place_badges_gone', (await badges()).length, 0);
   check('place_tick_gone', await tick(), 0);
-  check('place_ghost_gone', await ghosts(), 0);
+  check('place_preview_gone', await previews(), 0);
   // …and confirming the dialog writes the opening at the magnetised point
   await page.evaluate(() => { const c = window.__card; c._saveOpening(); return c.updateComplete && true; });
   await settle();

demo/smoke_opening_preview.mjs

@@ -1,43 +1,233 @@
+// Unified Opening tool (#75/#76): the toolbar launcher opens the shared
+// secondary tray, a type preset arms placement, and the hover preview is the
+// real architectural symbol painted above the wall body. Tests are authored
+// here but run only as part of the release gate.
 import { launch, checkAll, finish } from './serve.mjs';
+
 const { page, browser } = await launch();
+await page.evaluate(() => {
+  window.__card._setMode('plan');
+  return window.__card.updateComplete;
+});
+await page.waitForTimeout(240);
+await page.evaluate(() => new Promise((resolve) =>
+  requestAnimationFrame(() => requestAnimationFrame(resolve))));
+
 const res = await page.evaluate(async () => {
   const out = {};
-  const c = window.__card;
-  const sr = () => c.shadowRoot || c.renderRoot;
-  c._setMode('plan'); c._tool = 'opening'; await c.updateComplete;
-  const rooms = c._spaceModel().rooms;
-  const r = rooms.find((x) => x.id === 'r1');
-  const poly = r.poly || [[r.x, r.y], [r.x + r.w, r.y], [r.x + r.w, r.y + r.h], [r.x, r.y + r.h]];
+  const card = window.__card;
+  const root = () => card.shadowRoot || card.renderRoot;
+  const settle = async () => {
+    card.requestUpdate();
+    await card.updateComplete;
+    await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+  };
+  const visibleGeometrySignature = (container) => (container
+    ? [container, ...container.querySelectorAll('g, line, path, rect')]
+    : []).map((element) => ({
+    tag: element.tagName,
+    cls: element.getAttribute('class') || '',
+    geometry: [
+      'transform', 'd', 'x', 'y', 'x1', 'y1', 'x2', 'y2', 'width', 'height',
+      'stroke-dasharray', 'stroke-dashoffset', 'style',
+    ]
+      .map((name) => `${name}=${element.getAttribute(name) || ''}`).join('|'),
+  }));
+  const launcher = () => root().querySelector('[data-editor-group="opening"]');
+  const choose = async (type) => {
+    launcher().click();
+    await settle();
+    const item = root().querySelector(`[data-group-item="${type}"]`);
+    item?.click();
+    await settle();
+    return !!item;
+  };
+
+  out.oneLauncher = root().querySelectorAll('[data-editor-group="opening"]').length === 1;
+  out.oneSecondaryHost = root().querySelectorAll('.editor-secondary-host').length === 1;
+  out.launcherDoesNotArm = card._tool !== 'opening' && card._openingPreset == null;
+  const stageHeightBeforeMenu = root().querySelector('.stage').getBoundingClientRect().height;
+  const geometryBeforeMenu = JSON.stringify(card._curSpaceCfg.openings || []);
+  const epochBeforeMenu = card._cfgEpoch;
+  launcher().click();
+  await settle();
+  out.menuHasThreeTypes = root().querySelectorAll('.editor-group-item').length === 3;
+  out.launcherStillDoesNotArm = card._tool !== 'opening' && card._openingPreset == null;
+  out.menuDoesNotResizeStage = Math.abs(
+    root().querySelector('.stage').getBoundingClientRect().height - stageHeightBeforeMenu,
+  ) < 1;
+  card._editorSecondary.closeGroup(false);
+  await settle();
+
+  out.windowChoice = await choose('window');
+  out.windowDefault = card._tool === 'opening'
+    && card._openingPreset?.type === 'window' && card._openingPreset?.lengthCm === 120;
+  out.doorChoice = await choose('door');
+  out.doorDefault = card._openingPreset?.type === 'door' && card._openingPreset?.lengthCm === 90;
+  out.launcherReflectsActivePreset = launcher()?.getAttribute('aria-pressed') === 'true';
+  out.gateChoice = await choose('gate');
+  out.gateDefault = card._openingPreset?.type === 'gate' && card._openingPreset?.lengthCm === 300;
+
+  // Return to Door for geometry assertions.
+  await choose('door');
+  const room = card._spaceModel().rooms.find((item) => item.id === 'r1')
+    || card._spaceModel().rooms[0];
+  const poly = room.poly || [
+    [room.x, room.y], [room.x + room.w, room.y],
+    [room.x + room.w, room.y + room.h], [room.x, room.y + room.h],
+  ];
   const wallMid = [(poly[0][0] + poly[1][0]) / 2, (poly[0][1] + poly[1][1]) / 2];
-  // 1) курсор возле стены → пунктирный призрак есть
-  c._cursorPt = [wallMid[0], wallMid[1] + c._gridPitch * 0.5]; c.requestUpdate(); await c.updateComplete;
-  const ghost = sr().querySelector('.opghost');
-  out.ghostNearWall = !!ghost;
-  if (ghost) {
-    const cs = getComputedStyle(ghost);
-    out.dashed = cs.strokeDasharray !== 'none' && cs.strokeDasharray !== '';
-    // призрак лежит на стене (y координаты концов совпадают с y стены)
-    out.onWall = Math.abs(Number(ghost.getAttribute('y1')) - poly[0][1]) < 0.5
-      && Math.abs(Number(ghost.getAttribute('y2')) - poly[0][1]) < 0.5;
-    // длина = 90 см в рендер-единицах
-    const len = Math.hypot(ghost.getAttribute('x2') - ghost.getAttribute('x1'), ghost.getAttribute('y2') - ghost.getAttribute('y1'));
-    out.len90cm = Math.abs(len - c._cmToUnits(90)) < 0.5;
-  }
-  // 2) курсор далеко от стен → призрака нет
-  const center = c._roomCenter(r);
-  c._cursorPt = center; c.requestUpdate(); await c.updateComplete;
-  out.noGhostFarFromWall = !sr().querySelector('.opghost');
-  // 3) в других инструментах призрака нет
-  c._tool = 'draw'; c._cursorPt = [wallMid[0], wallMid[1] + 2]; c.requestUpdate(); await c.updateComplete;
-  out.noGhostOtherTool = !sr().querySelector('.opghost');
-  // 4) над существующим проёмом призрак не рисуется (там клик = редактирование)
-  c._serverCfg = { ...c._serverCfg, spaces: c._serverCfg.spaces.map((s) => s.id !== c._space ? s : ({
-    ...s, openings: [{ id: 'op9', type: 'door', x: wallMid[0] / 1000, y: wallMid[1] / (1000 / (c._curSpaceCfg.aspect || 1)) * (c._curSpaceCfg.aspect ? 1 : 1), angle: 0, length: 0.09 }] })) };
-  c._tool = 'opening'; c.requestUpdate(); await c.updateComplete;
-  const op = c._openingsR[0];
-  c._cursorPt = [op.rx, op.ry]; c.requestUpdate(); await c.updateComplete;
-  out.noGhostOverExisting = !sr().querySelector('.opghost');
+
+  await choose('window');
+  card._cursorPt = wallMid;
+  await settle();
+  const windowPreview = root().querySelector('.opening-preview[data-kind="window"]');
+  out.windowPreviewGeometry = windowPreview?.querySelectorAll('.op-leaf').length === 2
+    && windowPreview?.querySelectorAll('.op-arc').length === 2;
+  await choose('gate');
+  card._cursorPt = wallMid;
+  await settle();
+  const gatePreview = root().querySelector('.opening-preview[data-kind="gate"]');
+  out.gatePreviewGeometry = gatePreview?.querySelectorAll('.op-leaf').length === 2
+    && gatePreview?.querySelectorAll('.op-arc').length === 0;
+  await choose('door');
+  const axisCandidate = card._resolveOpeningPlacement(wallMid);
+  const target = axisCandidate?.target;
+  const dx = target ? target.b[0] - target.a[0] : 1;
+  const dy = target ? target.b[1] - target.a[1] : 0;
+  const length = Math.hypot(dx, dy) || 1;
+  const bodyOffset = (target?.physicalHalfWidth || 0) * 0.8;
+  card._cursorPt = [wallMid[0] - (dy / length) * bodyOffset,
+    wallMid[1] + (dx / length) * bodyOffset];
+  await settle();
+
+  const preview = root().querySelector('.opening-preview');
+  const previewGeometry = visibleGeometrySignature(preview?.querySelector(':scope > g'));
+  out.previewExists = !!preview;
+  out.previewIsDoor = preview?.getAttribute('data-kind') === 'door';
+  out.previewHasFullSymbol = !!preview?.querySelector('.op-arc')
+    && !!preview?.querySelector('.op-leaf');
+  out.previewHalfTransparent = preview
+    ? Math.abs(Number.parseFloat(getComputedStyle(preview).opacity) - 0.5) < 0.001 : false;
+  out.previewPointerInert = preview?.getAttribute('pointer-events') === 'none';
+  out.previewAriaHidden = preview?.getAttribute('aria-hidden') === 'true';
+  out.previewHasNoPersistentIdentity = !preview?.hasAttribute('data-id')
+    && !preview?.hasAttribute('data-hp');
+  out.typeChoicesDoNotMutateGeometry = card._cfgEpoch === epochBeforeMenu
+    && JSON.stringify(card._curSpaceCfg.openings || []) === geometryBeforeMenu;
+  const wallBody = root().querySelector('.wallbody');
+  out.previewPaintedAfterWall = !wallBody || (!!preview
+    && !!(wallBody.compareDocumentPosition(preview) & Node.DOCUMENT_POSITION_FOLLOWING));
+
+  // A click is authoritative and does not require a preceding hover event.
+  const expectedClick = card._resolveOpeningPlacement(wallMid);
+  const openingIdsBeforeSave = new Set((card._curSpaceCfg.openings || []).map((item) => item.id));
+  card._cursorPt = null;
+  card._openingHoverCandidate = null;
+  card._openingClick(wallMid);
+  await settle();
+  out.clickWithoutHoverOpensDialog = card._openingDialog?.type === 'door'
+    && card._openingDialog?.lengthCm === 90;
+  out.clickDialogMatchesResolver = !!expectedClick && !!card._openingDialog
+    && Math.abs(card._openingDialog.x - expectedClick.x) < 1e-6
+    && Math.abs(card._openingDialog.y - expectedClick.y) < 1e-6
+    && Math.abs(card._openingDialog.angle - expectedClick.angle) < 1e-6
+    && card._openingDialog.flipH === expectedClick.flipH
+    && card._openingDialog.flipV === expectedClick.flipV;
+  out.previewGoneWhileDialogOpen = !root().querySelector('.opening-preview');
+
+  // Save writes exactly that candidate and keeps the serial-placement preset.
+  card._saveOpening();
+  await settle();
+  const saved = (card._curSpaceCfg.openings || []).find((item) => !openingIdsBeforeSave.has(item.id));
+  out.saveMatchesResolver = !!saved && !!expectedClick
+    && saved.type === expectedClick.type
+    && Math.abs(saved.x * 1000 - expectedClick.x) < 1e-6
+    && Math.abs(saved.y * card._spaceH - expectedClick.y) < 1e-6
+    && Math.abs(saved.angle - expectedClick.angle) < 1e-6
+    && Math.abs(saved.length * 1000 - expectedClick.renderedLength) < 1e-6
+    && !!saved.flip_h === expectedClick.flipH
+    && !!saved.flip_v === expectedClick.flipV;
+  const committed = saved
+    ? root().querySelector(`.opening[data-id="${saved.id}"] > g`)
+    : null;
+  out.previewAndCommittedShareVisibleGeometry = !!committed
+    && JSON.stringify(visibleGeometrySignature(committed)) === JSON.stringify(previewGeometry);
+  out.saveKeepsPreset = card._tool === 'opening' && card._openingPreset?.type === 'door';
+  const savedRender = saved && card._openingsR.find((item) => item.id === saved.id);
+  const savedCenter = savedRender ? [savedRender.rx, savedRender.ry] : wallMid;
+  const savedRad = savedRender ? savedRender.angle * Math.PI / 180 : 0;
+  const farNormal = savedRender ? Math.max(40, savedRender.rlen * 0.45) : 40;
+  const radialLeakPoint = [
+    savedCenter[0] - Math.sin(savedRad) * farNormal,
+    savedCenter[1] + Math.cos(savedRad) * farNormal,
+  ];
+  out.existingOpeningHitBoxIsBounded = !!savedRender
+    && card._openingAt(savedCenter)?.id === saved.id
+    && card._openingAt(radialLeakPoint) == null;
+  card._cursorPt = savedCenter;
+  await settle();
+  out.noPreviewOverExisting = !root().querySelector('.opening-preview');
+
+  const emptyWallMid = poly.map((point, index) => {
+    const next = poly[(index + 1) % poly.length];
+    return [(point[0] + next[0]) / 2, (point[1] + next[1]) / 2];
+  }).find((point) => !card._openingAt(point) && card._resolveOpeningPlacement(point));
+
+  // Cancel of a new, unsaved opening keeps the selected session preset too.
+  if (emptyWallMid) card._openingClick(emptyWallMid);
+  await settle();
+  out.cancelCreateDialogOpened = !!emptyWallMid
+    && !card._openingDialog?.id && card._openingDialog?.type === 'door';
+  card._openingDialog = null;
+  await settle();
+  out.cancelKeepsPreset = card._tool === 'opening' && card._openingPreset?.type === 'door';
+
+  // A viewport transform invalidates the pointer-to-plan projection. The old
+  // world-space preview must disappear until a fresh pointer move arrives.
+  card._cursorPt = emptyWallMid || card._roomCenter(room);
+  await settle();
+  out.previewBeforeZoom = !!root().querySelector('.opening-preview');
+  card._stepZoom(1);
+  await settle();
+  out.zoomClearsStalePreview = !root().querySelector('.opening-preview')
+    && card._openingPreset?.type === 'door';
+  card._cursorPt = card._roomCenter(room);
+  await settle();
+  out.noPreviewAwayFromWalls = !root().querySelector('.opening-preview');
+
+  // Real independent bodies are occluders, not room-owned wall intervals.
+  // They must never become accidental opening-placement targets.
+  const bodyCentre = card._roomCenter(room);
+  const bodyX = bodyCentre[0] / 1000;
+  const bodyY = bodyCentre[1] / card._spaceH;
+  card._curSpaceCfg.partitions = [{
+    id: 'opening-smoke-partition', a: [bodyX - 0.05, bodyY], b: [bodyX + 0.05, bodyY], cm: 20,
+  }];
+  card._cfgEpoch++;
+  card._openingPlacementIntervalsCache = null;
+  card._cursorPt = bodyCentre;
+  await settle();
+  out.partitionIsNotOpeningTarget = !root().querySelector('.opening-preview')
+    && card._resolveOpeningPlacement(bodyCentre) == null;
+  card._curSpaceCfg.partitions = [];
+  card._curSpaceCfg.wall_columns = [{
+    id: 'opening-smoke-column', shape: 'square', cm: 30, center: [bodyX, bodyY], angle: 0,
+  }];
+  card._cfgEpoch++;
+  card._openingPlacementIntervalsCache = null;
+  await settle();
+  out.columnIsNotOpeningTarget = !root().querySelector('.opening-preview')
+    && card._resolveOpeningPlacement(bodyCentre) == null;
+  card._cancelPath();
+  card._tool = 'draw';
+  await settle();
+  out.leavingToolClearsPreset = card._openingPreset == null
+    && !root().querySelector('.opening-preview')
+    && launcher()?.getAttribute('aria-pressed') === 'false';
+
   return out;
 });
+
 checkAll(res);
 await finish(browser, res);

demo/smoke_readonly_cold_start.mjs

@@ -0,0 +1,187 @@
+// #131: a read-only HA session may read the House Plan snapshot while HA
+// rejects event subscriptions. The initial frame must still select one exact
+// space and render every raw-space layer before any user click.
+import { launch, checkAll, finish } from './serve.mjs';
+import { makeVisualMatrixFixture } from './fixtures/visual-matrix.mjs';
+
+const fixture = makeVisualMatrixFixture();
+const { page, browser } = await launch({ width: 820, height: 760 });
+
+const result = await page.evaluate(async (rawFixture) => {
+  const out = {};
+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  const HP = customElements.get('houseplan-card');
+  const host = document.getElementById('host');
+  window.__card.remove();
+  HP._warmBootReset?.();
+  for (const key of Object.keys(localStorage)) {
+    if (key.startsWith('houseplan_card_')) localStorage.removeItem(key);
+  }
+  history.replaceState(null, '', '/demo.html');
+
+  const fixture = structuredClone(rawFixture);
+  const lighting = fixture.config.spaces.find((space) => space.id === 'golden-lighting');
+  const geometry = fixture.config.spaces.find((space) => space.id === 'golden-geometry');
+  lighting.id = 'home';
+  lighting.title = 'Home';
+  lighting.settings = {
+    ...lighting.settings,
+    fill_mode: 'custom',
+    custom_fill: { c: '#cdbb96', a: 0.42 },
+    glow_enabled: true,
+    show_borders: true,
+  };
+  lighting.decor = [{
+    id: 'readonly-furniture', kind: 'rect', x: 0.16, y: 0.18, w: 0.12, h: 0.08,
+    color: '#8d6e63', opacity: 1, width_cm: 2, fill: true,
+    fill_color: '#bcaaa4', fill_opacity: 1,
+  }];
+  geometry.id = 'upstairs';
+  geometry.title = 'Upstairs';
+  fixture.config.spaces = [lighting, geometry];
+  fixture.config.markers.push({
+    id: 'golden-light-one', binding: 'device:golden-light-one', display: 'value',
+  });
+  fixture.layout = Object.fromEntries(Object.entries(fixture.layout).map(([id, pos]) => [
+    id,
+    { ...pos, s: pos.s === 'golden-lighting' ? 'home' : pos.s === 'golden-geometry' ? 'upstairs' : pos.s },
+  ]));
+
+  const base = window.__mkHass();
+  const makeHass = (subscriptionMode = 'partial') => {
+    const calls = { configGets: 0, events: {}, unsubscribed: [] };
+    const connection = {
+      subscribeEvents: async (callback, event) => {
+        calls.events[event] = (calls.events[event] || 0) + 1;
+        if (String(event).startsWith('houseplan_')
+            && (subscriptionMode === 'reject-all'
+              || event === 'houseplan_config_updated' || event === 'houseplan_trail_updated')) {
+          throw new Error('unauthorized');
+        }
+        return () => { calls.unsubscribed.push(event); };
+      },
+      subscribeMessage: async () => () => {},
+    };
+    const hass = {
+      ...base,
+      user: { id: 'readonly', name: 'Readonly', is_admin: false },
+      devices: fixture.devices,
+      entities: fixture.entities,
+      areas: fixture.areas,
+      states: fixture.states,
+      connection,
+      callWS: async (message) => {
+        if (message.type === 'houseplan/config/get') {
+          calls.configGets += 1;
+          return { config: structuredClone(fixture.config), rev: 131, can_write: false };
+        }
+        if (message.type === 'houseplan/layout/get') {
+          return { layout: structuredClone(fixture.layout), rev: 131 };
+        }
+        if (message.type === 'houseplan/trail/get') return { trails: {} };
+        if (message.type === 'config/device_registry/list') return Object.values(fixture.devices);
+        if (message.type === 'config/entity_registry/list') return Object.values(fixture.entities);
+        if (message.type === 'config_entries/get') {
+          return [{ entry_id: 'golden_entry', domain: 'houseplan_golden', title: 'Golden' }];
+        }
+        if (message.type === 'manifest/list') {
+          return [{ domain: 'houseplan_golden', name: 'Golden' }];
+        }
+        return { ok: true };
+      },
+    };
+    return { hass, calls };
+  };
+
+  const layerSnapshot = (card) => {
+    const root = card.shadowRoot || card.renderRoot;
+    return {
+      exactSpace: card._curSpaceCfg?.id || null,
+      activeSpace: root.querySelector('[data-hp="space-tab"].active')?.getAttribute('data-id') || null,
+      rooms: root.querySelectorAll('[data-hp="room"]').length,
+      decor: root.querySelectorAll('[data-hp="decor"]').length,
+      walls: root.querySelectorAll('.wallbodies .wallbody-fill').length,
+      glow: root.querySelectorAll('.glow-spot').length,
+      devices: root.querySelectorAll('[data-hp="device"]').length,
+      values: root.querySelectorAll('[data-hp="device"] .valtext').length,
+    };
+  };
+  const complete = (snapshot) => snapshot.exactSpace === 'home'
+    && snapshot.activeSpace === 'home' && snapshot.rooms > 0 && snapshot.decor > 0
+    && snapshot.walls > 0 && snapshot.glow > 0 && snapshot.devices > 0 && snapshot.values > 0;
+  const waitForCard = async (card, calls, kiosk = false) => {
+    const until = performance.now() + 9000;
+    while (performance.now() < until) {
+      const snapshot = layerSnapshot(card);
+      const allSubscriptionsTried = ['houseplan_config_updated', 'houseplan_trail_updated', 'houseplan_layout_updated']
+        .every((event) => calls.events[event] === 1);
+      if (card._loadOk && !card._loading && card._booting === false
+          && allSubscriptionsTried && complete({
+            ...snapshot,
+            activeSpace: kiosk ? 'home' : snapshot.activeSpace,
+          })) return snapshot;
+      await sleep(25);
+    }
+    throw new Error(`readonly card did not settle: ${JSON.stringify({
+      state: layerSnapshot(card), calls, space: card._space, loadOk: card._loadOk,
+    })}`);
+  };
+  const mount = async (title, options = {}) => {
+    const runtime = makeHass(options.subscriptionMode);
+    const card = document.createElement('houseplan-card');
+    card.setConfig({ type: 'custom:houseplan-card', title, kiosk: !!options.kiosk });
+    host.appendChild(card);
+    card.hass = runtime.hass;
+    const snapshot = await waitForCard(card, runtime.calls, !!options.kiosk);
+    return { card, snapshot, ...runtime };
+  };
+
+  const cold = await mount('Readonly cold start');
+  out.coldSelectsExactSpace = cold.card._space === 'home'
+    && cold.snapshot.exactSpace === 'home' && cold.snapshot.activeSpace === 'home';
+  out.coldRendersAllSpatialLayers = complete(cold.snapshot);
+  out.readOnlyStaysReadOnly = cold.card._canEdit === false
+    && !(cold.card.shadowRoot || cold.card.renderRoot).querySelector('.modetab');
+  out.allSubscriptionsAttempted = ['houseplan_config_updated', 'houseplan_trail_updated', 'houseplan_layout_updated']
+    .every((event) => cold.calls.events[event] === 1);
+  out.allowedSubscriptionAdopted = typeof cold.card._unsubLayout === 'function'
+    && !cold.card._unsubCfg && !cold.card._unsubTrail;
+  out.cacheWritten = !!localStorage.getItem('houseplan_card_cfg_v1');
+  const beforeClick = layerSnapshot(cold.card);
+  cold.card._pickSpace('home');
+  await cold.card.updateComplete;
+  out.activeTabClickIsNoop = JSON.stringify(layerSnapshot(cold.card)) === JSON.stringify(beforeClick);
+  await sleep(700);
+  out.optionalFailureNoFullRetry = cold.calls.configGets === 1;
+  cold.card.remove();
+  await sleep(20);
+  out.successfulSubscriptionCleanedUp = cold.calls.unsubscribed.includes('houseplan_layout_updated');
+
+  const warm = await mount('Readonly cold start');
+  out.warmRemountKeepsCompleteSpace = complete(warm.snapshot) && warm.card._space === 'home';
+  warm.card.remove();
+  await sleep(20);
+
+  HP._warmBootReset?.();
+  const reload = await mount('Readonly simulated reload');
+  out.cachedReloadKeepsCompleteSpace = complete(reload.snapshot) && reload.card._space === 'home';
+  reload.card.remove();
+  await sleep(20);
+
+  HP._warmBootReset?.();
+  localStorage.removeItem('houseplan_card_cfg_v1');
+  localStorage.removeItem('houseplan_card_nav_v1');
+  const kiosk = await mount('Readonly cold kiosk', { kiosk: true, subscriptionMode: 'reject-all' });
+  const kioskRoot = kiosk.card.shadowRoot || kiosk.card.renderRoot;
+  out.coldKioskCompleteWithoutHeaderAction = kiosk.card._space === 'home'
+    && kiosk.snapshot.exactSpace === 'home' && kiosk.snapshot.rooms > 0
+    && kiosk.snapshot.decor > 0 && kiosk.snapshot.walls > 0 && kiosk.snapshot.glow > 0
+    && kiosk.snapshot.devices > 0 && getComputedStyle(kioskRoot.querySelector('.hdr')).display === 'none';
+  out.kioskCacheWritten = !!localStorage.getItem('houseplan_card_cfg_v1');
+  kiosk.card.remove();
+
+  return out;
+}, fixture);
+
+checkAll(result);
+await finish(browser, result);

demo/smoke_split_corner_wall.mjs

@@ -0,0 +1,146 @@
+/** Issue #123: a Split ending at a room vertex must not reshape the facade. */
+import { launch, checkAll, finish } from './serve.mjs';
+
+const { page, browser } = await launch();
+
+const res = await page.evaluate(async () => {
+  const out = {};
+  const c = window.__card;
+  const sr = () => c.shadowRoot || c.renderRoot;
+  const sp = () => c._serverCfg.spaces.find((space) => space.id === c._space);
+  const pitch = 1 / 240;
+  const wallKey = (a, b) => {
+    const q = (value) => Math.round(value / pitch) * pitch;
+    let dx = b[0] - a[0], dy = b[1] - a[1];
+    const length = Math.hypot(dx, dy) || 1;
+    dx /= length; dy /= length;
+    if (dx < -1e-12 || (Math.abs(dx) <= 1e-12 && dy < 0)) { dx = -dx; dy = -dy; }
+    let angle = Math.atan2(dy, dx);
+    if (angle < 0) angle += Math.PI;
+    angle = Math.round(angle * 1800) / 1800;
+    return `${q((a[0] + b[0]) / 2).toFixed(6)},${q((a[1] + b[1]) / 2).toFixed(6)}@${angle.toFixed(4)}`;
+  };
+  const entry = (a, b, cm) => ({ key: wallKey(a, b), a: [...a], b: [...b], cm });
+  const update = async () => {
+    c._cfgEpoch++;
+    c._wallUnionCache = null;
+    c._lightBarrierCache = null;
+    c.requestUpdate();
+    await c.updateComplete;
+  };
+  const bbox = (element) => {
+    const box = element?.getBBox?.();
+    return box ? [box.x, box.y, box.width, box.height] : null;
+  };
+  const sameBox = (a, b, epsilon = 0.01) => !!a && !!b
+    && a.every((value, index) => Math.abs(value - b[index]) <= epsilon);
+
+  const a = [0.10, 0.10], tr = [0.90, 0.10], b = [0.90, 0.50];
+  const br = [0.90, 0.90], bl = [0.10, 0.90];
+  const original = { id: 'corner-source', name: 'Corner source', area: null, poly: [a, tr, br, bl] };
+  const outerBefore = [
+    entry(a, tr, 15), entry(tr, br, 15), entry(br, bl, 15), entry(bl, a, 15),
+  ];
+  const outerAfter = [
+    entry(a, tr, 15), entry(tr, b, 15), entry(b, br, 15),
+    entry(br, bl, 15), entry(bl, a, 15),
+  ];
+  const splitRooms = [
+    { id: 'corner-source', name: 'Corner source', area: null, poly: [a, tr, b] },
+    { id: 'corner-fresh', name: 'Corner fresh', area: null, poly: [b, br, bl, a] },
+  ];
+
+  const space = sp();
+  space.settings = { ...(space.settings || {}), show_borders: true };
+  space.rooms = [structuredClone(original)];
+  space.walls = structuredClone(outerBefore);
+  delete space.open_spans;
+  delete space.openings;
+  delete space.partitions;
+  delete space.room_drafts;
+  delete space.wall_columns;
+  c._setMode('plan');
+  await update();
+  const beforeWall = bbox(sr().querySelector('.wallbody'));
+  const beforePaper = bbox(sr().querySelector('.hp-paperg'));
+  out.beforeDrawn = !!beforeWall && !!beforePaper;
+
+  space.rooms = structuredClone(splitRooms);
+  const pathByThickness = {};
+  for (const cm of [0, 15, 100]) {
+    space.walls = [
+      ...structuredClone(outerAfter),
+      ...(cm ? [entry(a, b, cm)] : []),
+    ];
+    await update();
+    const wall = sr().querySelector('.wallbody');
+    const paper = sr().querySelector('.hp-paperg');
+    out[`wall${cm}KeepsFacade`] = sameBox(bbox(wall), beforeWall);
+    out[`paper${cm}KeepsFacade`] = sameBox(bbox(paper), beforePaper);
+    pathByThickness[cm] = wall?.getAttribute('d') || '';
+  }
+  out.dividerChangesInterior = pathByThickness[15] !== pathByThickness[100]
+    && pathByThickness[0] !== pathByThickness[15];
+
+  const persisted = JSON.stringify({ rooms: space.rooms, walls: space.walls });
+  const planD = sr().querySelector('.wallbody')?.getAttribute('d') || '';
+  const lightSpace = c._spaceModel();
+  const lightPolys = lightSpace.rooms
+    .filter((room) => Array.isArray(room.poly))
+    .map((room) => ({ r: room, poly: room.poly }));
+  const lightPhysical = c._physicalBodiesR(lightSpace);
+  const lightGeom = c._lightBarriers(lightSpace, lightPolys, lightPhysical).masonryGeometry;
+  const lightPoints = lightGeom.flat(2);
+  const lightBox = lightPoints.length ? [
+    Math.min(...lightPoints.map((point) => point[0])),
+    Math.min(...lightPoints.map((point) => point[1])),
+    Math.max(...lightPoints.map((point) => point[0])) - Math.min(...lightPoints.map((point) => point[0])),
+    Math.max(...lightPoints.map((point) => point[1])) - Math.min(...lightPoints.map((point) => point[1])),
+  ] : null;
+  out.lightUsesFacade = sameBox(lightBox, beforeWall);
+
+  c._setMode('view');
+  await update();
+  const viewD = sr().querySelector('.wallbody')?.getAttribute('d') || '';
+  out.planViewParity = !!planD && viewD === planD;
+
+  const kioskBefore = c._config.kiosk;
+  c._config.kiosk = true;
+  await update();
+  out.kioskParity = sr().querySelector('.wallbody')?.getAttribute('d') === planD;
+  c._config.kiosk = kioskBefore;
+
+  history.replaceState(null, '', `?hp-labs=iso#space=${encodeURIComponent(c._space)}`);
+  dispatchEvent(new HashChangeEvent('hashchange'));
+  await c.updateComplete;
+  c._setProjection('iso');
+  await update();
+  out.isoUsesCanonicalBody = !!sr().querySelector('.iso-walls .iso-wall-top')
+    && c._isoSource().build().walls.flat(2).length > 0;
+  c._setProjection('flat');
+  await update();
+
+  await customElements.whenDefined('houseplan-space-card');
+  const cfg = structuredClone(c._serverCfg);
+  const baseCall = c.hass.callWS.bind(c.hass);
+  const staticCard = document.createElement('houseplan-space-card');
+  staticCard.setConfig({ type: 'custom:houseplan-space-card', space: c._space, show_button: false });
+  staticCard.hass = { ...c.hass, callWS: async (message) => {
+    if (message.type === 'houseplan/config/get') return { config: cfg, rev: 1 };
+    if (message.type === 'houseplan/layout/get') return { layout: c._layout || {}, rev: 1 };
+    return baseCall(message);
+  } };
+  document.body.appendChild(staticCard);
+  const started = Date.now();
+  while (!staticCard.renderRoot?.querySelector('.wallbody') && Date.now() - started < 6000)
+    await new Promise((resolve) => setTimeout(resolve, 60));
+  await staticCard.updateComplete;
+  out.staticParity = staticCard.renderRoot?.querySelector('.wallbody')?.getAttribute('d') === planD;
+  staticCard.remove();
+
+  out.renderDoesNotRewriteConfig = JSON.stringify({ rooms: space.rooms, walls: space.walls }) === persisted;
+  return out;
+});
+
+checkAll(res);
+await finish(browser, res);

demo/smoke_sun.mjs

@@ -9,6 +9,13 @@ const res = await page.evaluate(async () => {
   const c = window.__card;
   const sr = () => c.shadowRoot || c.renderRoot;
   const upd = async () => { c.requestUpdate(); await c.updateComplete; };
+  const settleMode = async () => {
+    const started = performance.now();
+    while (c._modeTransitionBusy && performance.now() - started < 1800) {
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      await c.updateComplete;
+    }
+  };
   const setSun = async (azimuth, elevation) => {
     c.hass = { ...c.hass, states: { ...c.hass.states, 'sun.sun': {
       entity_id: 'sun.sun', state: elevation > 0 ? 'above_horizon' : 'below_horizon',
@@ -150,10 +157,12 @@ const res = await page.evaluate(async () => {
   await setSun(90, 5);
   c._setMode('plan');
   await upd();
+  await settleMode();
   out.editorNoRays = domPolys().length === 0;
   out.editorNoDaynight = !sr().querySelector('.stage.daynight');
   c._setMode('view');
   await upd();
+  await settleMode();
   out.viewRaysBack = domPolys().length > 0;
 
   return out;

demo/smoke_virtual_light_toggle.mjs

@@ -0,0 +1,171 @@
+// #107: persistent manual virtual light, shared by two full cards and one static card.
+import { launch, checkAll, finish } from './serve.mjs';
+
+const { page, browser } = await launch({ width: 1200, height: 900 });
+const result = await page.evaluate(async () => {
+  const first = window.__card;
+  const markerId = 'smoke_manual_virtual_light';
+  const space = first._model[0];
+  const room = space.rooms.find((candidate) => candidate.id && candidate.area);
+  const serverConfig = structuredClone(first._serverCfg);
+  serverConfig.markers = [...(serverConfig.markers || []), {
+    id: markerId,
+    name: 'Manual virtual lamp',
+    binding: 'virtual',
+    is_light: true,
+    tap_action: 'toggle',
+    tap_confirm: false,
+    controls: ['light.ceiling'],
+    space: space.id,
+    area: room.area,
+    room_id: room.id,
+  }];
+  const serverLayout = {
+    ...first._layout,
+    [markerId]: { s: space.id, x: 0.32, y: 0.32 },
+  };
+  const virtual = { rev: 0, config_rev: first._cfgRev, off: [] };
+  const subscriptions = new Map();
+  const serviceCalls = [];
+  let toggleCalls = 0;
+  const emit = (event, data) => {
+    for (const listener of subscriptions.get(event) || []) listener({ data });
+  };
+  const baseHass = first.hass;
+  const baseCallWS = baseHass.callWS.bind(baseHass);
+  const connection = {
+    ...baseHass.connection,
+    addEventListener: baseHass.connection?.addEventListener?.bind(baseHass.connection),
+    removeEventListener: baseHass.connection?.removeEventListener?.bind(baseHass.connection),
+    subscribeMessage: baseHass.connection?.subscribeMessage?.bind(baseHass.connection),
+    subscribeEvents: async (callback, event) => {
+      const listeners = subscriptions.get(event) || new Set();
+      listeners.add(callback);
+      subscriptions.set(event, listeners);
+      return () => listeners.delete(callback);
+    },
+  };
+  const hass = {
+    ...baseHass,
+    connection,
+    callService: async (domain, service, data) => {
+      serviceCalls.push({ domain, service, data });
+    },
+    callWS: async (message) => {
+      if (message.type === 'houseplan/config/get') return {
+        config: serverConfig,
+        rev: virtual.config_rev,
+        can_write: true,
+        virtual_lights: structuredClone(virtual),
+      };
+      if (message.type === 'houseplan/layout/get') return {
+        layout: serverLayout,
+        rev: first._layoutRev,
+      };
+      if (message.type === 'houseplan/virtual_light/toggle') {
+        toggleCalls++;
+        const off = new Set(virtual.off);
+        if (off.has(message.marker_id)) off.delete(message.marker_id);
+        else off.add(message.marker_id);
+        virtual.off = [...off].sort();
+        virtual.rev++;
+        const reply = {
+          marker_id: message.marker_id,
+          on: !off.has(message.marker_id),
+          rev: virtual.rev,
+        };
+        queueMicrotask(() => emit('houseplan_virtual_light_updated', reply));
+        return reply;
+      }
+      return baseCallWS(message);
+    },
+  };
+
+  // Reconnect the already mounted card to the fake server authority.
+  first._unsubVirtual?.();
+  first._unsubVirtual = null;
+  first.hass = hass;
+  await first._reloadConfigOnly(true);
+  first._layout = serverLayout;
+  first._regSignature = '';
+  first._maybeRebuildDevices();
+  first._ensureLiveSyncSubscriptions();
+  await first.updateComplete;
+
+  const second = document.createElement('houseplan-card');
+  second.setConfig({ type: 'custom:houseplan-card', icon_size: 3.4 });
+  document.body.append(second);
+  second.hass = hass;
+
+  const staticCard = document.createElement('houseplan-space-card');
+  staticCard.setConfig({ type: 'custom:houseplan-space-card', space: space.id });
+  document.body.append(staticCard);
+  staticCard.hass = hass;
+
+  const waitFor = async (predicate, timeout = 6000) => {
+    const started = Date.now();
+    while (!predicate() && Date.now() - started < timeout) {
+      await new Promise((resolve) => setTimeout(resolve, 40));
+    }
+    return !!predicate();
+  };
+  await waitFor(() => second._devices?.some((device) => device.id === markerId));
+  await waitFor(() => staticCard.renderRoot?.querySelector(`[data-id="${markerId}"]`));
+  await second.updateComplete;
+  await staticCard.updateComplete;
+
+  const deviceOf = (card) => card._devices.find((device) => device.id === markerId);
+  const on = (card) => card._stateClass(deviceOf(card)).includes('on');
+  const staticOn = () => staticCard.renderRoot
+    .querySelector(`[data-id="${markerId}"]`)?.classList.contains('on');
+  const initialEverywhereOn = on(first) && on(second) && staticOn();
+
+  const markerNode = first.renderRoot.querySelector(`.dev[data-id="${markerId}"]`);
+  markerNode.dispatchEvent(new MouseEvent('click', { bubbles: true, composed: true }));
+  await waitFor(() => virtual.rev === 1 && !on(second) && staticOn() === false);
+  await first.updateComplete;
+  const clickEverywhereOff = !on(first) && !on(second) && staticOn() === false;
+
+  // A second real click returns to on; the saved outgoing control never calls HA.
+  markerNode.dispatchEvent(new MouseEvent('click', { bubbles: true, composed: true }));
+  await waitFor(() => virtual.rev === 2 && on(second) && staticOn() === true);
+  const secondClickEverywhereOn = on(first) && on(second) && staticOn();
+
+  const beforeTouch = toggleCalls;
+  markerNode.dispatchEvent(new PointerEvent('pointerdown', {
+    bubbles: true, composed: true, pointerType: 'touch', pointerId: 41,
+    clientX: 100, clientY: 100,
+  }));
+  markerNode.dispatchEvent(new PointerEvent('pointerup', {
+    bubbles: true, composed: true, pointerType: 'touch', pointerId: 41,
+    clientX: 100, clientY: 100,
+  }));
+  markerNode.dispatchEvent(new MouseEvent('click', { bubbles: true, composed: true }));
+  await waitFor(() => virtual.rev === 3 && !on(second) && staticOn() === false);
+  const touchSingleToggle = toggleCalls === beforeTouch + 1;
+
+  // A fresh card must paint the server's off snapshot, not wait for an event.
+  const reloaded = document.createElement('houseplan-card');
+  reloaded.setConfig({ type: 'custom:houseplan-card', icon_size: 3.4 });
+  document.body.append(reloaded);
+  reloaded.hass = hass;
+  await waitFor(() => reloaded._devices?.some((device) => device.id === markerId));
+  await reloaded.updateComplete;
+  const reloadFirstStateOff = !on(reloaded);
+
+  second.remove();
+  staticCard.remove();
+  reloaded.remove();
+  return {
+    initialEverywhereOn,
+    clickEverywhereOff,
+    secondClickEverywhereOn,
+    touchSingleToggle,
+    reloadFirstStateOff,
+    oneServerTogglePerGesture: toggleCalls === 3,
+    noHaServiceCalls: serviceCalls.length === 0,
+  };
+});
+
+checkAll(result);
+await finish(browser, result);

demo/smoke_visual_continuity.mjs

@@ -42,6 +42,11 @@ const result = await page.evaluate(async (visualFixture) => {
   card._serverCfg = visualFixture.config;
   card._layout = visualFixture.layout;
   card._space = 'golden-lighting';
+  // This fixture starts after a same-route space choice. #131 deliberately
+  // refuses to treat the class initializer/current id as cold-start intent;
+  // mark this injected selection as already adopted navigation so the reload
+  // exercises continuity instead of cold-start precedence.
+  card._navApplied = true;
   card._regSignature = '';
   card.hass = {
     ...card.hass,

docs/ARCHITECTURE.md

@@ -245,7 +245,13 @@ HA binding against automatic discovery while intentionally exposing that same
 binding to the Add picker. A device tombstone excludes all data of that device;
 an entity tombstone excludes the standalone entity binding but does not mutate
 the same entity out of a still-live parent device. Runtime-filtered references
-such as `controls` remain persisted and become active again after re-add.
+such as `controls` and live text remain persisted and become active again after
+re-add. Exact `opening.contact` / `opening.lock` fields are a separate
+architectural-object role: their HA availability ignores marker tombstones but
+still uses `resolveHaBindingStatus()` to reject disabled, orphaned or unverified
+entities. Their painted state comes from the immutable active-registry frame,
+not directly from live `hass`. Re-adding a marker therefore cannot duplicate or
+rewrite an opening reference.
 Re-adding replaces the tombstone; virtual markers need no tombstone because
 they have no discovery source.
 
@@ -320,6 +326,45 @@ its types declare named exports — breaking either tsc or the runtime): merge a
 when the union collapses into one hole-free outline; split cuts wall-to-wall with a chord, the
 bigger part keeps the room identity (name/area/devices).
 
+`wallBodiesGeometry()` is the canonical physical masonry for flat full/static
+rendering, hidden isometric projection and Glow/sun occlusion. Its exterior
+shell is derived from the union of room centrelines plus the surviving `outer`
+atomic intervals; internal/shared interval bodies are clipped to that union
+before the shell is restored. Consequently a Split edge ending at an exterior
+vertex cannot contribute a child-room mitre to the facade. Per-room rings remain
+an interior join/nested-room representation, and atomic quads provide a safe
+physical interval when an acute child ring cannot be subtracted. Paper and
+masonry paths are emitted by that same geometry pass. The full card retains the
+pair in `_wallUnionCache`; static cards retain it in a weak server-snapshot
+cache guarded by a structural geometry fingerprint. This is computed render
+state only: it never rewrites rooms or wall entries, and an HA state tick does
+not rebuild topology.
+
+### Hidden Isometric Stage 2 composition (#122)
+
+The hidden `iso` View reuses that masonry but has one bounded structural scene,
+not a second house model. `_isoGeometryCache` remains an eight-entry LRU keyed
+by room/wall/opening geometry (including opening flips), scale/camera, fixed
+wall/floor-edge heights and an algorithm revision. Each value holds wall faces,
+the room/exterior slab edge, immutable opening jamb bases and the projected
+frame. HA state, theme, hover and filter support are presentation inputs and
+never enter this key.
+
+`floorFootprintGeometry()` derives only the union of room floors and exterior
+masonry; unlike wall volume, it has no independent partition/column input.
+`buildIsoFloorGeometry()` emits visible low faces for outer component rings,
+not internal edges or holes. `src/iso-openings.ts` stores jamb/axis topology and
+applies `openingAmount()` only during live projection, keeping contact updates
+out of the boolean geometry path.
+
+Composition is shared-viewBox SVG: ambient shadow/floor edge → the existing
+affine-projected floor/live scene → contact/leaf shadows → wall material and
+vertical panels → existing screen-facing HTML overlays. A constant set of
+gradients/filters serves every face. Unsupported decoration or forced colours
+remove nuance/shadows without changing projection; only structural failure
+uses the Stage 1 latched Flat fallback. Details and fixed ratios are recorded in
+`docs/adr/122-isometric-stage2-composition.md`.
+
 ## Markup editor (v1.4.0+)
 
 State inside the card: `_markup` (mode), `_tool` (draw/partition/column/merge/split/resize/opening/
@@ -409,10 +454,16 @@ Its default width in the editor is 300 cm. `openingAmount` (pure) maps the conta
 0..1: no sensor → door/gate drawn open / window closed (static-plan convention);
 `unavailable`/`unknown` freeze that default. The lock renders as an HTML padlock badge
 (`.oplock`) in the device layer; a lock is
-**never** toggled from the plan (TOGGLE_FORBIDDEN_DOMAINS rule). View-mode UX: hover outline,
+**never** toggled from the plan (`resolveToggleIntent` returns a secure no-op). View-mode UX: hover outline,
 drag along walls (continuous re-snap, saved on release), click → status card (250 ms timer),
 double click → properties dialog. In markup mode the "Opening" tool handles clicks instead.
 
+Contact and lock are exact HA references owned by the opening, not aliases of
+standalone markers. Their candidate/action path follows HA binding status while
+their render path follows the frozen active-registry projection; neither path
+consults marker tombstones. Plan-level consumers keep the tombstone policy
+described above.
+
 For a wall with thickness, one `OpeningWallIndex` resolves the atomic wall
 interval and adjacent room on each side of the centreline. Opening symbols,
 wall cuts and room-coloured tunnel patches all consume this association; none
@@ -438,7 +489,8 @@ spans are clipped per atomic body.
 | `houseplan/layout/get` | — | `{layout: {device_id: {x,y}}, rev}` |
 | `houseplan/layout/set` | `layout`, `expected_rev?` | `{ok, rev}` / err `conflict`; event `houseplan_layout_updated` |
 | `houseplan/layout/update` | `device_id`, `pos` | `{ok, rev}`; event `houseplan_layout_updated` |
-| `houseplan/config/get` | — | `{config, rev}` |
+| `houseplan/config/get` | — | `{config, rev, virtual_lights:{rev,config_rev,off[]}}` (`virtual_lights` optional for rolling compatibility) |
+| `houseplan/virtual_light/toggle` | `marker_id` | `{marker_id,on,rev}` / err `not_toggleable`; event `houseplan_virtual_light_updated` |
 | `houseplan/trail/get` | — | `{trails: {marker: {current, previous}}}` — vacuum runs, raw robot coords |
 | `houseplan/trail/delete` | `marker_id` | `{ok, removed}` — erase current/previous runs after marker deletion |
 | `houseplan/config/set` | `config`, `expected_rev?` | `{ok, rev}` / err `conflict`; event `houseplan_config_updated` |
@@ -459,6 +511,23 @@ spans are clipped per atomic body.
 Manual attachments upload over HTTP (streaming, transactional staging), not WS —
 the old `houseplan/file/set` was removed in v1.10.0.
 
+Manual virtual-light state is operational data, not plan configuration. The
+integration owns a separate versioned `houseplan.virtual_lights` Store whose
+bounded payload contains only `{rev, config_rev, off[]}`. The existing shared
+write lock serializes config reconciliation and atomic toggles. Eligibility is
+always recalculated from server config; the toggle command accepts no desired
+state, entity id or service. It is intentionally available to every
+authenticated View user, while config writers remain governed by `may_write`.
+The durable save precedes both reply and event. A config-revision gap from an
+older writer clears manual off bits to the compatibility default `on`.
+
+The first `config/get` frame carries the coherent operational snapshot. Full
+cards subscribe directly to the update event; all `houseplan-space-card`
+instances share the module-level config cache and one subscription. Local
+storage may retain the last snapshot for continuity, but never authorizes an
+optimistic toggle. The data is excluded from marker/layout schemas, portable
+export/import and the HA entity registry.
+
 Portable import preview uses authenticated
 `POST /api/houseplan/import/preview`. The endpoint streams at most 8 MiB,
 strictly rejects duplicate/prototype keys, non-finite numbers and future model
@@ -583,6 +652,9 @@ order — the write lock orders the requests but says nothing about whether the
 file survived. `config/set` therefore checks every `/api/houseplan/content/plans/`
 url against the disk before saving, and refuses with `missing_plan`. External and
 legacy urls are the user's own and are never second-guessed.
+Portable import repeats the same check under its paired-write lock for both
+plans and local marker PDF attachments, so content that disappears after the
+preview cannot leave a newly broken reference in the restored config.
 
 **Signed content urls are batched, aged and deduplicated** (reviews R2-2, R3-2, R4-2). `ContentSigner`
 in `src/signing.ts` is the single implementation, used by both cards; the
@@ -622,6 +694,24 @@ localized opaque recovery overlay, after a 150 ms delay. The overlay never
 steals initial focus; while visible it alone is interactive and the scene is
 `inert`.
 
+**The initial snapshot does not depend on live-sync subscriptions** (#131).
+`houseplan-card` first accepts config and layout, builds the model, chooses one
+exact space, caches the accepted snapshot and restores its viewport. Only then
+is the mandatory load complete. Config, trail and layout event subscriptions
+start together as independent best-effort enrichments: one rejected channel
+does not prevent the others from subscribing, does not erase the usable
+snapshot and does not schedule a full-load retry solely for that rejection.
+Missing channels get another attempt on the next normal load or reconnect.
+
+`src/initial-load.ts` is the shared authority for the exact space used by a
+cached snapshot, a live snapshot and its protected-backdrop candidate. A cold
+load considers only valid ids in this order: URL hash, saved navigation,
+`default_floor`, first live space. Once an initial URL hash has been consumed,
+a valid same-route current selection is preserved instead of repeatedly
+snapping back to that hash. The legacy field initializer is never a cold-start
+choice by itself. A plan with no spaces keeps `null` authority and does not
+invent an id.
+
 **Room climate is one pass per hass snapshot** (review R2-3). `areaClimateMap()`
 classifies the whole registry once and returns `Map<area, {temp, hum}>`; the
 card memoizes it on `hass` identity, which Home Assistant replaces on every

docs/CHANGELOG.md

@@ -2,6 +2,142 @@
 
 ## Unreleased
 
+## v1.64.0-beta.1 — 2026-08-14
+
+- Read-only View and kiosk cards now paint a complete first frame even when
+  Home Assistant refuses live-sync event subscriptions. The selected space,
+  room fills, decor, walls, Glow and device values no longer require clicking
+  the already active space tab ([#131](https://github.com/Matysh/houseplan-card/issues/131)).
+- Virtual markers configured as **Light source → Always** with **Toggle state**
+  can now be switched directly without an HA helper. Their shared state
+  survives reloads/restarts and stays consistent across Glow, room light
+  presentation, full cards and static space cards, including markers that retain
+  saved outgoing controls
+  ([#107](https://github.com/Matysh/houseplan-card/issues/107)).
+- Small fixes and improvements.
+
+## v1.63.0 — 2026-08-13
+
+- Preserved explicit door, window and gate bindings when their standalone
+  sensor or lock marker is removed, and fixed the supported empty state after
+  deleting the last space
+  ([#104](https://github.com/Matysh/houseplan-card/issues/104),
+  [#111](https://github.com/Matysh/houseplan-card/issues/111)).
+- Splitting a room from an existing corner no longer deforms the exterior
+  facade, including with thick dividers. Flat, static and hidden isometric
+  rendering use the same preserved wall geometry
+  ([#123](https://github.com/Matysh/houseplan-card/issues/123)).
+- Small fixes and improvements.
+
+## v1.63.0-beta.2 — 2026-08-13
+
+- Splitting a room from an existing corner no longer deforms the exterior wall
+  or pulls a thick internal divider through the facade. Plan, View, kiosk,
+  static cards, hidden isometric rendering and light obstacles now use the same
+  preserved exterior geometry, including already saved plans
+  ([#123](https://github.com/Matysh/houseplan-card/issues/123)).
+- Small fixes and improvements.
+
+## v1.63.0-beta.1 — 2026-08-13
+
+- Deleting a standalone sensor or lock marker no longer breaks its explicit
+  door, window or gate binding: the entity stays available in opening settings
+  and continues to drive its state without restoring the marker on the plan
+  ([#104](https://github.com/Matysh/houseplan-card/issues/104)).
+- Fixed a crash after deleting the last space: the supported empty state now
+  stays usable so a new space can be added ([#111](https://github.com/Matysh/houseplan-card/issues/111)).
+- Small fixes and improvements.
+
+## v1.62.0 — 2026-08-13
+
+- Added portable full-plan and single-space backups with server-validated
+  preview, safe import and one-step undo, plus reusable contextual help for
+  complex settings ([#50](https://github.com/Matysh/houseplan-card/issues/50),
+  [#68](https://github.com/Matysh/houseplan-card/issues/68)).
+- Added passive light markers, explicit leading-entity selection and
+  user-controlled value badges, while unifying device actions and activity
+  presentation across the plan, preview and static cards
+  ([#84](https://github.com/Matysh/houseplan-card/issues/84),
+  [#88](https://github.com/Matysh/houseplan-card/issues/88),
+  [#90](https://github.com/Matysh/houseplan-card/issues/90),
+  [#94](https://github.com/Matysh/houseplan-card/issues/94),
+  [#98](https://github.com/Matysh/houseplan-card/issues/98)).
+- Reworked opening placement with a Window / Door / Gate submenu and a
+  full-symbol preview on thick walls. Fixed room Split wall thickness, opening
+  tunnel seams and Glow sources embedded in walls or exterior openings
+  ([#75](https://github.com/Matysh/houseplan-card/issues/75),
+  [#76](https://github.com/Matysh/houseplan-card/issues/76),
+  [#81](https://github.com/Matysh/houseplan-card/issues/81),
+  [#91](https://github.com/Matysh/houseplan-card/issues/91),
+  [#92](https://github.com/Matysh/houseplan-card/issues/92)).
+- Added coherent transitions between View and editors, restored reliable
+  window sun rays, and hardened editor lifecycle, composite-device selection,
+  previews and regression coverage
+  ([#93](https://github.com/Matysh/houseplan-card/issues/93),
+  [#95](https://github.com/Matysh/houseplan-card/issues/95),
+  [#101](https://github.com/Matysh/houseplan-card/issues/101),
+  [#102](https://github.com/Matysh/houseplan-card/issues/102)).
+- Small fixes and improvements.
+
+## v1.62.0-rc.1 — 2026-08-13
+
+- Republished the reviewed beta.10 candidate under an RC identifier so HACS
+  discovers it after beta.9; the application code and user-visible behaviour
+  are unchanged.
+
+## v1.62.0-beta.10 — 2026-08-13
+
+- Fixed composite device presentation and actions after the beta review:
+  an explicitly selected light entity now remains the tap target, a primary
+  cover keeps the cover face, and registry-backed state selection is identical
+  in the full plan, preview and static card. Strengthened Split, Glow,
+  contextual-help and opening-preview regression coverage.
+- A light source placed inside a physical wall, window tunnel or exterior
+  door/gate opening intentionally produces no Glow; move its marker onto the
+  room floor to restore illumination ([#92](https://github.com/Matysh/houseplan-card/issues/92)).
+- Small fixes and improvements
+  ([#108](https://github.com/Matysh/houseplan-card/issues/108)).
+
+## v1.62.0-beta.9 — 2026-08-12
+
+- Fixed post-review inconsistencies between device state and tap behaviour:
+  exact bindings no longer toggle a sibling entity, a passive relay controls
+  its leading entity, and incidental cover or humidity entities no longer
+  take over a composite device's presentation.
+- Hardened opening placement with shared defaults, a stable geometry cache,
+  correct centre snapping and a stricter visual preview gate. Restored the
+  public activity and preview-dot CSS hooks, improved help accessibility and
+  strengthened internal process checks.
+- Small fixes and improvements
+  ([#108](https://github.com/Matysh/houseplan-card/issues/108)).
+
+## v1.62.0-beta.8 — 2026-08-12
+
+- Reworked opening placement in the Plan editor. **Opening** now opens a compact
+  Window / Door / Gate sub-menu; choosing a type arms its 120 / 90 / 300 cm
+  preset and shows the complete future architectural symbol at 50% opacity on
+  top of physical walls. Thick-wall targeting, junction selection, click
+  without prior hover and repeated placement are now deterministic, while the
+  persisted opening model remains unchanged
+  ([#75](https://github.com/Matysh/houseplan-card/issues/75),
+  [#76](https://github.com/Matysh/houseplan-card/issues/76)).
+- Hardened the beta after the full review: editor close/navigation can no
+  longer be swallowed by an active transition or context tray; device taps,
+  passive light state and value badges now use the same resolved sources on
+  every surface; legacy temperature/humidity satellites are preserved; help,
+  paired import/export and split-wall geometry gained the missing guards and
+  regression coverage. Small fixes and internal improvements
+  ([#50](https://github.com/Matysh/houseplan-card/issues/50),
+  [#68](https://github.com/Matysh/houseplan-card/issues/68),
+  [#84](https://github.com/Matysh/houseplan-card/issues/84),
+  [#90](https://github.com/Matysh/houseplan-card/issues/90),
+  [#91](https://github.com/Matysh/houseplan-card/issues/91),
+  [#92](https://github.com/Matysh/houseplan-card/issues/92),
+  [#94](https://github.com/Matysh/houseplan-card/issues/94),
+  [#95](https://github.com/Matysh/houseplan-card/issues/95),
+  [#98](https://github.com/Matysh/houseplan-card/issues/98),
+  [#101](https://github.com/Matysh/houseplan-card/issues/101)).
+
 ## v1.62.0-beta.7 — 2026-08-12
 
 - Fixed the first opening of device settings: **Display**, **Room** and

docs/CHANGELOG.ru.md

@@ -8,6 +8,149 @@
 
 ## Unreleased
 
+## v1.64.0-beta.1 — 2026-08-14
+
+- Read-only карточки в режимах View и киоска теперь сразу показывают полный
+  первый кадр, даже если Home Assistant запрещает подписки на события live-sync.
+  Выбранное пространство, заливки комнат, декор, стены, Glow и значения
+  устройств больше не требуют нажатия на уже активную вкладку пространства
+  ([#131](https://github.com/Matysh/houseplan-card/issues/131)).
+- Виртуальные маркеры с сочетанием **Источник света → Всегда** и
+  **Переключить состояние** теперь можно включать и выключать без helper/entity
+  Home Assistant. Общее состояние переживает перезагрузку страницы и HA и
+  одинаково отображается в Glow, свете комнаты, полной и статической карточках,
+  в том числе при сохранённых исходящих связях управления
+  ([#107](https://github.com/Matysh/houseplan-card/issues/107)).
+- Мелкие исправления и улучшения.
+
+## v1.63.0 — 2026-08-13
+
+- Сохранены явные привязки дверей, окон и ворот после удаления отдельного
+  маркера датчика или замка; исправлено предусмотренное пустое состояние после
+  удаления последнего пространства
+  ([#104](https://github.com/Matysh/houseplan-card/issues/104),
+  [#111](https://github.com/Matysh/houseplan-card/issues/111)).
+- Split из существующего угла комнаты больше не деформирует наружный фасад,
+  в том числе с толстым разделителем. Плоский, статичный и скрытый
+  изометрический рендер используют одну сохранённую геометрию стен
+  ([#123](https://github.com/Matysh/houseplan-card/issues/123)).
+- Мелкие исправления и улучшения.
+
+## v1.63.0-beta.2 — 2026-08-13
+
+- Split из существующего угла комнаты больше не деформирует наружную стену и
+  не вытягивает толстый внутренний разделитель сквозь фасад. Редактор плана,
+  View, киоск, статичная карточка, скрытая изометрия и световые препятствия
+  используют одну сохранённую наружную геометрию, в том числе для уже
+  сохранённых планов ([#123](https://github.com/Matysh/houseplan-card/issues/123)).
+- Мелкие исправления и улучшения.
+
+## v1.63.0-beta.1 — 2026-08-13
+
+- Удаление самостоятельного маркера датчика или замка больше не разрывает его
+  явную привязку к двери, окну или воротам: сущность остаётся доступной в
+  настройках проёма и продолжает показывать состояние, не возвращая маркер на
+  план ([#104](https://github.com/Matysh/houseplan-card/issues/104)).
+- Исправлено падение после удаления последнего пространства: предусмотренное
+  пустое состояние остаётся рабочим, и из него можно добавить новое пространство
+  ([#111](https://github.com/Matysh/houseplan-card/issues/111)).
+- Мелкие исправления и улучшения.
+
+## v1.62.0 — 2026-08-13
+
+- Добавлены переносимые резервные копии всего плана и отдельных пространств с
+  серверной проверкой, безопасным импортом и одношаговой отменой, а также
+  переиспользуемые контекстные подсказки для сложных настроек
+  ([#50](https://github.com/Matysh/houseplan-card/issues/50),
+  [#68](https://github.com/Matysh/houseplan-card/issues/68)).
+- Добавлены пассивные маркеры света, явный выбор ведущей сущности и управляемые
+  пользователем бейджи значений. Действия и отображение активности устройств
+  унифицированы для плана, предпросмотра и статичных карточек
+  ([#84](https://github.com/Matysh/houseplan-card/issues/84),
+  [#88](https://github.com/Matysh/houseplan-card/issues/88),
+  [#90](https://github.com/Matysh/houseplan-card/issues/90),
+  [#94](https://github.com/Matysh/houseplan-card/issues/94),
+  [#98](https://github.com/Matysh/houseplan-card/issues/98)).
+- Переработано размещение проёмов: подменю «Окно / Дверь / Ворота» и полный
+  предпросмотр символа на толстых стенах. Исправлены толщина примыкающих стен
+  при разделении комнат, швы тоннелей проёмов и Glow для источников внутри стен
+  и внешних проёмов
+  ([#75](https://github.com/Matysh/houseplan-card/issues/75),
+  [#76](https://github.com/Matysh/houseplan-card/issues/76),
+  [#81](https://github.com/Matysh/houseplan-card/issues/81),
+  [#91](https://github.com/Matysh/houseplan-card/issues/91),
+  [#92](https://github.com/Matysh/houseplan-card/issues/92)).
+- Добавлены согласованные переходы между просмотром и редакторами, восстановлены
+  надёжные солнечные лучи из окон, усилены жизненный цикл редакторов, выбор
+  состояния составных устройств, предпросмотры и регрессионные проверки
+  ([#93](https://github.com/Matysh/houseplan-card/issues/93),
+  [#95](https://github.com/Matysh/houseplan-card/issues/95),
+  [#101](https://github.com/Matysh/houseplan-card/issues/101),
+  [#102](https://github.com/Matysh/houseplan-card/issues/102)).
+- Мелкие исправления и улучшения.
+
+## v1.62.0-rc.1 — 2026-08-13
+
+- Проверенный кандидат beta.10 переопубликован с RC-идентификатором, чтобы HACS
+  корректно видел его после beta.9; код приложения и поведение для пользователя не изменились.
+
+## v1.62.0-beta.10 — 2026-08-13
+
+- По результатам ревью беты исправлены отображение и действия составных
+  устройств: явно выбранный источник света теперь остаётся целью нажатия,
+  основная сущность шторы сохраняет отображение шторы, а выбор состояния по
+  реестру одинаков в полном плане, предпросмотре и статичной карточке. Усилены
+  регрессии для разделения комнат, Glow, контекстных подсказок и предпросмотра
+  проёмов.
+- Источник света внутри тела физической стены, тоннеля окна или внешнего
+  дверного проёма/ворот намеренно не создаёт Glow; для появления света маркер
+  нужно переместить на чистую площадь комнаты
+  ([#92](https://github.com/Matysh/houseplan-card/issues/92)).
+- Мелкие исправления и улучшения
+  ([#108](https://github.com/Matysh/houseplan-card/issues/108)).
+
+## v1.62.0-beta.9 — 2026-08-12
+
+- По результатам повторного код-ревью устранены расхождения между состоянием
+  устройства и действием по нажатию: точная привязка больше не переключает
+  соседнюю сущность, пассивное реле управляет своей ведущей сущностью, а
+  вспомогательные cover- и humidity-сущности не перехватывают отображение
+  составного устройства.
+- Усилено размещение проёмов: единые размеры по умолчанию, устойчивый кеш
+  геометрии, корректная центральная привязка и более строгая визуальная
+  проверка предпросмотра. Восстановлены публичные CSS-хуки активности и точки
+  предпросмотра; улучшены доступность подсказок и внутренние проверки процесса.
+- Мелкие исправления и улучшения
+  ([#108](https://github.com/Matysh/houseplan-card/issues/108)).
+
+## v1.62.0-beta.8 — 2026-08-12
+
+- Переработано размещение проёмов в Редакторе плана. Кнопка **«Проём»** теперь
+  открывает компактное подменю **«Окно / Дверь / Ворота»**; выбор типа включает
+  размер 120 / 90 / 300 см и показывает поверх физической стены полный будущий
+  символ с прозрачностью 50%. Наведение на толстые стены, выбор стены в сложном
+  стыке, клик без предварительного наведения и серийное размещение теперь
+  детерминированы, при этом сохранённая модель проёмов не менялась
+  ([#75](https://github.com/Matysh/houseplan-card/issues/75),
+  [#76](https://github.com/Matysh/houseplan-card/issues/76)).
+- Бета усилена по результатам полного код-ревью: закрытие редактора и навигация
+  больше не теряются во время перехода или при открытой контекстной панели;
+  нажатия, состояние пассивных источников и бейджи значения используют одни и
+  те же вычисленные источники на всех поверхностях; сохранён legacy-показ
+  температуры и влажности; добавлены недостающие защиты и регрессии для
+  подсказок, согласованного импорта/экспорта и геометрии разделённых стен.
+  Мелкие исправления и внутренние улучшения
+  ([#50](https://github.com/Matysh/houseplan-card/issues/50),
+  [#68](https://github.com/Matysh/houseplan-card/issues/68),
+  [#84](https://github.com/Matysh/houseplan-card/issues/84),
+  [#90](https://github.com/Matysh/houseplan-card/issues/90),
+  [#91](https://github.com/Matysh/houseplan-card/issues/91),
+  [#92](https://github.com/Matysh/houseplan-card/issues/92),
+  [#94](https://github.com/Matysh/houseplan-card/issues/94),
+  [#95](https://github.com/Matysh/houseplan-card/issues/95),
+  [#98](https://github.com/Matysh/houseplan-card/issues/98),
+  [#101](https://github.com/Matysh/houseplan-card/issues/101)).
+
 ## v1.62.0-beta.7 — 2026-08-12
 
 - Исправлено первое открытие настроек устройства: поля «Отображение»,

docs/CONFIG-COMPATIBILITY.md

@@ -48,6 +48,24 @@ Unknown future fields remain outside this report and continue to follow the
 backend's forward-compatibility policy. Absence from the report is therefore
 not permission to delete a field.
 
+## Legacy device tap action
+
+The historical marker token `tap_action: cover` remains accepted indefinitely.
+It is projected in the current UI as the universal **Toggle state** action and
+keeps cover-first target priority at runtime. Merely opening and saving an
+unrelated marker field preserves the literal `cover` token; once the user edits
+the action selector, the current canonical `toggle` token is written. The UI
+never creates new `cover` values. Unknown or unavailable cover capabilities
+remain a safe no-op and are never replaced by a guessed service call.
+
+The universal `toggle` resolver uses the current HA registry as its capability
+boundary. A disabled, orphaned or not-yet-verified device target is therefore
+a visible/explained safe no-op; it is not silently retargeted to a sibling
+entity and does not fall back to opening the info card. Entity bindings that
+still have a live, enabled service target may continue to work while registry
+metadata is refreshing. Persisted actions are preserved in both cases so a
+temporarily unavailable binding recovers without a config rewrite.
+
 ## Independent Glow compatibility
 
 The historical space and room token `fill_mode: glow` remains accepted on read
@@ -124,3 +142,29 @@ while an untouched old broken source remains readable and round-trippable.
 space transfer remaps an internal target and disables/counts a link whose
 target is outside the transfer. Older clients ignore the field and may erase
 it if they reconstruct the same marker after a downgrade.
+
+## Persistent manual virtual-light state
+
+The exact `virtual` + `is_light:true` + `tap_action:toggle` combination has a
+shared operational on/off state. It is not a Marker/ServerConfig field: the
+integration stores `{rev, config_rev, off[]}` under a separate versioned Store
+key and exposes an optional `virtual_lights` snapshot in `houseplan/config/get`.
+It is excluded from layout, full/space export, import and HA entities. Missing
+Store data or a missing wire field projects to `on`.
+
+Compatibility matrix:
+
+| Frontend | Backend | Behaviour |
+|---|---|---|
+| old | new | Extra snapshot/event are ignored; the marker keeps historical #84/#94 behaviour and config remains intact |
+| new | old | Missing snapshot starts `on`; an unsupported toggle command reports an error and creates no optimistic local state |
+| new | new | Server snapshot is authoritative; revisioned events synchronize full and static cards |
+
+Every current config writer reconciles the Store. Rename, move, hide and
+unrelated edits preserve off bits for still-eligible stable marker ids;
+binding/role/action changes, tombstones and deletion prune them. Re-entering the
+triple therefore starts on. If `config_rev` skips the revision recorded by the
+operational Store — for example after downgrade, an old writer or an interrupted
+pair — all off bits are cleared rather than resurrected against unknown marker
+lifecycle history. Older integrations safely ignore the separate Store on
+downgrade.

docs/DEVELOPMENT.md

@@ -105,6 +105,23 @@ git config core.untrackedCache true
 
 ## Maintenance diagnostics
 
+### Labs presentation flags
+
+Labs is an internal, presentation-only runtime in `src/labs.ts`; it must never
+gate config/schema migrations, persistence writes, HA services or network
+requests. Enable the current experiment with `?hp-labs=iso` (or
+`#hp-labs=iso&space=<id>`), remove it with `-iso`, and clear all flags with
+`hp-labs=off`. Known URL operations persist to
+`houseplan_card_labs_v1` without rewriting the URL. Active flags are exposed for
+diagnostics as the frozen sorted `window.__hpLabs` array.
+
+To add a flag, add one unique lowercase id plus issue, `since`, `expires` and a
+non-empty summary to `LABS_FLAGS`, then cover URL/storage ordering, runtime
+subscription and expiry. Versions compare the numeric `major.minor.patch` core:
+at `expires` (including its first beta) the flag is dead and every activation
+path fails closed. Remove or graduate a flag before its expiry cycle; do not
+extend an expiry silently. See `docs/ISOMETRIC.md` for the current Stage 1 use.
+
 These commands are read-only diagnostics, not release gates:
 
 ```bash
@@ -115,6 +132,9 @@ npm run audit:config -- path/to/houseplan-config.json
 # Reproducible synthetic large-house report (seven measured samples + warm-up).
 npm run benchmark:large-house -- --samples=7 --warmups=1 --output=artifacts/performance/local.json
 
+# Hidden isometric profile; diagnostic only outside exact-SHA Linux CI.
+npm run benchmark:large-house-isometric -- --samples=7 --warmups=1 --output=artifacts/performance/isometric-local.json
+
 # Golden candidates never overwrite reviewed references.
 npm run golden:capture
 npm run golden:verify

docs/FILTERING.md

@@ -104,10 +104,15 @@ the old behaviour until an editing client materialises it.
   standalone plan object; it does not remove the same entity from the data of
   a still-live parent HA device. Tombstones are binding-scoped, not mutations
   of the HA registry.
-- References in openings, live text and another marker's persisted `controls`
-  are retained but become inactive (no lock/contact badge, `—`, or control
-  action respectively). Adding the binding again restores them without
-  reconstructing configuration or performing an unrelated Save first.
+- Exact `opening.contact` and `opening.lock` references are independent of a
+  standalone plan marker: deleting that marker does not remove the entity from
+  the opening picker and does not stop the saved opening from following its HA
+  state. The tombstone still suppresses every marker-level contribution and is
+  not removed or rewritten by choosing the entity in an opening.
+- References in live text and another marker's persisted `controls` are
+  retained but become inactive (`—` or no control action respectively).
+  Adding the binding again restores those references without reconstructing
+  configuration or performing an unrelated Save first.
 - The same inactive rule applies while a saved binding is HA-disabled. The
   marker, room metrics, Glow/light fill, registry-wide climate, live text,
   openings, controls, vacuum puck and trails all ignore it. Reactivation of the

docs/ISOMETRIC.md

@@ -0,0 +1,168 @@
+# Hidden Isometric View internals
+
+Issue [#89](https://github.com/Matysh/houseplan-card/issues/89) implements a
+hidden, presentation-only volumetric View experiment. The normative contract is
+`docs/specs/089-isometric-view-stage1.md`; the fixed rendering decisions are in
+`docs/adr/089-isometric-stage1-renderer.md`.
+
+## Activation and lifetime
+
+The feature exists only while the `iso` entry in `src/labs.ts` is live. For the
+v1.62 cycle it can be enabled with either `?hp-labs=iso` or
+`#hp-labs=iso&space=<id>`. Query operations are applied first and hash operations
+second. `-iso` removes this flag and `off` clears every Labs flag. A known URL
+operation is persisted in `houseplan_card_labs_v1`; the URL itself is not
+rewritten.
+
+The selected presentation is stored per space in `houseplan_card_view_v1`. Flat
+is always the initial default. Kiosk has no toggle but reads the saved preference.
+Editors and `houseplan-space-card` are always flat.
+
+The current registry entry is live from numeric core `1.62.0` and expires at
+`1.65.0`. Thus `1.65.0-beta.1` is already expired. Malformed versions, malformed
+entries and duplicate ids fail closed. Labs never gate schemas, migrations,
+stores, service calls or network requests.
+
+## Coordinate systems
+
+- Plan points are the existing 1000-unit logical floor coordinates.
+- Scene points are coordinates in the effective SVG viewBox.
+- HTML devices, vacuum pucks, room labels/cards and lock markers stay
+  screen-facing. Their anchors use the same `projectPlanPoint()` snapshot as the
+  SVG floor.
+- `clientToScenePoint()` maps a client point to the current scene; floor hit
+  testing then uses `unprojectFloorPoint()`.
+
+Stage 1 uses a fixed orthographic affine camera:
+
+```text
+rotDeg=0, tiltDeg=20, xyScale=1, zScale=1, origin=[500,500]
+wallHeight=64 plan units
+```
+
+There is no perspective, free rotation or user tilt. Switching projections
+preserves scalar zoom and converts the view centre through logical floor space.
+`projectedFrame()` includes both floor corners and wall-top corners so fit/home
+cannot clip the volume.
+
+## Geometry and composition
+
+`src/iso-projection.ts` owns pure projection math. `src/iso-walls.ts` consumes
+the canonical `wallBodiesGeometry()` MultiPolygon after openings and extra
+physical bodies have been resolved. It normalizes outer/hole winding, builds one
+evenodd top path and at most one visible side per ring edge, then uses a stable
+depth/order tie-break. Complexity is O(E) in canonical ring edges.
+
+The content fingerprint includes rooms, wall geometry/thickness, open cuts,
+openings, partitions, drafts, columns, scale/grid inputs, camera, wall height and
+algorithm version. It deliberately excludes `_cfgEpoch`, HA state, hover and
+`show_borders`. The per-card LRU is capped at eight scenes. Pan, zoom and HA-only
+updates reuse it.
+
+Composition remains SVG-first:
+
+1. the existing floor SVG and all its current live layers;
+2. explicit visible wall sides and wall top;
+3. screen-facing HTML overlays.
+
+The floor keeps the same nodes and order for paper/backdrop, room fills/hover,
+Glow/spill, sun, decor/furniture, opening symbols and vacuum path/outline. Stage
+1 does not add a second light source/layer. Markers and room cards intentionally
+remain above walls without geometric occlusion.
+
+## Failure boundary
+
+Projection/topology failures latch flat fallback for the current
+`space|fingerprint`. One diagnostic is emitted without config, entity ids or URL
+data. The saved iso preference is retained; an explicit iso request retries the
+fingerprint, and changed geometry receives a new fingerprint. Flat rendering is
+the rollback path and does not depend on the iso cache.
+
+## Deliberate Stage 1 limits
+
+- door, window and gate keep their current floor-plane symbol and live state;
+- no vertical leaf/window panels, sill model or new window light;
+- no floor-edge extrusion, shadows, photorealistic materials or marker
+  occlusion;
+- no volumetric editor and no volumetric `houseplan-space-card`;
+- no YAML/config option or public settings surface.
+
+Golden references are accepted only from the complete reviewed Linux artifact.
+The full `large-house-isometric-v1` performance comparison is also canonical on
+the exact Linux CI SHA.
+
+## Stage 2 composition (#122)
+
+Stage 2 evolves the same hidden `iso` experiment; it does not add a flag,
+setting or public activation path. The accepted implementation contract is
+`docs/specs/122-isometric-stage2.md` and the fixed composition decisions are in
+`docs/adr/122-isometric-stage2-composition.md`. The Labs `since: 1.62.0` and
+exclusive `expires: 1.65.0` boundary are unchanged.
+
+### One structural scene, live opening leaves
+
+The per-card LRU remains capped at eight entries. Its Stage 2 value contains:
+
+- canonical wall top/sides and the physical-wall contact path;
+- a room/exterior floor footprint and its low visible outer faces;
+- immutable opening jamb/axis bases, including type, flips and selected wall
+  face;
+- the shared projected frame, including wall/opening tops and the low floor
+  edge.
+
+The key includes rooms, masonry/opening geometry, flips, scale/camera, wall and
+edge heights and algorithm revision. It excludes HA state, theme, hover,
+day/night and filter capability. `openingAmount()` is applied only after an LRU
+hit by `projectIsoOpening()`, so a contact update projects O(O) leaves without
+repeating a wall or floor boolean operation.
+
+`floorFootprintGeometry()` deliberately accepts no independent physical-body
+input. The slab is the union of room floors and derived exterior masonry:
+internal room boundaries and nested holes make no decorative step, detached
+room components keep separate outside edges, while partitions and columns do
+not enlarge it.
+
+### Layer order and materials
+
+All geometry roots use one scene `viewBox`. The existing floor/live nodes are
+grouped under the Stage 1 affine matrix; HTML anchors still use
+`projectPlanPoint()`.
+
+```text
+stage background
+→ shared ambient shadow + low exterior floor edge
+→ existing floor SVG (paper/image, room fills/hover, decor, Glow, sun)
+→ shared contact and live leaf shadows
+→ canonical wall sides/top + inert vertical opening panels
+→ existing HTML devices, labels/cards, locks and vacuum overlays
+```
+
+Wall top and side use two shared matte gradients. Ambient, contact and leaf
+shadows use three shared filters; definition count is constant per card, never
+per face or opening. Forced colours use solid `Canvas`/`CanvasText` faces and
+omit decoration. A runtime without the required filter paint keeps solid
+structure, floor edge and vertical panels but emits no Stage 2 shadows; this
+does not enter the structural fallback latch.
+
+### Vertical openings and display settings
+
+`src/iso-openings.ts` mirrors the existing opening-symbol transform algebra:
+door has one jamb-hinged leaf, gate has two leaves with the established
+0–10° exterior-face turn, and window has two light neutral casements. Heights
+are fixed presentation ratios of `ISO_WALL_HEIGHT`; there is no schema field.
+Panels/shadows are pointer- and ARIA-inert. Existing lock badges/cards and HA
+actions remain the only interactive opening surface.
+
+- borders visible: vertical panels replace the floor-plane symbols;
+- `hide_openings: true`: panels and leaf shadows disappear, while masonry
+  cuts, Glow/sun and contact/lock meaning remain;
+- `show_borders: false`: Stage 2 roots are absent and the established floor
+  symbols and Stage 1 projected frame return (subject to `hide_openings`),
+  avoiding floating panels or an invisible Stage 2 bound that reframes them;
+- Flat, editors and `houseplan-space-card` retain their old symbols and DOM.
+
+Stage 2 adds no window beam, Glow source, sun renderer, material config,
+network request or HA service path. Structural topology/projection exceptions
+still use the Stage 1 latched Flat fallback. The known independent exact-SHA
+view-toggle performance debt remains tracked in #124; #122 neither weakens its
+budget nor treats fallback as benchmark success.

docs/LIGHT.md

@@ -50,7 +50,9 @@ Source placement follows the same geometry, fail-dark. If the source centre is
 inside an opaque wall body, a window tunnel, or an exterior door/gate opening,
 the source produces no Glow at all. It does not light the indoor half of the
 opening. An interior door/gate passage remains a real hole and is therefore a
-valid source position.
+valid source position. This is an intentional placement rule, not a temporary
+availability state: move the source marker onto the clean room floor to make it
+emit Glow again ([#92](https://github.com/Matysh/houseplan-card/issues/92)).
 
 ## From barriers to a lit region
 
@@ -132,6 +134,18 @@ source even when the marker has no controllable HA entity. That last case is a
 - its position, room, colour, brightness and radius belong to the target lamp,
   not to the switch which drives it.
 
+There is one explicit manual-authority exception. An active marker with a
+`virtual` binding, `is_light: true` (Always) and `tap_action: toggle` reads its
+on/off value from the integration's revisioned operational store. Absence is
+`on`. While the triple remains active, that value overrides incoming controller
+OR for the marker source and therefore reaches every consumer of
+`resolvedLightSources()` — Glow, room fill/counts, device presentation, preview
+and both card types. Saved controls remain lossless but a tap on this exact
+marker performs the operational toggle, never an HA service call. Leaving the
+triple restores the normal controller rules and clears any stored off bit;
+hiding alone does neither. The operational revision is part of the resolver
+cache key, so an event changes the projection without an HA state tick.
+
 The controller picker can therefore link a smart relay to a virtual marker for
 a dumb physical lamp. Multiple controllers use OR. A direct entity reference
 and a marker reference resolving to the same stateful source are deduplicated.
@@ -157,6 +171,11 @@ The complete UI and runtime truth table lives in
   source on an opaque edge is rejected, the ±π seam cannot cut a wedge from
   the fan, and a corner made by two crossing barriers is lit right up to the
   corner.
+- `test/physical-geometry.test.mjs` plus
+  `test/houseplan-runtime-contract.test.mjs` — the source-placement guard:
+  exterior opening masonry, wall bodies, partitions and columns are fail-dark,
+  while a real interior passage remains a valid source position; the rendered
+  Glow path is pinned to that shared guard.
 - `demo/smoke_glow.mjs` — pixels on a rendered plan: the aperture itself is lit,
   the floor behind a door is lit, the visible beam is no wider than twice the
   opening, there is no light behind a column while the floor beside it is lit,

docs/RELEASE-NOTES.md

@@ -1,14 +1,16 @@
-<!-- release: v1.62.0-beta.7 -->
+<!-- release: v1.64.0-beta.1 -->
 
 ## Основное
 
-- Настройки устройства теперь сразу показывают фактически сохранённые варианты отображения, комнаты и источника света.
+- Карточки View и киоска теперь сразу показывают полный первый кадр даже без доступа к подпискам live-sync.
+- Виртуальные светильники «Всегда» с действием «Переключить состояние» теперь работают без helper Home Assistant и синхронизируются между карточками.
 - Мелкие исправления и улучшения.
 
 ## Highlights
 
-- Device settings now immediately show the persisted display, room and light-source choices.
+- View and kiosk cards now paint a complete first frame even without access to live-sync subscriptions.
+- Always-on virtual light sources with Toggle state now work without a Home Assistant helper and stay synchronized across cards.
 - Small fixes and improvements.
 
-[Полный список изменений на русском](https://github.com/Matysh/houseplan-card/blob/v1.62.0-beta.7/docs/CHANGELOG.ru.md)
-· [Full changelog in English](https://github.com/Matysh/houseplan-card/blob/v1.62.0-beta.7/docs/CHANGELOG.md)
+[Полный список изменений на русском](https://github.com/Matysh/houseplan-card/blob/v1.64.0-beta.1/docs/CHANGELOG.ru.md)
+· [Full changelog in English](https://github.com/Matysh/houseplan-card/blob/v1.64.0-beta.1/docs/CHANGELOG.md)