migration: add capability ledger foundation

docs: link shared project map from agent instructions
fix: verify apply duplicate and capture runtime failures
2026-08-05 08:57:24 +03:00 · 2026-08-05 07:14:45 +03:00 · 2026-08-04 16:35:42 +03:00 · 2026-08-04 14:59:51 +03:00 · 2026-08-04 14:49:54 +03:00 · 2026-08-04 14:43:59 +03:00
64 changed files with 4032 additions and 46 deletions
@@ -0,0 +1,163 @@
+# AGENTS.md
+
+## Назначение проекта
+
+Этот репозиторий содержит аудит, архитектуру, исходный код, тесты, runtime
+evidence и документацию миграции корпоративной экосистемы Autodesk AutoCAD
+Plant 3D 2019 на Autodesk AutoCAD Plant 3D 2026.
+
+Конечная цель — функционально эквивалентная рабочая схема Plant 3D 2026:
+корпоративный Launcher, локальная доставка и активация пакетов, managed
+плагины, команды, Ribbon, Plant project integration, DataLinks, Ortho,
+аннотации, обновление, диагностика и rollback. Миграция не считается
+завершённой после успешной компиляции: необходима runtime-проверка реальных
+сценариев в Plant 3D 2026.
+
+## Связанные репозитории
+
+- основной Autodesk-репозиторий: `C:\dev\autodesk`;
+- Launcher Next: `C:\dev\launcher-next`;
+- legacy launcher (read-only): `C:\dev\launcher\git`, `C:\dev\p_serv_starter`;
+- legacy P_Rec_Annot (read-only): `C:\dev\autodesk\link\P_Rec_Annot\v1.0.4\repo`.
+
+Legacy и deployed-файлы нельзя изменять без отдельного прямого задания.
+
+## Целевая платформа и принцип миграции
+
+- Autodesk AutoCAD Plant 3D 2026, series R25.1, Windows x64, .NET 8;
+- использовать реальные Autodesk 2026 managed assemblies;
+- managed package загружается локально, не напрямую с UNC;
+- Autodesk DLL нельзя коммитить, помещать в package/fixture или публиковать.
+
+Переносится функциональное поведение, а не историческая структура файлов. Не
+воспроизводить без отдельного доказательства 20 последовательных `NETLOAD`,
+legacy LISP bootstrap, `OrthoLoader.dll`, загрузку с сети или прежние
+workaround. Предпочтительная цепочка:
+
+`Launcher Next → versioned local package → один managed entry assembly → internal dependencies → commands and Ribbon`.
+
+## Статус legacy-команд
+
+Ни одна активная команда Plant 3D 2019 не исчезает молча. Для каждой команды
+фиксируется ровно один статус: `IMPLEMENTED`, `RUNTIME_VERIFIED`,
+`REPLACED_WITH_NATIVE`, `RETIRED_APPROVED` или `BLOCKED_WITH_REASON`.
+Aliases сохраняются, пока их удаление не утверждено отдельно.
+
+## Runtime уровни
+
+`Smoke` проверяет assembly load, регистрацию команд, Plant context, Ribbon,
+отсутствие необработанных исключений и отсутствие записи в DWG.
+
+`DryRun` проверяет реальные Plant data, Ortho/sheet/view definitions, DataLinks,
+Plant objects, детерминированный план и отсутствие записи в DWG/project DB.
+
+`Apply` разрешается только отдельным явным заданием: write guard, ограниченная
+DWG transaction, тестовая копия проекта, baseline, rollback/UNDO, duplicate
+protection и runtime evidence обязательны. Apply нельзя включать только
+локальной конфигурацией.
+
+## Runtime важнее предположений
+
+Build и unit tests не доказывают Autodesk integration. Для
+`RUNTIME_VERIFIED` необходимы фактические результаты: команда, module path,
+DBMOD, Ribbon, DataLinks, Ortho status, telemetry и состояние файлов после
+закрытия. Не выдумывать UI evidence: использовать `null`, `NOT VERIFIED` или
+`BLOCKED WITH REASON`.
+
+На тестовой машине реальный Plant 3D запуск разрешён, если он входит в задачу
+и есть test branch, локальный fixture, пройденные build/tests, rollback и нет
+production deploy. Не создавать искусственный review-gate перед Process.Start.
+Остановка допустима лишь после завершения доступной части работы и при
+конкретном внешнем blocker: установка, ОС, права, Autodesk runtime, fixture или
+необходимость production-данных.
+
+## Test fixtures и отсутствие записи
+
+Fixtures создаются вне Git, например `<TEST_FIXTURE_ROOT>`. Ortho fixture —
+настоящий Plant project с Pipe, DataLinks row, line group, Ortho drawing,
+Ortho viewport и source-model connection; обычный AutoCAD viewport не годится.
+Production DWG/project использовать нельзя без прямого разрешения.
+
+Нельзя коммитить DWG, DCF, Project.xml с runtime-data, project DB, Ortho
+generated files или реальные engineering values.
+
+Для Smoke/DryRun проверять DBMOD до/после, SHA-256 содержательных project
+files, отсутствие непредусмотренных transactions/DCF/project-metadata writes.
+`LastWriteTime` недостаточен. Отделять служебные Plant cache/session files от
+содержательных данных.
+
+## Ribbon, механика и evidence
+
+Ribbon — часть продукта: проверять tab, panel, button, command binding, stable
+IDs, отсутствие дубликатов при документах/workspace/reinitialization. Команда
+может быть отдельно рабочей, но plugin slice не завершён без Ribbon evidence
+или отдельного UI defect.
+
+Документировать каждую runtime-цепочку: component/project/class/method,
+input/output, Autodesk transaction mode, writes, telemetry, failure code и
+rollback action. Документация соответствует фактическому коду.
+
+Evidence содержит только проверенные значения. Не добавлять username, permit,
+полный environment, real project paths/line numbers/ObjectId/RowId/properties,
+полные logs, local manifest или startup scripts. Путь fixture заменять на
+`<TEST_FIXTURE_ROOT>`.
+
+## Warnings и Git
+
+Известный `MSB3277` WindowsBase 4.0.0.0/8.0.0.0 допустим только при полном
+совпадении с ранее зафиксированным warning. Новые warnings исследовать; не
+подавлять `NoWarn` без причины.
+
+Запрещены force push, amend/rebase опубликованной истории, push binaries,
+изменение неизвестного remote и production deployment из test branch. Перед
+commit выполнять:
+
+```powershell
+git diff --check
+git status --short
+git diff --cached --check
+```
+
+Не смешивать Launcher defect, plugin defect, runtime evidence и unrelated
+formatting в одном commit.
+
+## Definition of Done
+
+Срез завершён, когда реализованы код, build/tests, валидный package и требуемый
+runtime-сценарий; записаны фактические результаты; выполнен rollback; fixture и
+production изолированы; механика документирована; ветка опубликована обычным
+push.
+
+## Общая карта проекта
+
+Каноническая общая карта проекта находится в Google Drive:
+`https://drive.google.com/drive/folders/1avnR0V8q7y5pfWRYwB6LPBEEyfpN7PpV`.
+Локальная синхронизированная копия, если она доступна, определяется только
+переменной среды `PHIM_PLANT3D_PROJECT_MAP_ROOT`; её путь не хардкодить.
+
+Перед работой над архитектурой, миграцией или runtime-сценарием обязательно
+прочитать доступные индекс/обзор карты, целевую архитектуру и migration status,
+индекс runtime evidence, а также записи карты для затрагиваемых Launcher и
+P_Rec_Annot. Затем сверить их с локальными AGENTS.md, релевантными tracked
+документами, текущим кодом и тестами.
+
+Источники истины имеют следующий приоритет: фактическое runtime evidence;
+текущий код, tests и tracked configuration на проверенном Git HEAD; tracked
+документация репозитория; общая карта проекта. Внешняя карта описывает и
+связывает работу, но не является build/runtime dependency и не переопределяет
+текущий код или runtime evidence.
+
+Проверять свежесть каждой используемой записи карты по фактическим `git
+rev-parse HEAD`, ветке и привязанному runtime evidence. Если карта или её
+локальная копия недоступна, фиксировать `PROJECT_MAP_UNAVAILABLE`; если
+зафиксированные commit/runtime status не совпадают с фактическими —
+`PROJECT_MAP_STALE`. Эти статусы не разрешают выдумывать evidence: продолжать
+по доступным локальным источникам и явно сообщать расхождение.
+
+Системные инварианты сохраняются: Launcher доставляет versioned local package
+с одним managed entry assembly и без Autodesk DLL; P_Rec_Annot подтверждает
+реальное Plant/Ortho/DataLinks поведение runtime evidence, а не только build
+или tests. После изменения архитектуры либо runtime-статуса в отчёте указывать
+конкретные документы общей карты, которые требуют обновления (архитектура,
+статус миграции, evidence index и запись затронутой подсистемы); не заявлять,
+что они уже обновлены, без фактического изменения.
@@ -0,0 +1,119 @@
+# AGENTS.md — P_Rec_Annot
+
+## Назначение и package
+
+`P_Rec_Annot` — приоритетный Plant 3D 2026 plugin для чтения, планирования и
+последующего создания Ortho-аннотаций; это перенос активного legacy поведения
+Plant 3D 2019 на .NET 8/Plant 3D 2026.
+
+Единственная assembly для `NETLOAD` — `PRecAnnot.Plant3D2026.dll`.
+`PRecAnnot.*.dll` — internal managed dependencies, их нельзя NETLOAD по одной.
+Использовать Autodesk 2026 references; Autodesk DLL не включать в bundle.
+
+## Commands и context
+
+Поддерживаемые команды: `PHP_REC_ANNOT`, `PXP-AAV`, `PXP-OA`. Все
+регистрируются реальным Autodesk API, работают в Smoke/DryRun, не изменяют DWG
+в этих режимах и создают одно usage event на явный вызов.
+
+Project status: `NotFound`, `FoundWithName`, `FoundWithoutDisplayName`,
+`Ambiguous`, `Failed`. Никогда не выводить `проект '' найден`; для пустого
+display name: `Plant 3D-проект открыт; отображаемое имя не определено.`
+Diagnostic code: `PLANT_PROJECT_DISPLAY_NAME_EMPTY`.
+
+Drawing states: `Ortho`, `NotOrtho`, `Ambiguous`, `Failed`. Обычный DWG не
+классифицируется как Ortho; для реального Ortho применять Autodesk API и
+`OrthoDocUtils.IsValidOrthoDrawing`.
+
+## DryRun и determinism
+
+Pipeline: `Plant context → Ortho detection → sheet/view definitions → viewport
+snapshots → DataLinks → Plant properties → independent DTO → deterministic
+AnnotationPlan → diagnostics → no write`.
+
+Autodesk objects, transactions и database handles остаются в adapter layer;
+Core/Application используют только независимые DTO. На неизменном fixture
+повторный DryRun обязан давать тот же PlanId, counts, порядок операций и warning
+codes, без side effects. PlanId не включает время, GUID, absolute path,
+нестабильный ObjectId или пользовательские данные.
+
+## Write guard, Ribbon, tests
+
+Все writes проходят централизованный write guard; в Smoke/DryRun он всегда
+запрещает изменения. Apply не обходится через command handler/adapter.
+
+Ожидаемый Ribbon путь: `Промхимпроект → Аннотации → Аннотировать`. Требуются
+stable IDs, отсутствие дублей, binding к `PHP_REC_ANNOT`, устойчивость к
+документам/workspace и корректный Terminate.
+
+Unit tests не требуют Autodesk runtime. Runtime evidence отдельно фиксирует
+initialization, commands, context, Ortho, DataLinks, plan, Ribbon, DBMOD,
+telemetry и shutdown.
+
+Bundle содержит только фактический runtime dependency graph и никогда не
+содержит Autodesk DLL, PDB, test assemblies, legacy 2019 assemblies, bin/obj
+или production configuration.
+
+Fixture: local Plant 3D 2026 project вне Git с настоящей Pipe, synthetic line
+number, Ortho drawing/viewport и SHA baseline до DryRun.
+
+## Viewport membership and source DataLinks
+
+Legacy P_Rec_Annot source for read-only analysis is
+`\\phpsrv03\NBIM\code\CS\P_Rec_Annot\v1.0.4\repo`.
+
+A source object is not a member of an Ortho viewport without confirmed
+evidence. A geometry-only filter is at most `PartiallyResolved`. Apply is
+blocked by any `PLUGIN_ONLY_CHANGE` in a DWG, DCF, or project metadata found by
+a paired CONTROL/DryRun comparison.
+
+## Ortho source DataLinks and DCF control
+
+DataLinks активного Ortho drawing не являются источником Piping rows. Piping
+rows читаются из source model drawing и Piping project part, разрешённых через
+Ortho sheet/view definitions.
+
+Перед предположениями об Autodesk runtime API необходимо исследовать текущий
+код, доступный legacy usage, assembly metadata и реальные runtime types.
+Reflection/runtime inspection применяется только для подтверждения данных,
+которых нельзя установить статически. Production resolver не угадывает
+Autodesk properties по строковым именам.
+
+Подтверждённый контракт Plant 3D 2026: `IDwgViewDef.DwgQuery` →
+`IDwgQuery.ModelFiles` → `ModelFile[].ModelFileName`. При несовпадении типа
+возвращать `ORTHO_MODEL_FILES_API_UNSUPPORTED`, без fallback-эвристики.
+
+Проверка DCF выполняется на парных `control` и `DryRun` fixtures, созданных из
+одного закрытого состояния проекта. Сравнивать нужно `control delta` с
+`DryRun delta`: одинаковые изменения классифицируются как baseline behavior
+Plant 3D, а plugin-only изменения блокируют дальнейшую работу.
+
+## Общая карта проекта
+
+Каноническая общая карта проекта:
+`https://drive.google.com/drive/folders/1avnR0V8q7y5pfWRYwB6LPBEEyfpN7PpV`.
+Необязательная локальная копия доступна только через
+`PHIM_PLANT3D_PROJECT_MAP_ROOT`; локальный путь синхронизации не хардкодить.
+
+До изменения P_Rec_Annot читать доступные индекс карты, запись архитектуры и
+статуса P_Rec_Annot, DryRun/Apply contract, карту Ortho/DataLinks и связанный
+runtime evidence index. Сверять их с фактическим Git HEAD, текущими plugin
+code/tests/configuration и runtime evidence конкретной fixture.
+
+Приоритет источников: runtime evidence, затем code/tests/configuration на
+проверенном HEAD, затем tracked repository documentation, затем общая карта.
+Карта не является build/runtime dependency и не заменяет фактический код либо
+runtime evidence. Недоступную карту отмечать `PROJECT_MAP_UNAVAILABLE`;
+несовпадение её commit/runtime status с фактическими данными —
+`PROJECT_MAP_STALE`.
+
+Инварианты P_Rec_Annot: остаётся единственная NETLOAD entry assembly, aliases
+и статусы команд не исчезают молча, Smoke/DryRun не пишут DWG, а Apply требует
+явного разрешения, локальной fixture, ограниченной transaction, evidence и
+проверяемого rollback/UNDO. Не ослаблять подтверждённый Ortho source/DataLinks
+контракт и DCF control comparison ради сведений из карты.
+
+После изменения plugin architecture или runtime-status в отчёте перечислять
+документы карты, требующие обновления: запись P_Rec_Annot, command/status,
+Ortho/DataLinks contract, DryRun/Apply/UNDO evidence и migration status. Не
+утверждать обновление внешней документации без фактического изменения.
@@ -0,0 +1,5 @@
+# Annotation-plan determinism
+
+`AnnotationPlanBuilder` uses schema version `1`. Its canonical input is the normalized command, source drawing basename, view ID, source snapshots sorted by stable ID, properties sorted by key, membership state, and operations sorted by stable source key and type. Absolute paths, process data, timestamps and runtime ObjectIds are excluded.
+
+Runtime DryRun confirmed equal PlanIds and summaries for two calls of each supported command. Changing a relevant normalized input changes the PlanId.
@@ -0,0 +1,26 @@
+# CONTROL versus DryRun DCF comparison
+
+DBMOD covers only the active drawing. This procedure separately compares
+content-bearing project files after identical CONTROL and DryRun sessions.
+
+1. With Plant 3D closed and the Launcher session `RolledBack`, copy the local
+   fixture to `<FROZEN_FIXTURE>`.
+2. Create `<CONTROL_FIXTURE>` and `<DRYRUN_FIXTURE>` from that same frozen
+   state; calculate complete local SHA-256 inventories before each run.
+3. Open model and Ortho drawings in CONTROL through the same Launcher DryRun
+   launch contract, but invoke no P_Rec_Annot command. Close without saving,
+   wait for Launcher rollback, then calculate the after inventory.
+4. Repeat with DRYRUN and invoke each supported command twice. Close without
+   saving, wait for rollback, then calculate the after inventory.
+5. Compare deltas by logical relative path. Classify each content-bearing file
+   as `UNCHANGED`, `AUTODESK_BASELINE_CHANGE`, `PLUGIN_ONLY_CHANGE`, or
+   `INCONCLUSIVE`.
+
+Content-bearing groups include model DWG, Ortho DWG, `Piping.dcf`, remaining
+DCF/database files, `Project.xml` or equivalent project metadata, and Ortho
+metadata. Lock, cache, session, log, preview, and temporary files are reported
+separately and cannot establish project invariance.
+
+Any `PLUGIN_ONLY_CHANGE` blocks Apply. Full paths and hashes remain local;
+repository evidence contains only logical fixture markers, groups, counts, and
+classifications.
@@ -0,0 +1,17 @@
+{
+  "executionMode": "DryRun",
+  "planSchemaVersion": 1,
+  "sourceObjectsRead": 7,
+  "membershipResolved": 0,
+  "membershipPartial": 0,
+  "membershipUnresolved": 7,
+  "phpRecAnnotPlanIds": ["plan-C5D40DC32505D5D9CFE6D38B", "plan-C5D40DC32505D5D9CFE6D38B"],
+  "pxpAavPlanIds": ["plan-E4877CA13418D43A17F47AAA", "plan-E4877CA13418D43A17F47AAA"],
+  "pxpOaPlanIds": ["plan-6C794D25C292E73AA3BDDC31", "plan-6C794D25C292E73AA3BDDC31"],
+  "summariesDeterministic": true,
+  "dbmodBefore": 0,
+  "dbmodAfter": 0,
+  "launcherSession": "RolledBack",
+  "dcfControlComparison": null,
+  "applyModeUsed": false
+}
@@ -0,0 +1,66 @@
+{
+  "schemaVersion": 1,
+  "executionMode": "DryRun",
+  "fixture": {
+    "frozen": "<FROZEN_FIXTURE>",
+    "control": "<CONTROL_FIXTURE>",
+    "dryRun": "<DRYRUN_FIXTURE>",
+    "trackedFileCount": 210
+  },
+  "membership": {
+    "mechanism": "IDwgViewDef.DwgQuery.Execute -> MdObjectId.PrjObjectId -> DataLinksManager.FindAcPpRowId",
+    "orthoViews": 1,
+    "sourceObjects": 7,
+    "resolved": 5,
+    "partiallyResolved": 0,
+    "outsideView": 2,
+    "notResolved": 0,
+    "evidenceCode": "VIEW_MEMBERSHIP_FROM_CONFIRMED_PNP_ID"
+  },
+  "commands": {
+    "PHP_REC_ANNOT": {
+      "planSchemaVersion": 1,
+      "run1PlanId": "plan-AD701C7AA38D99E4C28D7D6D",
+      "run2PlanId": "plan-AD701C7AA38D99E4C28D7D6D",
+      "planDeterministic": true,
+      "summaryDeterministic": true
+    },
+    "PXP-AAV": {
+      "planSchemaVersion": 1,
+      "run1PlanId": "plan-C4FCD62F4EEBA1D1948FA22B",
+      "run2PlanId": "plan-C4FCD62F4EEBA1D1948FA22B",
+      "planDeterministic": true,
+      "summaryDeterministic": true
+    },
+    "PXP-OA": {
+      "planSchemaVersion": 1,
+      "run1PlanId": "plan-C30D133E2D5B4BF4C0AF2ED1",
+      "run2PlanId": "plan-C30D133E2D5B4BF4C0AF2ED1",
+      "planDeterministic": true,
+      "summaryDeterministic": true
+    }
+  },
+  "projectFileComparison": {
+    "controlDeltaCount": 0,
+    "dryRunDeltaCount": 0,
+    "modelDwgPluginOnlyDelta": "UNCHANGED",
+    "orthoDwgPluginOnlyDelta": "UNCHANGED",
+    "pipingDcfPluginOnlyDelta": "UNCHANGED",
+    "projectMetadataPluginOnlyDelta": "UNCHANGED"
+  },
+  "dbmod": {
+    "pairedRun": null,
+    "reason": "Command-window output was not retained."
+  },
+  "launcher": {
+    "controlSession": "RolledBack",
+    "dryRunSession": "RolledBack",
+    "netloadCount": 1,
+    "profileArgumentPresent": false
+  },
+  "apply": {
+    "performed": false,
+    "authorised": false,
+    "reason": "All operations remain Skip; annotation rules are not yet implemented."
+  }
+}
@@ -0,0 +1,28 @@
+{
+  "date": "2026-08-03",
+  "executionMode": "DryRun",
+  "plantProjectDetected": true,
+  "projectDisplayNameStatus": "FoundWithName",
+  "orthoDetection": "Confirmed",
+  "viewportCount": 1,
+  "dataLinksAvailable": true,
+  "dataLinksSheetToSourceMapping": "resolved-through-piping-project-drawing-id",
+  "sourceDrawingsResolved": 1,
+  "sourceDataLinksAvailable": true,
+  "objectsRead": 7,
+  "pipeObjectsRead": 7,
+  "phpRecAnnotRuns": 1,
+  "pxpAavRuns": null,
+  "pxpOaRuns": null,
+  "planId": null,
+  "repeatedPlanIdEqual": null,
+  "dbmodBefore": null,
+  "dbmodAfter": null,
+  "dwgModified": null,
+  "dcfModified": null,
+  "changedProjectFiles": null,
+  "unhandledExceptions": 0,
+  "applyModeUsed": false,
+  "launcherRollback": "RolledBack",
+  "exactViewportMembership": "not-verified"
+}
@@ -0,0 +1,46 @@
+# Ortho DryRun runtime result
+
+Date: 2026-08-03
+
+The local test fixture's `TestPipeOrtho.dwg` was detected as Ortho with one
+viewport. In the paired `DryRun`, `PHP_REC_ANNOT`, `PXP-AAV`, and `PXP-OA`
+each ran twice. Plugin telemetry recorded all six preflight completions without
+an unhandled exception. The command-window DBMOD output was not retained for
+this paired run, so its DBMOD value is recorded as `NOT RECORDED` rather than
+inferred from telemetry.
+
+`PlantProject.Name` was available for this fixture and rendered as
+`PRecAnnotTestProject`.
+
+The active Ortho sheet does not expose direct Piping rows and must not be used
+as a DataLinks source. Metadata inspection and a sanitized runtime probe
+confirmed `IDwgViewDef.DwgQuery.ModelFiles[].ModelFileName` as the source-model
+reference. The adapter resolves that reference through
+`PipingProject.GetPnPDrawingFiles()` and reads
+`DataLinksManager.SelectAcPpRowIds(PnPProjectDrawing.Id)`.
+
+On the paired real DryRun, one source drawing was resolved and seven source
+Plant objects were read. The confirmed view query resolved five source rows to
+the active viewport and classified two as outside the view. Each command
+reported seven skipped operations, zero writes, zero conflicts, and zero
+errors. The repeated plans were deterministic:
+
+| Command | Run 1 / run 2 PlanId |
+| --- | --- |
+| `PHP_REC_ANNOT` | `plan-AD701C7AA38D99E4C28D7D6D` |
+| `PXP-AAV` | `plan-C4FCD62F4EEBA1D1948FA22B` |
+| `PXP-OA` | `plan-C30D133E2D5B4BF4C0AF2ED1` |
+
+This verifies source-model DataLinks access, exact view membership through the
+stored view query, and repeated-plan determinism. The remaining functional
+limitation is annotation-rule coverage: all seven operations remain safe
+`Skip` operations, so no first Apply is authorised.
+
+The earlier single-fixture SHA baseline changed before the first command and
+was therefore inconclusive. A fresh paired comparison used 210-file CONTROL
+and DRYRUN copies created from the same closed frozen fixture. Both inventories
+had zero SHA-256 delta after their respective sessions. The CONTROL session
+invoked no plugin command; the DRYRUN session invoked all six commands. Thus
+the model DWG, Ortho DWG, `Piping.dcf`, project metadata, and other tracked
+content-bearing files have no plugin-only delta in this comparison. Both
+Launcher sessions completed automatic rollback to `RolledBack`.
@@ -0,0 +1,39 @@
+# Ortho source-model mapping
+
+## Confirmed Plant 3D 2026 read path
+
+```text
+Active Ortho document
+→ OrthoProject.DwgSheetDefinitions
+→ IDwgSheetDef.DwgViewDefs
+→ IDwgViewDef.DwgQuery.ModelFiles[].ModelFileName
+→ PipingProject.GetPnPDrawingFiles()
+→ exact normalized-path match to PnPProjectDrawing
+→ PnPProjectDrawing.Id
+→ DataLinksManager.SelectAcPpRowIds(int dwgid)
+→ GetObjectClassname / GetAllProperties
+→ independent PlantObjectSnapshot
+→ AnnotationPlanBuilder
+```
+
+`PlantOrthoViewportReader.ReadViewports` reads the typed DwgQuery contract and
+creates an Ortho viewport snapshot. `PlantObjectReader.ReadObjects` resolves
+the resulting model-file reference through the Piping project drawing list and
+reads DataLinks by project drawing ID. The active Ortho database is not a
+Piping-row source.
+
+All calls are read-only. The adapter opens no write transaction and does not
+save a drawing, DCF, or project metadata.
+
+## Diagnostics
+
+The source reader returns stable telemetry diagnostics rather than suppressing
+the result of a failed query: `ORTHO_SOURCE_DRAWING_NOT_RESOLVED`,
+`ORTHO_SOURCE_DRAWING_NOT_IN_PROJECT`, `ORTHO_SOURCE_DRAWING_AMBIGUOUS`,
+`PIPING_PROJECT_PART_NOT_FOUND`, `SOURCE_DATALINKS_UNAVAILABLE`,
+`SOURCE_DATALINKS_NO_ROWS`, `SOURCE_DATABASE_READ_FAILED`,
+`SOURCE_PIPE_ROWS_NOT_FOUND`, or `SOURCE_DATALINKS_READ`.
+
+Exact membership of a source object in a particular Ortho viewport is not yet
+implemented. A source-level DryRun plan must not be presented as proof of
+viewport membership.
@@ -0,0 +1,36 @@
+# Ortho viewport membership
+
+## Runtime path
+
+`EntryPoint.RunDiagnostic` reads each `OrthoViewportInfo` and calls
+`PlantObjectReader.ReadObjects`. The reader resolves source Piping rows, then
+`PlantViewportMembershipReader.Read` evaluates the stored query for that exact
+view. It maps `MdObjectId.PrjObjectId` to a source DataLinks row and assigns a
+membership status to every independent `PlantObjectSnapshot`.
+
+| Status | Meaning | Diagnostic evidence |
+| --- | --- | --- |
+| `Resolved` | The source row was returned by the exact view query. | `VIEW_MEMBERSHIP_FROM_CONFIRMED_PNP_ID` |
+| `ObjectOutsideView` | The source row was not returned by that confirmed query. | `VIEW_MEMBERSHIP_OBJECT_OUTSIDE_CLIP` |
+| `NotResolved` | The view contract is unavailable, ambiguous, or failed. | `VIEW_MEMBERSHIP_API_UNSUPPORTED` |
+
+No source object is treated as visible solely because it belongs to the same
+model drawing. No geometry-only result is upgraded to `Resolved`.
+
+## Plan effect
+
+`AnnotationPlanBuilder` includes membership status in its canonical plan input.
+`ObjectOutsideView`, unsupported, and unresolved objects are `Skip` operations
+with stable reason codes. `Resolved` membership can progress only through the
+existing annotation rules; this DryRun slice never writes an annotation.
+
+## Paired DryRun evidence
+
+The paired local DryRun resolved five of seven source rows through the exact
+view query and classified the remaining two as `ObjectOutsideView`. Each of
+the three supported commands produced an identical PlanId on its repeated
+invocation. Both Launcher sessions reached `RolledBack`.
+
+The paired command-window DBMOD output was not retained. It is intentionally
+reported as `NOT RECORDED`; project-file SHA-256 inventories nevertheless had
+zero delta for both CONTROL and DRYRUN copies.
@@ -0,0 +1,101 @@
+# Plant 3D 2026 DwgQuery / ModelFiles API contract
+
+## Scope and method
+
+This report is based on metadata-only inspection of the installed Plant 3D 2026
+assemblies. The assemblies were read from `<PLANT3D_2026_INSTALL>` and were not
+copied into the repository. Metadata-only inspection was necessary because the
+normal PowerShell host cannot load the product's .NET 8 dependencies safely.
+
+Legacy source at the documented local path was not present on this machine, so
+there is no legacy API claim in this report.
+
+## Confirmed assemblies
+
+| Assembly | Version | Relevant type |
+| --- | --- | --- |
+| `PnPDwg2dDef` | `0.0.0.0` | `Autodesk.ProcessPower.Drawings2d.DwgQuery`, `IDwgQuery`, `DwgViewDef`, `IDwgViewDef`, `DwgSheetDef`, `IDwgSheetDef` |
+| `PnPDwg2dUtil` | `0.0.0.0` | `Autodesk.ProcessPower.Drawings2d.ModelFile` |
+| `PnP3dOrthoProjectPart` | `17.0.60.1` | Ortho project-part integration assembly; the metadata scan found no public DwgQuery declaration there |
+
+`PnPDwg2dDef` and `PnPDwg2dUtil` use `0.0.0.0` assembly versions in the
+installed metadata. The supported runtime contract is therefore identified by
+the exact public type names below, not by an invented product-version number.
+
+## Confirmed contract
+
+```text
+Autodesk.ProcessPower.Drawings2d.IDwgViewDef.DwgQuery
+  : Autodesk.ProcessPower.Drawings2d.IDwgQuery
+
+Autodesk.ProcessPower.Drawings2d.IDwgQuery.ModelFiles
+  : Autodesk.ProcessPower.Drawings2d.ModelFile[]
+
+Autodesk.ProcessPower.Drawings2d.ModelFile.ModelFileName
+  : System.String
+
+Autodesk.ProcessPower.Drawings2d.ModelFile.ModelFileGuid
+  : System.String
+```
+
+`DwgViewDef` implements `IDwgViewDef`; `DwgQuery` implements `IDwgQuery` and
+`IDisposable`; `ModelFile` implements `IComparable<ModelFile>`.
+
+`ModelFiles` is an array, not an untyped enumerable. `ModelFileName` is the
+only confirmed string field representing the model-file reference. `ModelFileGuid`
+is a separate identity field. `IsReferencedDwg` and `Xform` describe reference
+state and transform, not a substitute path.
+
+## Public members relevant to source resolution
+
+`IDwgViewDef` exposes `DwgQuery`, `ViewName`, layout/orientation properties,
+and `SetClippingPlanes`, `SetLayout`, `SetOrientation`, `Erase`, and `New`.
+
+`IDwgQuery` exposes `ModelFiles`, `Execute`, and `Erase`.
+
+`ModelFile` exposes `ModelFileName`, `ModelFileGuid`, `IsReferencedDwg`, and
+`Xform`; its constructors accept a file-name string and optional transform,
+reference flag, and GUID.
+
+`IDwgSheetDef.DwgViewDefs` exposes the view-definition collection. Sheet
+`DwgName`/`DwgPath` identify the Ortho sheet and must not be used as the source
+of Piping DataLinks.
+
+## Current and legacy usage
+
+The original adapter used reflection and tried several possible names
+(`ModelFileName`, `Value`, and arbitrary string values). That was not a valid
+Plant 3D 2026 contract.
+
+The production read path now uses the confirmed typed chain only:
+
+```text
+IDwgViewDef.DwgQuery.ModelFiles[].ModelFileName
+```
+
+The legacy source path was unavailable locally, so no legacy source-model or
+DataLinks workaround has been imported.
+
+## Runtime evidence
+
+Static metadata cannot prove whether `ModelFileName` is project-relative or
+absolute in a concrete Ortho fixture, or whether a particular view has zero,
+one, or multiple model files. In DryRun only, setting
+`P_REC_ANNOT_DIAGNOSTICS=OrthoStructure` enables a sanitized structure probe.
+It records type names, collection counts, null state, string length, and a
+one-way value hash; it does not emit paths or engineering data.
+
+On the local DryRun fixture, the runtime probe recorded one view with one
+`ModelFile`. The concrete types were `DwgViewDef`, `DwgQueryByBox`, and
+`ModelFile[]`; `ModelFileName` was non-null and an absolute fixture-model
+reference. The path itself was not retained in repository evidence.
+
+The resolver resolves that reference to exactly one
+`PipingProject.GetPnPDrawingFiles()` entry by normalized full-path equality,
+then uses the confirmed `DataLinksManager.SelectAcPpRowIds(int dwgid)` overload
+with the resolved `PnPProjectDrawing.Id`. It does not open or query the active
+Ortho database for Piping rows.
+
+The production resolver has no fallback property-name search. If the exact
+contract is unavailable at runtime it reports
+`ORTHO_MODEL_FILES_API_UNSUPPORTED` rather than guessing.
@@ -0,0 +1,56 @@
+# Ortho viewport membership API
+
+## Scope
+
+This report records the Plant 3D 2026 contract used to map source-model
+DataLinks objects to one Ortho view. Autodesk binaries were inspected in
+`<PLANT3D_2026_INSTALL>` and are not part of this repository.
+
+## Confirmed Plant 3D 2026 contract
+
+| Assembly | Version | Type/member | Purpose |
+| --- | --- | --- | --- |
+| `PnPDwg2dDef` | `0.0.0.0` | `IDwgViewDef.DwgQuery` | Returns the query stored by an Ortho view. |
+| `PnPDwg2dDef` | `0.0.0.0` | `DwgQueryByBox.Execute(StringCollection, StringCollection)` | Executes the stored view selection and returns `IDwgSet`. |
+| `PnPDwg2dDef` | `0.0.0.0` | `IDwgSet.GetItem(int, ref MdObjectId)` | Enumerates selected source identities. |
+| `PnPDwg2dUtil` | `0.0.0.0` | `MdObjectId.PrjObjectId` | Exposes the selected project object identity. |
+| `PnPDataLinks` | `17.0.60.1` | `DataLinksManager.FindAcPpRowId(PpObjectId)` | Maps a selected project object to its DataLinks row. |
+
+`DwgQueryByBox` also exposes `CoordinateSystem`, `XLength`, `YLength`,
+`ZLength`, and `SelectionMask`. `DwgViewDef` exposes orientation, clipping,
+and layout fields. They are not used as a heuristic in this slice because the
+query result provides a stronger project-object identity.
+
+## Selected implementation
+
+`PlantViewportMembershipReader.Read` locates exactly one view by the stable
+ID already generated from the sheet GUID and view name. It executes that
+view's stored `DwgQuery`, converts every returned `MdObjectId.PrjObjectId`
+through `DataLinksManager.FindAcPpRowId`, and intersects the result with the
+source drawing's Piping rows.
+
+Matching rows receive `Resolved` with
+`VIEW_MEMBERSHIP_FROM_CONFIRMED_PNP_ID`. Source rows absent from the confirmed
+query result receive `ObjectOutsideView` with
+`VIEW_MEMBERSHIP_OBJECT_OUTSIDE_CLIP`. An unsupported or ambiguous runtime
+contract stays `NotResolved` with `VIEW_MEMBERSHIP_API_UNSUPPORTED`; the code
+does not guess alternate Autodesk properties or select an arbitrary view.
+
+## Legacy analysis
+
+The read-only legacy source at
+`\\phpsrv03\NBIM\code\CS\P_Rec_Annot\v1.0.4\repo` was available. Its
+`UpdateOrthoDrawings/Commands.cs` configured `DwgQuery.ModelFiles` and called
+`DwgQuery.Execute`; `OrthoAutoAnnotate/Commands.cs` and
+`AutoAnnotateView/ViewPorts.cs` also used viewport and entity extents. Those
+extents checks are a geometric filter, not an authoritative object identity,
+so they were not ported as `Resolved` membership.
+
+## Side effects and failure handling
+
+The reader opens no Autodesk write transaction and calls no persistence API.
+It does not modify DWG, DCF, or project metadata. `DLException` while mapping
+an individual generated identity is ignored only for that non-Piping identity;
+other failures yield the stable API diagnostic and preserve no false positive.
+Runtime DryRun and paired control/DryRun hash comparison remain required to
+verify actual no-write behavior.
@@ -8,6 +8,7 @@ public sealed record RuntimeDiagnostic
 }

 public enum OrthoDetectionStatus { Confirmed, NotOrtho, Ambiguous, Unsupported, Failed }
+public enum PlantProjectDetectionStatus { NotFound, FoundWithName, FoundWithoutDisplayName, Ambiguous, Failed }

 public sealed record OrthoDetectionResult
 {
@@ -57,6 +58,19 @@ public sealed record PlantObjectSnapshot
    public required GeometrySnapshot Geometry { get; init; }
    public IReadOnlyDictionary<string, string?> Properties { get; init; } = new Dictionary<string, string?>();
    public IReadOnlyList<string> Diagnostics { get; init; } = Array.Empty<string>();
+    public ViewMembershipStatus MembershipStatus { get; init; } = ViewMembershipStatus.NotResolved;
+    public IReadOnlyList<string> MembershipEvidenceCodes { get; init; } = Array.Empty<string>();
+}
+
+public enum ViewMembershipStatus { NotResolved, Resolved, PartiallyResolved, ObjectOutsideView, Unsupported, Failed }
+
+public sealed record SourceObjectViewportMembership
+{
+    public required string SourceObjectStableKey { get; init; }
+    public required string ViewStableKey { get; init; }
+    public required ViewMembershipStatus Status { get; init; }
+    public IReadOnlyList<string> EvidenceCodes { get; init; } = Array.Empty<string>();
+    public string? ReasonCode { get; init; }
 }

 public sealed record PlantRuntimeContext
@@ -66,6 +80,7 @@ public sealed record PlantRuntimeContext
    public bool IsOrthoDrawing { get; init; }
    public string? DrawingName { get; init; }
    public string? ProjectDisplayName { get; init; }
+    public PlantProjectDetectionStatus ProjectDetectionStatus { get; init; } = PlantProjectDetectionStatus.NotFound;
    public IReadOnlyList<OrthoViewportInfo> Viewports { get; init; } = Array.Empty<OrthoViewportInfo>();
    public IReadOnlyList<RuntimeDiagnostic> Diagnostics { get; init; } = Array.Empty<RuntimeDiagnostic>();
    public OrthoDetectionResult Detection { get; init; } = new() { Status = OrthoDetectionStatus.Unsupported, Evidence = Array.Empty<string>(), Diagnostics = Array.Empty<RuntimeDiagnostic>() };
@@ -74,6 +89,62 @@ public sealed record PlantRuntimeContext
 public interface IPlantRuntimeContextReader { PlantRuntimeContext ReadCurrentContext(); }
 public interface IOrthoViewportReader { IReadOnlyList<OrthoViewportInfo> ReadViewports(CancellationToken cancellationToken); }

+public enum SourceDrawingResolutionStatus { Resolved, NotReferenced, Ambiguous, MissingFromProject, Unsupported, Failed }
+
+public sealed record OrthoSourceDrawingReference
+{
+    public required string StableId { get; init; }
+    public required string DisplayName { get; init; }
+    public string? ProjectRelativePath { get; init; }
+    public long? ProjectDrawingRowId { get; init; }
+    public required SourceDrawingResolutionStatus Status { get; init; }
+    public IReadOnlyList<string> EvidenceCodes { get; init; } = Array.Empty<string>();
+}
+
+public sealed record SourcePlantObjectSnapshot
+{
+    public required string StableObjectKey { get; init; }
+    public required string ClassName { get; init; }
+    public string? SourceDrawingStableId { get; init; }
+    public string? LineGroupStableKey { get; init; }
+    public IReadOnlyDictionary<string, string?> Properties { get; init; } = new Dictionary<string, string?>();
+}
+
+public sealed record SourceDrawingReadResult
+{
+    public required OrthoSourceDrawingReference Source { get; init; }
+    public IReadOnlyList<SourcePlantObjectSnapshot> Objects { get; init; } = Array.Empty<SourcePlantObjectSnapshot>();
+    public IReadOnlyList<RuntimeDiagnostic> Diagnostics { get; init; } = Array.Empty<RuntimeDiagnostic>();
+}
+
+public interface IOrthoSourceDrawingResolver
+{
+    IReadOnlyList<OrthoSourceDrawingReference> Resolve(OrthoDrawingSnapshot drawing);
+}
+
+public sealed record OrthoDrawingSnapshot
+{
+    public required string StableId { get; init; }
+    public IReadOnlyList<OrthoViewSourceSnapshot> Views { get; init; } = Array.Empty<OrthoViewSourceSnapshot>();
+}
+
+public sealed record OrthoViewSourceSnapshot
+{
+    public required string ViewStableId { get; init; }
+    public IReadOnlyList<string> ReferencedDrawingPaths { get; init; } = Array.Empty<string>();
+}
+
+public interface ISourceDrawingDataLinksReader
+{
+    SourceDrawingReadResult Read(PlantProjectContext project, OrthoSourceDrawingReference source);
+}
+
+public sealed record PlantProjectContext
+{
+    public required string StableProjectId { get; init; }
+    public string? ProjectDisplayName { get; init; }
+}
+
 public enum AnnotationOperationKind { Create, Update, Skip, Conflict, Unsupported }

 public sealed record AnnotationOperationPlan
@@ -106,12 +177,40 @@ public sealed record AnnotationPlanningRequest
    public required OrthoViewportInfo Viewport { get; init; }
    public IReadOnlyList<PlantObjectSnapshot> Objects { get; init; } = Array.Empty<PlantObjectSnapshot>();
    public IReadOnlyList<ExistingAnnotation> Existing { get; init; } = Array.Empty<ExistingAnnotation>();
+    // Test-only limited Apply intent.  It is part of the canonical plan and is
+    // deliberately explicit: the planner must never choose an arbitrary Pipe.
+    public string? LimitedApplyTargetSnapshotId { get; init; }
+    public string? LimitedApplyRuleId { get; init; }
 }

 public interface IAnnotationPlanBuilder { AnnotationPlan Build(AnnotationPlanningRequest request); }
 public enum PRecAnnotExecutionMode { Smoke, DryRun, Apply }
 public interface IRuntimeWriteGuard { void EnsureWriteAllowed(string operation); }

+public sealed record CreatePipeAnnotationOperation
+{
+    public required string OperationId { get; init; }
+    public required string SourceObjectStableKey { get; init; }
+    public required string ViewStableKey { get; init; }
+    public required string RuleId { get; init; }
+    public required AnnotationPoint Placement { get; init; }
+    public required string DuplicateKey { get; init; }
+}
+
+public sealed record FirstLimitedApplyPermit
+{
+    public required string FixtureMarker { get; init; }
+    public required bool AllowApply { get; init; }
+    public required string TargetSnapshotId { get; init; }
+    public required string ExpectedPlanId { get; init; }
+}
+
+public sealed record FirstLimitedApplyPreflight
+{
+    public required string PlanId { get; init; }
+    public required CreatePipeAnnotationOperation Operation { get; init; }
+}
+
 public sealed record OrthoViewportRef(string DrawingId, string ViewportId);

 public sealed record PlantObjectData
@@ -148,6 +247,7 @@ public sealed record AnnotationIntent

 public sealed record AnnotationPlan
 {
+    public int PlanSchemaVersion { get; init; }
    public string PlanId { get; init; } = string.Empty;
    public string CommandName { get; init; } = string.Empty;
    public IReadOnlyList<AnnotationOperationPlan> Operations { get; init; } = Array.Empty<AnnotationOperationPlan>();
@@ -6,6 +6,7 @@ namespace PRecAnnot.Core;

 public sealed class AnnotationPlanBuilder : IAnnotationPlanBuilder
 {
+    public const int CurrentPlanSchemaVersion = 2;
    public AnnotationPlan Build(AnnotationPlanningRequest request)
    {
        var objects = request.Objects.OrderBy(x => x.SnapshotId, StringComparer.Ordinal).ToArray();
@@ -30,6 +31,65 @@ public sealed class AnnotationPlanBuilder : IAnnotationPlanBuilder
                continue;
            }

+            if (!string.IsNullOrWhiteSpace(request.LimitedApplyTargetSnapshotId) &&
+                !string.Equals(item.SnapshotId, request.LimitedApplyTargetSnapshotId, StringComparison.Ordinal))
+            {
+                operations.Add(new AnnotationOperationPlan { SourceSnapshotId = item.SnapshotId, Kind = AnnotationOperationKind.Skip, Reasons = new[] { "APPLY_NOT_SELECTED_TARGET" } });
+                continue;
+            }
+
+            if (item.MembershipStatus is not ViewMembershipStatus.Resolved and not ViewMembershipStatus.PartiallyResolved)
+            {
+                operations.Add(new AnnotationOperationPlan { SourceSnapshotId = item.SnapshotId, Kind = AnnotationOperationKind.Skip, Reasons = new[] { MembershipReason(item.MembershipStatus) } });
+                continue;
+            }
+
+            // The first Apply slice is intentionally narrower than the
+            // historic bulk rules: exactly one explicitly selected, resolved
+            // Pipe can become a PIPE block operation.  All other objects keep
+            // their normal diagnostic treatment.
+            if (!string.IsNullOrWhiteSpace(request.LimitedApplyTargetSnapshotId) &&
+                string.Equals(item.SnapshotId, request.LimitedApplyTargetSnapshotId, StringComparison.Ordinal))
+            {
+                if (!string.Equals(item.ObjectClass, "Pipe", StringComparison.OrdinalIgnoreCase))
+                {
+                    operations.Add(new AnnotationOperationPlan { SourceSnapshotId = item.SnapshotId, Kind = AnnotationOperationKind.Unsupported, Reasons = new[] { "APPLY_UNSUPPORTED_OBJECT_CLASS" } });
+                    continue;
+                }
+                if (item.MembershipStatus != ViewMembershipStatus.Resolved)
+                {
+                    operations.Add(new AnnotationOperationPlan { SourceSnapshotId = item.SnapshotId, Kind = AnnotationOperationKind.Skip, Reasons = new[] { "APPLY_REQUIRES_RESOLVED_MEMBERSHIP" } });
+                    continue;
+                }
+                if (item.Geometry.PaperPosition is not { } pipePosition)
+                {
+                    operations.Add(new AnnotationOperationPlan { SourceSnapshotId = item.SnapshotId, Kind = AnnotationOperationKind.Skip, Reasons = new[] { "ANNOTATION_PLACEMENT_NOT_RESOLVED" } });
+                    continue;
+                }
+
+                var pipeIntent = new AnnotationIntent
+                {
+                    StableKey = $"{request.Viewport.Id}:{item.SnapshotId}:{FirstLimitedApplyPlanner.RuleId}",
+                    Text = FirstLimitedApplyPlanner.RuleId,
+                    Position = new AnnotationPoint(pipePosition.X, pipePosition.Y),
+                    Rotation = item.Geometry.Rotation ?? 0,
+                    ClassName = item.ObjectClass,
+                    Layer = "PXP_ANNOTATION"
+                };
+                operations.Add(new AnnotationOperationPlan
+                {
+                    SourceSnapshotId = item.SnapshotId,
+                    Kind = AnnotationOperationKind.Create,
+                    AnnotationType = "PIPE",
+                    Text = FirstLimitedApplyPlanner.RuleId,
+                    Position = pipePosition,
+                    Rotation = item.Geometry.Rotation,
+                    Reasons = Array.Empty<string>()
+                });
+                creates.Add(pipeIntent);
+                continue;
+            }
+
            var text = string.IsNullOrWhiteSpace(item.LineNumber) ? item.Tag?.Trim() : item.LineNumber!.Trim();
            if (string.IsNullOrWhiteSpace(text))
            {
@@ -84,7 +144,8 @@ public sealed class AnnotationPlanBuilder : IAnnotationPlanBuilder

        return new AnnotationPlan
        {
-            PlanId = BuildPlanId(request, objects),
+            PlanSchemaVersion = CurrentPlanSchemaVersion,
+            PlanId = BuildPlanId(request, objects, operations),
            CommandName = request.CommandName,
            Operations = operations,
            Diagnostics = diagnostics,
@@ -92,18 +153,41 @@ public sealed class AnnotationPlanBuilder : IAnnotationPlanBuilder
            Create = creates,
            Update = updates,
            Delete = Array.Empty<string>(),
-            SkipReasons = operations.Where(x => x.Kind == AnnotationOperationKind.Skip).SelectMany(x => x.Reasons).ToArray(),
+            SkipReasons = operations.Where(x => x.Kind == AnnotationOperationKind.Skip).SelectMany(x => x.Reasons).OrderBy(x => x, StringComparer.Ordinal).ToArray(),
            ExaminedCount = objects.Length,
            IsDeterministic = true
        };
    }

-    private static string BuildPlanId(AnnotationPlanningRequest request, IReadOnlyList<PlantObjectSnapshot> objects)
+    private static string BuildPlanId(AnnotationPlanningRequest request, IReadOnlyList<PlantObjectSnapshot> objects, IReadOnlyList<AnnotationOperationPlan> operations)
    {
-        var canonical = new StringBuilder(request.CommandName).Append('|').Append(request.Viewport.SourceDrawingName).Append('|').Append(request.Viewport.Id);
-        foreach (var item in objects)
-            canonical.Append('|').Append(item.SnapshotId).Append('|').Append(item.ObjectClass).Append('|').Append(item.Tag).Append('|').Append(item.LineNumber).Append('|').Append(item.Geometry.PaperPosition);
+        var canonical = new StringBuilder("schema=").Append(CurrentPlanSchemaVersion)
+            .Append("|command=").Append(Normalize(request.CommandName))
+            .Append("|source=").Append(Normalize(Path.GetFileName(request.Viewport.SourceDrawingName)))
+            .Append("|view=").Append(Normalize(request.Viewport.Id))
+            .Append("|limited-target=").Append(Normalize(request.LimitedApplyTargetSnapshotId))
+            .Append("|limited-rule=").Append(Normalize(request.LimitedApplyRuleId));
+        foreach (var item in objects.OrderBy(x => x.SnapshotId, StringComparer.Ordinal))
+        {
+            canonical.Append("|object=").Append(Normalize(item.SnapshotId)).Append('|').Append(Normalize(item.ObjectClass))
+                .Append('|').Append(Normalize(item.Tag)).Append('|').Append(Normalize(item.LineNumber))
+                .Append('|').Append(item.MembershipStatus);
+            foreach (var property in item.Properties.OrderBy(x => x.Key, StringComparer.Ordinal))
+                canonical.Append("|property=").Append(Normalize(property.Key)).Append('=').Append(Normalize(property.Value));
+        }
+        foreach (var operation in operations.OrderBy(x => x.SourceSnapshotId, StringComparer.Ordinal).ThenBy(x => x.Kind))
+            canonical.Append("|operation=").Append(Normalize(operation.SourceSnapshotId)).Append(':').Append(operation.Kind).Append(':').Append(string.Join(',', operation.Reasons.OrderBy(x => x, StringComparer.Ordinal)));
        var hash = SHA256.HashData(Encoding.UTF8.GetBytes(canonical.ToString()));
        return "plan-" + Convert.ToHexString(hash)[..24];
    }
+
+    private static string Normalize(string? value) => (value ?? string.Empty).Trim().Normalize(NormalizationForm.FormC);
+
+    private static string MembershipReason(ViewMembershipStatus status) => status switch
+    {
+        ViewMembershipStatus.ObjectOutsideView => "VIEW_MEMBERSHIP_OBJECT_OUTSIDE_CLIP",
+        ViewMembershipStatus.Unsupported => "VIEW_MEMBERSHIP_API_UNSUPPORTED",
+        ViewMembershipStatus.Failed => "VIEW_MEMBERSHIP_TRANSFORM_FAILED",
+        _ => "VIEW_MEMBERSHIP_NOT_RESOLVED"
+    };
 }
@@ -12,7 +12,8 @@ public sealed class AnnotationRuleEngine : IAnnotationRuleEngine
            ObjectClass = item.ClassName,
            Tag = item.Tag,
            LineNumber = item.LineNumber,
-            Geometry = new GeometrySnapshot { PaperPosition = new Point2Dto(item.Position.X, item.Position.Y), Rotation = item.Rotation }
+            Geometry = new GeometrySnapshot { PaperPosition = new Point2Dto(item.Position.X, item.Position.Y), Rotation = item.Rotation },
+            MembershipStatus = ViewMembershipStatus.Resolved
        }).ToArray();

        return new AnnotationPlanBuilder().Build(new AnnotationPlanningRequest
@@ -0,0 +1,52 @@
+using System.Security.Cryptography;
+using System.Text;
+using PRecAnnot.Abstractions;
+
+namespace PRecAnnot.Core;
+
+public sealed class FirstLimitedApplyPlanner
+{
+    public const string FixtureMarker = "FIRST_LIMITED_APPLY";
+    public const string RuleId = "PXP-OA.PIPE.OPEN-END.V1";
+
+    public FirstLimitedApplyPreflight Prepare(
+        PRecAnnotExecutionMode mode,
+        AnnotationPlan plan,
+        OrthoViewportInfo viewport,
+        IReadOnlyList<PlantObjectSnapshot> objects,
+        FirstLimitedApplyPermit permit)
+    {
+        if (mode != PRecAnnotExecutionMode.Apply) throw new InvalidOperationException("APPLY_MODE_REQUIRED");
+        if (!permit.AllowApply || !string.Equals(permit.FixtureMarker, FixtureMarker, StringComparison.Ordinal))
+            throw new InvalidOperationException("APPLY_TEST_FIXTURE_OR_PERMIT_REQUIRED");
+        if (!string.Equals(permit.ExpectedPlanId, plan.PlanId, StringComparison.Ordinal))
+            throw new InvalidOperationException("APPLY_PLAN_STALE");
+
+        var targets = objects.Where(x => string.Equals(x.SnapshotId, permit.TargetSnapshotId, StringComparison.Ordinal)).ToArray();
+        if (targets.Length != 1) throw new InvalidOperationException("APPLY_REQUIRES_EXACTLY_ONE_TARGET");
+        var target = targets[0];
+        if (target.MembershipStatus != ViewMembershipStatus.Resolved) throw new InvalidOperationException("APPLY_REQUIRES_RESOLVED_MEMBERSHIP");
+        if (!string.Equals(target.ObjectClass, "Pipe", StringComparison.OrdinalIgnoreCase)) throw new InvalidOperationException("APPLY_UNSUPPORTED_OBJECT_CLASS");
+        if (target.Geometry.PaperPosition is not { } placement) throw new InvalidOperationException("ANNOTATION_PLACEMENT_NOT_RESOLVED");
+
+        var create = plan.Operations.Where(x => x.Kind == AnnotationOperationKind.Create && string.Equals(x.SourceSnapshotId, target.SnapshotId, StringComparison.Ordinal)).ToArray();
+        if (create.Length != 1) throw new InvalidOperationException("APPLY_TARGET_CREATE_NOT_PLANNED");
+
+        var duplicateKey = Stable("duplicate", RuleId, viewport.Id, target.SnapshotId);
+        return new FirstLimitedApplyPreflight
+        {
+            PlanId = plan.PlanId,
+            Operation = new CreatePipeAnnotationOperation
+            {
+                OperationId = Stable("operation", RuleId, viewport.Id, target.SnapshotId),
+                SourceObjectStableKey = target.SnapshotId,
+                ViewStableKey = viewport.Id,
+                RuleId = RuleId,
+                Placement = new AnnotationPoint(placement.X, placement.Y),
+                DuplicateKey = duplicateKey
+            }
+        };
+    }
+
+    private static string Stable(params string[] values) => Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(string.Join("|", values))))[..24];
+}
@@ -0,0 +1,47 @@
+using System.Security.Cryptography;
+using System.Text;
+using PRecAnnot.Abstractions;
+
+namespace PRecAnnot.Core;
+
+public sealed class OrthoSourceDrawingResolver : IOrthoSourceDrawingResolver
+{
+    public IReadOnlyList<OrthoSourceDrawingReference> Resolve(OrthoDrawingSnapshot drawing)
+    {
+        var candidates = drawing.Views
+            .OrderBy(x => x.ViewStableId, StringComparer.Ordinal)
+            .SelectMany(x => x.ReferencedDrawingPaths)
+            .Where(x => !string.IsNullOrWhiteSpace(x))
+            .Select(x => x.Trim().Replace('\\', '/'))
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .OrderBy(x => x, StringComparer.OrdinalIgnoreCase)
+            .Select(path => new OrthoSourceDrawingReference
+            {
+                StableId = StableId(drawing.StableId, path),
+                DisplayName = Path.GetFileName(path),
+                ProjectRelativePath = path,
+                Status = SourceDrawingResolutionStatus.Resolved,
+                EvidenceCodes = new[] { "SOURCE_FROM_VIEW_DEFINITION", "SOURCE_PATH_MATCHED_PROJECT_RELATIVE" }
+            })
+            .ToArray();
+
+        return candidates.Length != 0
+            ? candidates
+            : new[]
+            {
+                new OrthoSourceDrawingReference
+                {
+                    StableId = StableId(drawing.StableId, "none"),
+                    DisplayName = "source drawing unavailable",
+                    Status = SourceDrawingResolutionStatus.NotReferenced,
+                    EvidenceCodes = new[] { "ORTHO_SOURCE_DRAWING_NOT_RESOLVED" }
+                }
+            };
+    }
+
+    private static string StableId(string drawingId, string source)
+    {
+        var hash = SHA256.HashData(Encoding.UTF8.GetBytes($"{drawingId}|{source}"));
+        return "src-" + Convert.ToHexString(hash)[..20];
+    }
+}
@@ -0,0 +1,3 @@
+using Autodesk.AutoCAD.Runtime;
+
+[assembly: CommandClass(typeof(PRecAnnot.Plant3D2026.EntryPoint))]
@@ -14,6 +14,8 @@ public sealed class EntryPoint : IExtensionApplication
    {
        RuntimeDiagnostics.Write("AssemblyInitializeStarted");
        RibbonIntegration.Register();
+        // Test automation is driven only by the explicitly generated /b script.
+        // Initialize remains production-equivalent and must not orchestrate commands.
        RuntimeDiagnostics.Write("AssemblyInitializeCompleted");
    }

@@ -33,6 +35,33 @@ public sealed class EntryPoint : IExtensionApplication
    [CommandMethod("PXP-OA")]
    public void OrthoAnnotateCommand() => RunDiagnostic("PXP-OA");

+    [CommandMethod("PHP_REC_AUTOMATION_START", CommandFlags.Session)]
+    public void AutomationStartCommand() => FirstLimitedApplyAutomationBootstrap.Arm();
+
+    // Test-only command-queue barrier. It deliberately performs no Plant or
+    // drawing work; its CommandEnded event proves the activated document is
+    // ready before the coordinator calls the Plant APIs.
+    [CommandMethod("PHP_REC_AUTOMATION_READY")]
+    public void AutomationReadyCommand() { }
+
+    [CommandMethod("PHP_REC_AUTOMATION_PREPARE", CommandFlags.Session)]
+    public void AutomationPrepareCommand() => ScriptDrivenFirstApplyAutomation.Prepare();
+
+    [CommandMethod("PHP_REC_AUTOMATION_BEFORE_PXP_1", CommandFlags.Session)]
+    public void AutomationBeforePxp1Command() => ScriptDrivenFirstApplyAutomation.RecordSentinel("BeforePxp1");
+
+    [CommandMethod("PHP_REC_AUTOMATION_AFTER_PXP_1", CommandFlags.Session)]
+    public void AutomationAfterPxp1Command() => ScriptDrivenFirstApplyAutomation.RecordSentinel("AfterPxp1");
+
+    [CommandMethod("PHP_REC_AUTOMATION_BEFORE_PXP_2", CommandFlags.Session)]
+    public void AutomationBeforePxp2Command() => ScriptDrivenFirstApplyAutomation.RecordSentinel("BeforePxp2");
+
+    [CommandMethod("PHP_REC_AUTOMATION_AFTER_PXP_2", CommandFlags.Session)]
+    public void AutomationAfterPxp2Command() => ScriptDrivenFirstApplyAutomation.RecordSentinel("AfterPxp2");
+
+    [CommandMethod("PHP_REC_AUTOMATION_FINALIZE", CommandFlags.Session)]
+    public void AutomationFinalizeCommand() => ScriptDrivenFirstApplyAutomation.FinalizeAutomation();
+
    private static void RunDiagnostic(string commandName)
    {
        var operationId = Guid.NewGuid().ToString("N");
@@ -43,9 +72,14 @@ public sealed class EntryPoint : IExtensionApplication
        {
            document = AcadApplication.DocumentManager.MdiActiveDocument;
            var mode = ParseMode(RuntimeDiagnostics.RuntimeMode);
-            if (mode == PRecAnnotExecutionMode.Apply) throw new InvalidOperationException("APPLY_MODE_NOT_IMPLEMENTED");

-            var context = new PlantRuntimeContextReader().ReadCurrentContext();
+            // Script-driven commands can run while Plant's implicit current
+            // document lags behind MDI activation. Bind the planner to the
+            // command document captured above, which is also the observer's
+            // fixture identity.
+            var context = ScriptDrivenFirstApplyAutomation.TryGetPreparedContext(document, out var scriptContext)
+                ? scriptContext
+                : new PlantRuntimeContextReader().ReadCurrentContext(document);
            var details = new Dictionary<string, object?>
            {
                ["ExecutionMode"] = mode.ToString(),
@@ -75,12 +109,45 @@ public sealed class EntryPoint : IExtensionApplication
                return;
            }

+            if (mode == PRecAnnotExecutionMode.Apply && !string.Equals(commandName, "PXP-OA", StringComparison.Ordinal))
+                throw new InvalidOperationException("APPLY_RULE_NOT_SUPPORTED");
+            var hasLimitedApplyPermit = !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("P_REC_ANNOT_APPLY_PERMIT_PATH"));
+            var applyPermit = (mode == PRecAnnotExecutionMode.Apply || hasLimitedApplyPermit) && document is not null
+                ? FirstLimitedApplyPermitReader.ReadFor(document)
+                : null;
+            var automationTarget = ScriptDrivenFirstApplyAutomation.SelectedTargetSnapshotId
+                ?? FirstLimitedApplyAutomationCoordinator.SelectedTargetSnapshotId;
+            var limitedTarget = applyPermit?.TargetSnapshotId ?? automationTarget;
+            if (mode == PRecAnnotExecutionMode.Apply && context.Viewports.Count != 1)
+                throw new InvalidOperationException("APPLY_REQUIRES_EXACTLY_ONE_VIEWPORT");
+
            var builder = new AnnotationPlanBuilder();
            var plans = new List<AnnotationPlan>();
+            var objectsByViewport = new List<IReadOnlyList<PlantObjectSnapshot>>();
            foreach (var viewport in context.Viewports)
            {
                var objects = new PlantObjectReader().ReadObjects(viewport, CancellationToken.None);
-                plans.Add(builder.Build(new AnnotationPlanningRequest { CommandName = commandName, Viewport = viewport, Objects = objects }));
+                objectsByViewport.Add(objects);
+                plans.Add(builder.Build(new AnnotationPlanningRequest
+                {
+                    CommandName = commandName,
+                    Viewport = viewport,
+                    Objects = objects,
+                    LimitedApplyTargetSnapshotId = limitedTarget,
+                    LimitedApplyRuleId = limitedTarget is null ? null : FirstLimitedApplyPlanner.RuleId
+                }));
+            }
+
+            if (mode == PRecAnnotExecutionMode.DryRun &&
+                string.Equals(Environment.GetEnvironmentVariable("P_REC_ANNOT_DIAGNOSTICS"), "FirstLimitedApply", StringComparison.Ordinal))
+            {
+                var candidates = objectsByViewport.SelectMany(x => x)
+                    .Where(x => string.Equals(x.ObjectClass, "Pipe", StringComparison.OrdinalIgnoreCase) && x.MembershipStatus == ViewMembershipStatus.Resolved && x.Geometry.PaperPosition is not null)
+                    .Select(x => x.SnapshotId)
+                    .OrderBy(x => x, StringComparer.Ordinal)
+                    .ToArray();
+                WriteEditor(document, $"\nP_Rec_Annot Apply preview candidates: {string.Join(",", candidates)}");
+                details["ApplyPreviewCandidateCount"] = candidates.Length;
            }

            var summary = new
@@ -94,20 +161,65 @@ public sealed class EntryPoint : IExtensionApplication
                WarningCount = plans.Sum(x => x.Summary.WarningCount),
                ErrorCount = plans.Sum(x => x.Summary.ErrorCount)
            };
+            var membershipResolved = objectsByViewport.SelectMany(x => x).Count(x => x.MembershipStatus == ViewMembershipStatus.Resolved);
+            var membershipPartial = objectsByViewport.SelectMany(x => x).Count(x => x.MembershipStatus == ViewMembershipStatus.PartiallyResolved);
+            var membershipUnresolved = objectsByViewport.SelectMany(x => x).Count(x => x.MembershipStatus == ViewMembershipStatus.NotResolved);
+            var membershipOutside = objectsByViewport.SelectMany(x => x).Count(x => x.MembershipStatus == ViewMembershipStatus.ObjectOutsideView);
+            var planId = plans.Count == 1 ? plans[0].PlanId : null;
            details["ObjectsExamined"] = summary.ObjectsExamined;
+            details["PlanSchemaVersion"] = AnnotationPlanBuilder.CurrentPlanSchemaVersion;
+            details["PlanId"] = planId;
+            details["MembershipResolved"] = membershipResolved;
+            details["MembershipPartial"] = membershipPartial;
+            details["MembershipUnresolved"] = membershipUnresolved;
+            details["MembershipOutsideView"] = membershipOutside;
            details["PlanCreateCount"] = summary.CreateCount;
            details["PlanUpdateCount"] = summary.UpdateCount;
            details["PlanSkipCount"] = summary.SkipCount;
            details["PlanConflictCount"] = summary.ConflictCount;
            details["PlanUnsupportedCount"] = summary.UnsupportedCount;
            details["ErrorCount"] = summary.ErrorCount;
+            if (string.Equals(commandName, "PXP-OA", StringComparison.OrdinalIgnoreCase))
+            {
+                var candidates = objectsByViewport.SelectMany(x => x)
+                    .Where(x => string.Equals(x.ObjectClass, "Pipe", StringComparison.OrdinalIgnoreCase) && x.MembershipStatus == ViewMembershipStatus.Resolved && x.Geometry.PaperPosition is not null)
+                    .Select(x => x.SnapshotId).OrderBy(x => x, StringComparer.Ordinal).ToArray();
+                ScriptDrivenFirstApplyAutomation.RecordPxpOa(planId, candidates, context.Viewports.SingleOrDefault()?.Id, summary.CreateCount, summary.SkipCount, mode == PRecAnnotExecutionMode.Apply ? applyPermit is not null : null, summary.ObjectsExamined, membershipResolved);
+                FirstLimitedApplyAutomationCoordinator.RecordPxpOa(planId, candidates, context.Viewports.SingleOrDefault()?.Id, summary.CreateCount, summary.SkipCount, mode == PRecAnnotExecutionMode.Apply ? applyPermit is not null : null);
+            }
+            if (mode == PRecAnnotExecutionMode.Apply)
+            {
+                var corePermit = new FirstLimitedApplyPermit
+                {
+                    FixtureMarker = FirstLimitedApplyPlanner.FixtureMarker,
+                    AllowApply = applyPermit!.AllowApply,
+                    TargetSnapshotId = applyPermit.TargetSnapshotId,
+                    ExpectedPlanId = applyPermit.ExpectedPlanId
+                };
+                var preflight = new FirstLimitedApplyPlanner().Prepare(mode, plans.Single(), context.Viewports.Single(), objectsByViewport.Single(), corePermit);
+                new RuntimeWriteGuard(mode).EnsureWriteAllowed(preflight.Operation.OperationId);
+                RuntimeDiagnostics.Write("ApplyPreflightCompleted", operationId: operationId, commandName: commandName, resultStatus: "Accepted", document: document);
+                RuntimeDiagnostics.Write("AnnotationTransactionStarted", operationId: operationId, commandName: commandName, document: document);
+                var outcome = new FirstLimitedPipeAnnotationWriter().Write(document!, preflight.Operation, applyPermit.VisibilityState, applyPermit.AnnotationTemplateDwgPath);
+                ScriptDrivenFirstApplyAutomation.RecordApplyOutcome(outcome);
+                FirstLimitedApplyAutomationCoordinator.RecordApplyOutcome(outcome);
+                details["ApplyOutcome"] = outcome.ToString();
+                details["AnnotationsCreated"] = outcome == PipeAnnotationWriteOutcome.Created ? 1 : 0;
+                details["AnnotationsSkipped"] = outcome == PipeAnnotationWriteOutcome.AlreadyExists ? 1 : 0;
+                RuntimeDiagnostics.Write(outcome == PipeAnnotationWriteOutcome.Created ? "AnnotationCreated" : "AnnotationDuplicateDetected", operationId: operationId, commandName: commandName, resultStatus: outcome.ToString(), document: document);
+                RuntimeDiagnostics.Write("AnnotationTransactionCommitted", operationId: operationId, commandName: commandName, resultStatus: outcome.ToString(), document: document);
+            }
            RuntimeDiagnostics.Write("CommandPreflightCompleted", operationId: operationId, commandName: commandName, resultStatus: "DryRunCompleted", document: document, details: details);
            WriteEditor(document, $"\nP_Rec_Annot — диагностический план\nПроект: {context.ProjectDisplayName}\nТип чертежа: Ortho\nViewport: {context.Viewports.Count}\nОбъектов найдено: {summary.ObjectsExamined}\nБудет создано: {summary.CreateCount}\nБудет обновлено: {summary.UpdateCount}\nБудет пропущено: {summary.SkipCount}\nКонфликтов: {summary.ConflictCount}\nОшибок: {summary.ErrorCount}\nDWG не изменён.");
-            WriteUsage(operationId, commandName, "DryRunCompleted", document, details, stopwatch.ElapsedMilliseconds);
-            RuntimeDiagnostics.Write("CommandCompleted", operationId: operationId, commandName: commandName, resultStatus: "DryRunCompleted", document: document, details: details);
+            WriteEditor(document, $"\nPlan schema: {AnnotationPlanBuilder.CurrentPlanSchemaVersion}; PlanId: {planId ?? "multiple"}; membership resolved/partial/outside/unresolved: {membershipResolved}/{membershipPartial}/{membershipOutside}/{membershipUnresolved}.");
+            var completedStatus = mode == PRecAnnotExecutionMode.Apply ? "ApplyCompleted" : "DryRunCompleted";
+            WriteUsage(operationId, commandName, completedStatus, document, details, stopwatch.ElapsedMilliseconds);
+            RuntimeDiagnostics.Write("CommandCompleted", operationId: operationId, commandName: commandName, resultStatus: completedStatus, document: document, details: details);
        }
        catch (System.Exception exception)
        {
+            if (string.Equals(commandName, "PXP-OA", StringComparison.OrdinalIgnoreCase) && string.Equals(Environment.GetEnvironmentVariable("P_REC_ANNOT_RUNTIME_MODE"), "Apply", StringComparison.OrdinalIgnoreCase))
+                ScriptDrivenFirstApplyAutomation.RecordApplyFailure(exception);
            RuntimeDiagnostics.Write("CommandFailed", "ERROR", operationId, commandName, exception.Message, exception, document);
            WriteUsage(operationId, commandName, exception.Message, document, null, stopwatch.ElapsedMilliseconds, exception);
            WriteEditor(document, $"\nP_Rec_Annot: безопасная диагностика завершилась ошибкой: {exception.Message}");
@@ -0,0 +1,502 @@
+using System.Text.Json;
+using Autodesk.AutoCAD.ApplicationServices;
+using Autodesk.AutoCAD.DatabaseServices;
+using Autodesk.AutoCAD.Runtime;
+using Autodesk.ProcessPower.PlantInstance;
+using Autodesk.ProcessPower.ProjectManager;
+using PRecAnnot.Abstractions;
+using AcadApplication = Autodesk.AutoCAD.ApplicationServices.Application;
+
+namespace PRecAnnot.Plant3D2026;
+
+// Test-only coordinator. It is not registered in Ribbon and is inert unless
+// the explicit NextPilot automation environment and local marker are present.
+internal sealed record FirstApplyAutomationConfiguration
+{
+    public required string Phase { get; init; }
+    public string? OrthoDrawingPath { get; init; }
+    public string? ModelDrawingPath { get; init; }
+    public required string EvidencePath { get; init; }
+    public required string FixtureMarkerPath { get; init; }
+}
+
+internal sealed record AutomationEntityCounts(int Total, int PipeBlocks, int PxpOaXdata, int Owned);
+internal sealed record PxpOaDiscoveryEvidence(bool Found, string? GlobalName, string? GroupName, string? Flags, string? DeclaringType, string? DeclaringAssembly, string? AssemblyLocation, string? AssemblySha256, bool AssemblyLoaded, bool CommandClassIncluded, bool BundleHashMatched, int DeclarationCount);
+internal sealed record AutomationSentinelEvidence(string Stage, string? DocumentIdentity, string? DatabaseIdentity, DateTimeOffset TimestampUtc);
+internal sealed record AutomationCommandCorrelationEvidence(string EventKind, string RawCommandName, string NormalizedCommandName, bool CommandNameMatched, bool PreparedStateMatched, bool DocumentMatched, bool DatabaseMatched, bool FixturePathMatched, bool SequenceAccepted, string? RejectionReason, string? SenderType, string? SenderDocumentPath, string? ExpectedDocumentPath, string? ActiveDocumentPath, int RunCount, DateTimeOffset TimestampUtc);
+
+internal static class FirstLimitedApplyAutomationBootstrap
+{
+    private enum BootstrapState { Created, Prepared, Armed, Starting, Completed }
+    private static BootstrapState state;
+    private static bool observedIdle;
+    private static int idleCallbackCount;
+    private static int coordinatorStartCount;
+
+    internal static int IdleCallbackCount => idleCallbackCount;
+    internal static int CoordinatorStartCount => coordinatorStartCount;
+
+    // Called from Initialize: BCL gates and one lightweight subscription only.
+    internal static void Prepare()
+    {
+        if (state != BootstrapState.Created) return;
+        state = BootstrapState.Prepared;
+        AcadApplication.Idle += OnIdle;
+        RuntimeDiagnostics.Write("AutomationBootstrapSubscribed", resultStatus: "Prepared");
+    }
+
+    // Public test command is intentionally side-effect free with respect to Plant APIs.
+    internal static void Arm()
+    {
+        if (state is BootstrapState.Prepared)
+        {
+            // The command itself is the post-NETLOAD barrier. The next Idle
+            // callback, not this command callback, is allowed to start work.
+            observedIdle = true;
+            state = BootstrapState.Armed;
+        }
+    }
+
+    private static void OnIdle(object? sender, EventArgs args)
+    {
+        try
+        {
+            idleCallbackCount++;
+            RuntimeDiagnostics.Write("AutomationBootstrapIdle", resultStatus: state.ToString());
+            // The script engine can consume the custom command after NETLOAD. The
+            // first idle is therefore the explicit post-NETLOAD arming point.
+            if (state == BootstrapState.Prepared) { observedIdle = true; state = BootstrapState.Armed; }
+            if (!observedIdle || state != BootstrapState.Armed) return;
+            state = BootstrapState.Starting;
+            AcadApplication.Idle -= OnIdle;
+            coordinatorStartCount++;
+            RuntimeDiagnostics.Write("AutomationCoordinatorStarting", resultStatus: "FirstPostStartupIdle");
+            new FirstLimitedApplyAutomationCoordinator().Start();
+        }
+        catch (System.Exception exception)
+        {
+            state = BootstrapState.Completed;
+            AcadApplication.Idle -= OnIdle;
+            FirstLimitedApplyAutomationCoordinator.WriteBootstrapFailure(exception);
+        }
+    }
+}
+internal sealed record FirstApplyAutomationEvidence
+{
+    public int SchemaVersion { get; init; } = 1;
+    public required string Phase { get; init; }
+    public bool Completed { get; init; }
+    public bool? Prepared { get; init; }
+    public bool? FunctionalEvidenceCompleted { get; init; }
+    public string? ErrorCode { get; init; }
+    public int? DbmodBefore { get; init; }
+    public int? DbmodAfterCommand1 { get; init; }
+    public int? DbmodAfterCommand2 { get; init; }
+    public int? DbmodAfterUndo { get; init; }
+    public AutomationEntityCounts? Baseline { get; init; }
+    public AutomationEntityCounts? AfterCommand1 { get; init; }
+    public AutomationEntityCounts? AfterCommand2 { get; init; }
+    public AutomationEntityCounts? AfterUndo { get; init; }
+    public IReadOnlyList<string> CompletedCommands { get; init; } = Array.Empty<string>();
+    public string? PlanIdRun1 { get; init; }
+    public string? PlanIdRun2 { get; init; }
+    public bool? PlanIdsEqual { get; init; }
+    public int? EligibleCandidateCount { get; init; }
+    public string? SelectedCandidateHash { get; init; }
+    public string? ViewHash { get; init; }
+    public int? CreateRun1 { get; init; }
+    public int? CreateRun2 { get; init; }
+    public int? SkipRun2 { get; init; }
+    public string? ApplyOutcomeRun1 { get; init; }
+    public string? ApplyOutcomeRun2 { get; init; }
+    public bool? PermitAccepted { get; init; }
+    public bool? CommandsCompleted { get; init; }
+    public bool? InspectorsCompleted { get; init; }
+    public bool? EvidenceFlushed { get; init; }
+    public bool? ExitAttemptQueued { get; init; }
+    public bool? QuitCommandWillStart { get; init; }
+    public bool? QuitCommandEnded { get; init; }
+    public string? ExitFailureCode { get; init; }
+    public int? IdleCallbackCount { get; init; }
+    public int? CoordinatorStartCount { get; init; }
+    // Local test evidence only. This is intentionally never copied into Git
+    // evidence because exception stacks may contain machine-specific paths.
+    public string? ExceptionText { get; init; }
+    public string? PreviousState { get; init; }
+    public string? CurrentState { get; init; }
+    public IReadOnlyList<string> StateTransitions { get; init; } = Array.Empty<string>();
+    public PxpOaDiscoveryEvidence? PxpOaDiscovery { get; init; }
+    public IReadOnlyList<AutomationSentinelEvidence> Sentinels { get; init; } = Array.Empty<AutomationSentinelEvidence>();
+    public IReadOnlyList<string> CommandEvents { get; init; } = Array.Empty<string>();
+    public IReadOnlyList<AutomationCommandCorrelationEvidence> CommandCorrelations { get; init; } = Array.Empty<AutomationCommandCorrelationEvidence>();
+}
+
+internal sealed class FirstLimitedApplyAutomationCoordinator
+{
+    private enum CoordinatorState { Created, Starting, Running, Completed, Failed, ExitQueued }
+    private sealed record PxpResult(string? PlanId, IReadOnlyList<string> Candidates, string? View, int Create, int Skip, bool? PermitAccepted, string? ApplyOutcome);
+    private static string? selectedTargetSnapshotId;
+    private static readonly List<PxpResult> pxpResults = [];
+    internal static string? SelectedTargetSnapshotId => selectedTargetSnapshotId;
+    internal static void WriteBootstrapFailure(System.Exception exception) =>
+        RuntimeDiagnostics.Write("AutomationBootstrapFailed", "ERROR", resultStatus: "AUTOMATION_BOOTSTRAP_FAILED", exception: exception);
+    internal static void RecordPxpOa(string? planId, IReadOnlyList<string> candidates, string? view, int create, int skip, bool? permitAccepted)
+    {
+        if (string.Equals(Environment.GetEnvironmentVariable("P_REC_ANNOT_AUTOMATION"), "FirstLimitedApplyRuntimeTest", StringComparison.Ordinal))
+            pxpResults.Add(new(planId, candidates, view, create, skip, permitAccepted, null));
+    }
+    internal static void RecordApplyOutcome(PipeAnnotationWriteOutcome outcome)
+    {
+        if (!string.Equals(Environment.GetEnvironmentVariable("P_REC_ANNOT_AUTOMATION"), "FirstLimitedApplyRuntimeTest", StringComparison.Ordinal) || pxpResults.Count == 0) return;
+        var last = pxpResults[^1];
+        pxpResults[^1] = last with { ApplyOutcome = outcome.ToString() };
+    }
+    private FirstApplyAutomationConfiguration? config;
+    private Document? document;
+    private readonly List<Document> automationOpenedDocuments = [];
+    private readonly List<string> completed = [];
+    private int step;
+    private int? before, after1, after2, afterUndo;
+    private AutomationEntityCounts? baseline, counts1, counts2, countsUndo;
+    private readonly List<string> transitions = ["Created"];
+    private CoordinatorState state = CoordinatorState.Created;
+    private CoordinatorState previousState = CoordinatorState.Created;
+    private bool documentHandlersSubscribed;
+    private bool lifecycleHandlersSubscribed;
+    private bool fixtureDocumentActivated;
+    private bool projectActivationStarted;
+    private bool exitQueued;
+    private bool exitHandlerSubscribed;
+    private string? exceptionText;
+    private bool functionalCompleted;
+    private bool evidenceFlushed;
+    private bool exitAttemptQueued;
+    private string? exitFailureCode;
+
+    public void Start()
+    {
+        try
+        {
+            Transition(CoordinatorState.Starting, "PostStartupReady");
+            config = ReadConfiguration();
+            if (string.Equals(config.Phase, "LifecycleProbe", StringComparison.OrdinalIgnoreCase))
+            {
+                CompleteLifecycleProbe();
+                return;
+            }
+            if (string.IsNullOrWhiteSpace(config.OrthoDrawingPath)) throw new InvalidOperationException("AUTOMATION_ORTHO_PATH_REQUIRED");
+            // A first startup Idle is sufficient to arm automation, but not to
+            // call Plant APIs. Establish an AutoCAD document first and wait for
+            // its activation plus a quiescent callback before project activation.
+            AcadApplication.DocumentManager.DocumentActivated += OnDocumentActivated;
+            AcadApplication.Idle += OnIdle;
+            lifecycleHandlersSubscribed = true;
+            if (!string.IsNullOrWhiteSpace(config.ModelDrawingPath)) automationOpenedDocuments.Add(AcadApplication.DocumentManager.Open(config.ModelDrawingPath, false));
+            transitions.Add("DocumentOpenStarted");
+            RuntimeDiagnostics.Write("AutomationBeforeDocumentOpen", resultStatus: "PostStartupReady");
+            document = AcadApplication.DocumentManager.Open(config.OrthoDrawingPath, false);
+            automationOpenedDocuments.Add(document);
+            AcadApplication.DocumentManager.MdiActiveDocument = document;
+            transitions.Add("DocumentOpened");
+            RuntimeDiagnostics.Write("AutomationAfterDocumentOpen", resultStatus: "WaitingForDocumentActivation", document: document);
+            document.CommandEnded += OnCommandEnded;
+            document.CommandFailed += OnCommandFailed;
+            document.CommandCancelled += OnCommandCancelled;
+            documentHandlersSubscribed = true;
+            Transition(CoordinatorState.Running, "AutomationRunning");
+            // DocumentActivated can be raised synchronously by Open before the
+            // coordinator receives the returned Document. Confirm the current
+            // active document after assignment so that one missed event cannot
+            // strand the workflow waiting for another startup Idle.
+            // Open was requested for this exact local fixture and it has just
+            // been made MDI-active. Queue a no-op public command regardless of
+            // wrapper identity/name normalisation; CommandEnded is the actual
+            // readiness proof before any Plant API is used.
+            fixtureDocumentActivated = true;
+            transitions.Add("FixtureDocumentActiveAfterOpen");
+            QueueReadinessBarrier();
+        }
+        catch (System.Exception ex) { FailFromCallback("Start", ex, "AUTOMATION_START_FAILED"); }
+    }
+
+    private void CompleteLifecycleProbe()
+    {
+        transitions.Add("LifecycleProbeCompleted");
+        WriteEvidence(true, null);
+        // LifecycleProbe is already running from the first verified Idle callback.
+        // Do not wait for a second Idle: a startup-script host is permitted not to
+        // raise one, which otherwise leaves acad.exe responsive but stranded.
+        RequestControlledExit(idleSafe: true);
+    }
+
+    private void OnIdle(object? sender, EventArgs e) => RunCallback("Idle", TryActivateProjectAndVerifyContext);
+    private void OnDocumentActivated(object sender, DocumentCollectionEventArgs e)
+    {
+        RunCallback("DocumentActivated", () =>
+        {
+            if (document is null || e.Document is null) return;
+            if (!string.Equals(e.Document.Name, document.Name, StringComparison.OrdinalIgnoreCase)) return;
+            fixtureDocumentActivated = true;
+            transitions.Add("FixtureDocumentActivated");
+            TryActivateProjectAndVerifyContext();
+        });
+    }
+    private void TryActivateProjectAndVerifyContext()
+    {
+        if (IsTerminal || document is null || !fixtureDocumentActivated || projectActivationStarted) return;
+        if (!AcadApplication.IsQuiescent) return;
+        projectActivationStarted = true;
+        AcadApplication.Idle -= OnIdle;
+        AcadApplication.DocumentManager.DocumentActivated -= OnDocumentActivated;
+        lifecycleHandlersSubscribed = false;
+        try
+        {
+            transitions.Add("ProjectActivationStarted");
+            RuntimeDiagnostics.Write("AutomationBeforeProjectActivation", resultStatus: "DocumentActivatedAndQuiescent", document: document);
+            var projectXml = Path.Combine(Path.GetDirectoryName(config!.FixtureMarkerPath)!, "Project.xml");
+            var project = PlantProject.LoadProject(projectXml, false, string.Empty, string.Empty);
+            PlantApplication.SetCurrentProject(project, true);
+            transitions.Add("ProjectActivated");
+            RuntimeDiagnostics.Write("AutomationAfterProjectActivation", resultStatus: "ProjectAvailable", document: document);
+            transitions.Add("ContextVerificationStarted");
+            var context = new PlantRuntimeContextReader().ReadCurrentContext(document);
+            if (!context.HasPlantProject || !context.IsOrthoDrawing || context.Viewports.Count != 1) { Complete(false, $"AUTOMATION_ORTHO_CONTEXT_INVALID:P={context.HasPlantProject};O={context.IsOrthoDrawing};V={context.Viewports.Count}"); return; }
+            var candidates = new PlantObjectReader().ReadObjects(context.Viewports.Single(), CancellationToken.None)
+                .Where(x => string.Equals(x.ObjectClass, "Pipe", StringComparison.OrdinalIgnoreCase) && x.MembershipStatus == ViewMembershipStatus.Resolved && x.Geometry.PaperPosition is not null)
+                .Select(x => x.SnapshotId).OrderBy(x => x, StringComparer.Ordinal).ToArray();
+            if (candidates.Length == 0) { Complete(false, "AUTOMATION_NO_ELIGIBLE_CANDIDATE"); return; }
+            selectedTargetSnapshotId = candidates[0];
+            transitions.Add("ContextVerified");
+            before = Dbmod(); baseline = Counts();
+            Queue("PXP-OA");
+        }
+        catch (System.Exception ex) { FailFromCallback("ContextVerification", ex, "AUTOMATION_CONTEXT_FAILED"); }
+    }
+
+    private void Queue(string command) => _ = DispatchCommandAsync(command, false);
+    private void QueueReadinessBarrier()
+    {
+        _ = DispatchCommandAsync("PHP_REC_AUTOMATION_READY", true);
+    }
+    private async Task DispatchCommandAsync(string command, bool readiness)
+    {
+        if (IsTerminal || document is null) return;
+        var expected = document;
+        transitions.Add(readiness ? "ReadinessCommandDispatchRequested" : "CommandDispatchRequested:" + command);
+        try
+        {
+            await AcadApplication.DocumentManager.ExecuteInCommandContextAsync(async _ =>
+            {
+                transitions.Add("CommandContextEntered:" + command);
+                var active = AcadApplication.DocumentManager.MdiActiveDocument;
+                if (active is null || !string.Equals(active.Name, expected.Name, StringComparison.OrdinalIgnoreCase))
+                    throw new InvalidOperationException("AUTOMATION_COMMAND_DOCUMENT_NOT_ACTIVE");
+                transitions.Add(readiness ? "ReadinessBarrierQueued" : "CommandQueued:" + command);
+                await active.Editor.CommandAsync(command);
+                transitions.Add("CommandInvocationReturned:" + command);
+            }, null);
+        }
+        catch (System.Exception exception) { FailFromCallback("CommandDispatcher", exception, "AUTOMATION_COMMAND_CONTEXT_FAILED"); }
+    }
+    private void OnCommandEnded(object sender, CommandEventArgs e)
+    {
+        RunCallback("CommandEnded", () =>
+        {
+            var name = e.GlobalCommandName?.Trim().TrimStart('.', '_').ToUpperInvariant();
+            if (name == "PHP_REC_AUTOMATION_READY")
+            {
+                transitions.Add("ReadinessBarrierCompleted");
+                TryActivateProjectAndVerifyContext();
+                return;
+            }
+            if (name is not ("PXP-OA" or "UNDO" or "U")) return;
+            completed.Add(name);
+            transitions.Add("CommandCompleted:" + name);
+            if (step++ == 0) { after1 = Dbmod(); counts1 = Counts(); Queue("PXP-OA"); return; }
+            if (step == 2 && string.Equals(config?.Phase, "Apply", StringComparison.OrdinalIgnoreCase)) { after2 = Dbmod(); counts2 = Counts(); Queue("_.UNDO _1"); return; }
+            if (string.Equals(config?.Phase, "Apply", StringComparison.OrdinalIgnoreCase)) { afterUndo = Dbmod(); countsUndo = Counts(); Complete(true, null, safeToExitNow: true); }
+            else { after2 = Dbmod(); counts2 = Counts(); Complete(true, null, safeToExitNow: true); }
+        });
+    }
+    private void OnCommandFailed(object sender, CommandEventArgs e) => RunCallback("CommandFailed", () => Complete(false, "AUTOMATION_COMMAND_FAILED:" + e.GlobalCommandName));
+    private void OnCommandCancelled(object sender, CommandEventArgs e) => RunCallback("CommandCancelled", () => Complete(false, "AUTOMATION_COMMAND_CANCELLED:" + e.GlobalCommandName));
+
+    private int Dbmod() => Convert.ToInt32(AcadApplication.GetSystemVariable("DBMOD"));
+    private AutomationEntityCounts Counts()
+    {
+        if (document is null) throw new InvalidOperationException("AUTOMATION_DOCUMENT_UNAVAILABLE");
+        using var tx = document.Database.TransactionManager.StartOpenCloseTransaction();
+        var table = (BlockTable)tx.GetObject(document.Database.BlockTableId, OpenMode.ForRead);
+        var paper = (BlockTableRecord)tx.GetObject(table[BlockTableRecord.PaperSpace], OpenMode.ForRead);
+        var total = 0; var pipes = 0; var xdata = 0; var owned = 0;
+        foreach (ObjectId id in paper)
+        {
+            total++;
+            if (tx.GetObject(id, OpenMode.ForRead) is BlockReference block && string.Equals(block.Name, "PIPE", StringComparison.OrdinalIgnoreCase)) pipes++;
+            if (tx.GetObject(id, OpenMode.ForRead) is Entity entity)
+            {
+                using var data = entity.GetXDataForApplication("PXP-OA");
+                if (data is not null) { xdata++; if (data.AsArray().Any(x => x.TypeCode == 1000)) owned++; }
+            }
+        }
+        return new(total, pipes, xdata, owned);
+    }
+    private FirstApplyAutomationConfiguration ReadConfiguration()
+    {
+        if (!string.Equals(Environment.GetEnvironmentVariable("P_REC_ANNOT_AUTOMATION"), "FirstLimitedApplyRuntimeTest", StringComparison.Ordinal)) throw new InvalidOperationException("AUTOMATION_DISABLED");
+        if (!string.Equals(RuntimeDiagnostics.RuntimeMode, "DryRun", StringComparison.OrdinalIgnoreCase) && !string.Equals(RuntimeDiagnostics.RuntimeMode, "Apply", StringComparison.OrdinalIgnoreCase)) throw new InvalidOperationException("AUTOMATION_MODE_BLOCKED");
+        var path = Environment.GetEnvironmentVariable("P_REC_ANNOT_AUTOMATION_CONFIG");
+        if (string.IsNullOrWhiteSpace(path) || !Path.IsPathFullyQualified(path) || path.StartsWith("\\\\", StringComparison.Ordinal)) throw new InvalidOperationException("AUTOMATION_CONFIGURATION_REQUIRED");
+        var loaded = JsonSerializer.Deserialize<FirstApplyAutomationConfiguration>(File.ReadAllText(path), new JsonSerializerOptions { PropertyNameCaseInsensitive = true }) ?? throw new InvalidOperationException("AUTOMATION_CONFIGURATION_INVALID");
+        if (!File.Exists(loaded.FixtureMarkerPath) || !string.Equals(File.ReadAllText(loaded.FixtureMarkerPath).Trim(), "P_REC_ANNOT_TEST_FIXTURE=FIRST_LIMITED_APPLY", StringComparison.Ordinal)) throw new InvalidOperationException("AUTOMATION_FIXTURE_MARKER_INVALID");
+        if (!string.Equals(loaded.Phase, "LifecycleProbe", StringComparison.OrdinalIgnoreCase) &&
+            (string.IsNullOrWhiteSpace(loaded.OrthoDrawingPath) || !Path.GetFullPath(loaded.OrthoDrawingPath).StartsWith(Path.GetDirectoryName(Path.GetFullPath(loaded.FixtureMarkerPath))! + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase)))
+            throw new InvalidOperationException("AUTOMATION_FIXTURE_OUTSIDE_MARKER_ROOT");
+        return loaded;
+    }
+    private void Complete(bool success, string? error, bool safeToExitNow = false)
+    {
+        if (IsTerminal) return;
+        functionalCompleted = success;
+        Transition(success ? CoordinatorState.Completed : CoordinatorState.Failed, success ? "Completed" : "Failed");
+        UnsubscribeHandlers();
+        TryWriteEvidence(success, error);
+        selectedTargetSnapshotId = null;
+        pxpResults.Clear();
+        RequestControlledExit(safeToExitNow);
+    }
+
+    // The managed Application.Quit call can leave a startup-script host alive
+    // when it is invoked from a CommandEnded callback. Queue AutoCAD's native
+    // QUIT command instead; the command processor runs it after the current
+    // public PXP-OA command has fully returned and discards every open drawing.
+    private void RequestControlledExit(bool idleSafe = false)
+    {
+        if (exitQueued) return;
+        exitQueued = true;
+        Transition(CoordinatorState.ExitQueued, "ExitQueued");
+        if (idleSafe)
+        {
+            DispatchNativeQuit();
+            return;
+        }
+        AcadApplication.Idle += OnExitIdle;
+        exitHandlerSubscribed = true;
+    }
+
+    private void OnExitIdle(object? sender, EventArgs args)
+    {
+        RunCallback("ControlledExitIdle", DispatchNativeQuit);
+    }
+
+    private void DispatchNativeQuit()
+    {
+        try
+        {
+            if (exitHandlerSubscribed) AcadApplication.Idle -= OnExitIdle;
+            exitHandlerSubscribed = false;
+            exitAttemptQueued = true;
+            if (!AcadApplication.IsQuiescent)
+            {
+                transitions.Add("QuitDispatchDeferredNotQuiescent");
+                TryWriteEvidence(functionalCompleted, null);
+                return;
+            }
+            // LifecycleProbe opens no fixture document, but the real startup
+            // document is available at this point (observed as Drawing1.dwg).
+            // Use that live document only to queue native QUIT; never retain it
+            // past this callback or use it for fixture/Plant work.
+            var exitDocument = AcadApplication.DocumentManager.MdiActiveDocument;
+            if (exitDocument is null)
+            {
+                exitFailureCode = "AUTOMATION_EXIT_DOCUMENT_UNAVAILABLE";
+                transitions.Add("QuitDispatchSkippedNoLiveDocument");
+                TryWriteEvidence(functionalCompleted, null);
+                return;
+            }
+            transitions.Add("QuitDispatchAttempted");
+            // Persist the exit boundary before handing control back to AutoCAD;
+            // process termination can otherwise prevent the final evidence flush.
+            TryWriteEvidence(functionalCompleted, null);
+            exitDocument.SendStringToExecute("_.QUIT _N\n", true, true, false);
+            document = null;
+            automationOpenedDocuments.Clear();
+        }
+        catch (System.Exception exception)
+        {
+            // This is terminal cleanup: contain the exception and leave process
+            // cleanup to Launcher rather than re-entering document APIs.
+            // A failed graceful-exit dispatch is not a failure of already
+            // completed PXP-OA/UNDO work. Launcher owns bounded forced cleanup.
+            exitFailureCode = "AUTOMATION_CONTROLLED_EXIT_FAILED:" + exception.GetType().Name;
+            transitions.Add("QuitDispatchFailed");
+            TryWriteEvidence(functionalCompleted, null);
+        }
+    }
+
+    private bool IsTerminal => state is CoordinatorState.Completed or CoordinatorState.Failed or CoordinatorState.ExitQueued;
+
+    private void Transition(CoordinatorState next, string transition)
+    {
+        previousState = state;
+        state = next;
+        transitions.Add(transition);
+    }
+
+    private void RunCallback(string callback, Action action)
+    {
+        if (IsTerminal && callback != "ControlledExitIdle") return;
+        try { action(); }
+        catch (System.Exception exception) { FailFromCallback(callback, exception, "AUTOMATION_CALLBACK_FAILED"); }
+    }
+
+    private void FailFromCallback(string callback, System.Exception exception, string code)
+    {
+        exceptionText = exception.ToString();
+        RuntimeDiagnostics.Write("AutomationCallbackFailed", "ERROR", resultStatus: code + ":" + callback, exception: exception);
+        if (!IsTerminal) Complete(false, code + ":" + callback + ":" + exception.GetType().Name);
+        else
+        {
+            UnsubscribeHandlers();
+            if (functionalCompleted)
+            {
+                exitFailureCode = code + ":" + callback + ":" + exception.GetType().Name;
+                transitions.Add("ExitCallbackFailed");
+                TryWriteEvidence(true, null);
+            }
+            else TryWriteEvidence(false, code + ":" + callback + ":" + exception.GetType().Name);
+        }
+    }
+
+    private void UnsubscribeHandlers()
+    {
+        if (documentHandlersSubscribed && document is not null)
+        {
+            try { document.CommandEnded -= OnCommandEnded; document.CommandFailed -= OnCommandFailed; document.CommandCancelled -= OnCommandCancelled; }
+            catch (System.Exception exception) { RuntimeDiagnostics.Write("AutomationHandlerUnsubscribeFailed", "ERROR", resultStatus: "AUTOMATION_UNSUBSCRIBE_FAILED", exception: exception); }
+        }
+        documentHandlersSubscribed = false;
+        if (lifecycleHandlersSubscribed)
+        {
+            try { AcadApplication.DocumentManager.DocumentActivated -= OnDocumentActivated; AcadApplication.Idle -= OnIdle; }
+            catch (System.Exception exception) { RuntimeDiagnostics.Write("AutomationHandlerUnsubscribeFailed", "ERROR", resultStatus: "AUTOMATION_UNSUBSCRIBE_FAILED", exception: exception); }
+        }
+        lifecycleHandlersSubscribed = false;
+    }
+
+    private bool TryWriteEvidence(bool success, string? error)
+    {
+        try { evidenceFlushed = true; WriteEvidence(success, error); return true; }
+        catch (System.Exception exception) { evidenceFlushed = false; RuntimeDiagnostics.Write("AutomationEvidenceWriteFailed", "ERROR", resultStatus: "AUTOMATION_EVIDENCE_WRITE_FAILED", exception: exception); return false; }
+    }
+
+    private void WriteEvidence(bool success, string? error)
+    {
+        if (config is null) return;
+        var first = pxpResults.ElementAtOrDefault(0); var second = pxpResults.ElementAtOrDefault(1);
+        var expectedCommands = string.Equals(config.Phase, "Apply", StringComparison.OrdinalIgnoreCase) ? 3 : 2;
+        var evidence = new FirstApplyAutomationEvidence { Phase = config.Phase, Completed = success, ErrorCode = error, DbmodBefore = before, DbmodAfterCommand1 = after1, DbmodAfterCommand2 = after2, DbmodAfterUndo = afterUndo, Baseline = baseline, AfterCommand1 = counts1, AfterCommand2 = counts2, AfterUndo = countsUndo, CompletedCommands = completed, PlanIdRun1 = first?.PlanId, PlanIdRun2 = second?.PlanId, PlanIdsEqual = first is not null && second is not null ? string.Equals(first.PlanId, second.PlanId, StringComparison.Ordinal) : null, EligibleCandidateCount = first?.Candidates.Count, SelectedCandidateHash = selectedTargetSnapshotId, ViewHash = first?.View, CreateRun1 = first?.Create, CreateRun2 = second?.Create, SkipRun2 = second?.Skip, ApplyOutcomeRun1 = first?.ApplyOutcome, ApplyOutcomeRun2 = second?.ApplyOutcome, PermitAccepted = first?.PermitAccepted, CommandsCompleted = completed.Count >= expectedCommands, InspectorsCompleted = baseline is not null && counts1 is not null && counts2 is not null && (!string.Equals(config.Phase, "Apply", StringComparison.OrdinalIgnoreCase) || countsUndo is not null), EvidenceFlushed = evidenceFlushed, ExitAttemptQueued = exitAttemptQueued, ExitFailureCode = exitFailureCode, IdleCallbackCount = FirstLimitedApplyAutomationBootstrap.IdleCallbackCount, CoordinatorStartCount = FirstLimitedApplyAutomationBootstrap.CoordinatorStartCount, ExceptionText = exceptionText, PreviousState = previousState.ToString(), CurrentState = state.ToString(), StateTransitions = transitions };
+        Directory.CreateDirectory(Path.GetDirectoryName(config.EvidencePath)!);
+        File.WriteAllText(config.EvidencePath, JsonSerializer.Serialize(evidence));
+    }
+}
@@ -0,0 +1,140 @@
+using System.Text.Json;
+using Autodesk.AutoCAD.ApplicationServices;
+using Autodesk.AutoCAD.DatabaseServices;
+using Autodesk.AutoCAD.Geometry;
+using PRecAnnot.Abstractions;
+
+namespace PRecAnnot.Plant3D2026;
+
+// This file is deliberately runtime-only.  Core receives only the anonymised
+// permit and canonical operation; no AutoCAD handle, database or project path
+// crosses the adapter boundary.
+internal sealed record FirstLimitedApplyRuntimePermit
+{
+    public required bool AllowApply { get; init; }
+    public required string FixtureMarkerPath { get; init; }
+    public required string TargetSnapshotId { get; init; }
+    public required string ExpectedPlanId { get; init; }
+    public required string VisibilityState { get; init; }
+    // Test-only local copy of the legacy v1.0.4 Template.dwg. The package
+    // deliberately carries no DWG assets; the per-run permit binds this source.
+    public required string AnnotationTemplateDwgPath { get; init; }
+}
+
+internal static class FirstLimitedApplyPermitReader
+{
+    private const string MarkerContent = "P_REC_ANNOT_TEST_FIXTURE=FIRST_LIMITED_APPLY";
+
+    public static FirstLimitedApplyRuntimePermit ReadFor(Document document)
+    {
+        var path = Environment.GetEnvironmentVariable("P_REC_ANNOT_APPLY_PERMIT_PATH");
+        if (string.IsNullOrWhiteSpace(path) || !Path.IsPathFullyQualified(path) || path.StartsWith("\\\\", StringComparison.Ordinal))
+            throw new InvalidOperationException("APPLY_PERMIT_PATH_REQUIRED");
+        if (!File.Exists(path)) throw new InvalidOperationException("APPLY_PERMIT_MISSING");
+
+        var permit = JsonSerializer.Deserialize<FirstLimitedApplyRuntimePermit>(File.ReadAllText(path), new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
+        if (permit is null || !permit.AllowApply || string.IsNullOrWhiteSpace(permit.TargetSnapshotId) || string.IsNullOrWhiteSpace(permit.ExpectedPlanId) || string.IsNullOrWhiteSpace(permit.VisibilityState))
+            throw new InvalidOperationException("APPLY_TEST_FIXTURE_OR_PERMIT_REQUIRED");
+        if (!Path.IsPathFullyQualified(permit.FixtureMarkerPath) || permit.FixtureMarkerPath.StartsWith("\\\\", StringComparison.Ordinal) || !File.Exists(permit.FixtureMarkerPath))
+            throw new InvalidOperationException("APPLY_TEST_FIXTURE_OR_PERMIT_REQUIRED");
+        if (!string.Equals(File.ReadAllText(permit.FixtureMarkerPath).Trim(), MarkerContent, StringComparison.Ordinal))
+            throw new InvalidOperationException("APPLY_TEST_FIXTURE_OR_PERMIT_REQUIRED");
+
+        var root = Path.GetDirectoryName(Path.GetFullPath(permit.FixtureMarkerPath))!;
+        var drawing = Path.GetFullPath(document.Name);
+        if (!drawing.StartsWith(root + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
+            throw new InvalidOperationException("APPLY_TEST_FIXTURE_OR_PERMIT_REQUIRED");
+        if (string.IsNullOrWhiteSpace(permit.AnnotationTemplateDwgPath) || !Path.IsPathFullyQualified(permit.AnnotationTemplateDwgPath) || permit.AnnotationTemplateDwgPath.StartsWith("\\\\", StringComparison.Ordinal) || !File.Exists(permit.AnnotationTemplateDwgPath))
+            throw new InvalidOperationException("ANNOTATION_TEMPLATE_ASSET_REQUIRED");
+        return permit;
+    }
+}
+
+internal enum PipeAnnotationWriteOutcome { Created, AlreadyExists }
+
+internal sealed class FirstLimitedPipeAnnotationWriter
+{
+    private const string BlockName = "PIPE";
+    private const string XdataApplication = "PXP-OA";
+
+    public PipeAnnotationWriteOutcome Write(Document document, CreatePipeAnnotationOperation operation, string visibilityState, string annotationTemplateDwgPath)
+    {
+        var database = document.Database;
+        using var transaction = database.TransactionManager.StartTransaction();
+        var table = (BlockTable)transaction.GetObject(database.BlockTableId, OpenMode.ForRead);
+        var blockId = EnsureLegacyPipeBlock(transaction, database, table, annotationTemplateDwgPath);
+
+        var paper = (BlockTableRecord)transaction.GetObject(table[BlockTableRecord.PaperSpace], OpenMode.ForWrite);
+        if (HasOwnedAnnotation(transaction, paper, operation.DuplicateKey)) return PipeAnnotationWriteOutcome.AlreadyExists;
+        EnsureRegApp(transaction, database);
+
+        using var annotation = new BlockReference(
+            new Point3d(operation.Placement.X, operation.Placement.Y, operation.Placement.Z),
+            blockId);
+        paper.AppendEntity(annotation);
+        transaction.AddNewlyCreatedDBObject(annotation, true);
+        SetConfirmedVisibility(annotation, visibilityState);
+        annotation.XData = new ResultBuffer(
+            new TypedValue((int)DxfCode.ExtendedDataRegAppName, XdataApplication),
+            new TypedValue((int)DxfCode.ExtendedDataAsciiString, operation.DuplicateKey),
+            new TypedValue((int)DxfCode.ExtendedDataAsciiString, operation.RuleId));
+        transaction.Commit();
+        return PipeAnnotationWriteOutcome.Created;
+    }
+
+    private static ObjectId EnsureLegacyPipeBlock(Transaction destinationTransaction, Database destination, BlockTable destinationTable, string templatePath)
+    {
+        if (destinationTable.Has(BlockName)) return destinationTable[BlockName];
+        if (!File.Exists(templatePath)) throw new InvalidOperationException("ANNOTATION_TEMPLATE_ASSET_MISSING");
+
+        using var source = new Database(false, true);
+        source.ReadDwgFile(templatePath, FileShare.Read, true, string.Empty);
+        source.CloseInput(true);
+        using var sourceTransaction = source.TransactionManager.StartTransaction();
+        var sourceTable = (BlockTable)sourceTransaction.GetObject(source.BlockTableId, OpenMode.ForRead);
+        if (!sourceTable.Has(BlockName)) throw new InvalidOperationException("ANNOTATION_TEMPLATE_PIPE_BLOCK_MISSING");
+        using var sourceIds = new ObjectIdCollection { sourceTable[BlockName] };
+        using var mapping = new IdMapping();
+        destination.WblockCloneObjects(sourceIds, destination.BlockTableId, mapping, DuplicateRecordCloning.Ignore, false);
+        sourceTransaction.Commit();
+
+        var refreshed = (BlockTable)destinationTransaction.GetObject(destination.BlockTableId, OpenMode.ForRead);
+        if (!refreshed.Has(BlockName)) throw new InvalidOperationException("ANNOTATION_TEMPLATE_BLOCK_IMPORT_FAILED");
+        return refreshed[BlockName];
+    }
+
+    private static bool HasOwnedAnnotation(Transaction transaction, BlockTableRecord paper, string duplicateKey)
+    {
+        foreach (ObjectId id in paper)
+        {
+            if (transaction.GetObject(id, OpenMode.ForRead) is not BlockReference reference) continue;
+            using var xdata = reference.GetXDataForApplication(XdataApplication);
+            if (xdata?.AsArray().Any(value => value.TypeCode == (int)DxfCode.ExtendedDataAsciiString && string.Equals(value.Value as string, duplicateKey, StringComparison.Ordinal)) == true)
+                return true;
+        }
+        return false;
+    }
+
+    private static void EnsureRegApp(Transaction transaction, Database database)
+    {
+        var apps = (RegAppTable)transaction.GetObject(database.RegAppTableId, OpenMode.ForRead);
+        if (apps.Has(XdataApplication)) return;
+        apps.UpgradeOpen();
+        using var record = new RegAppTableRecord { Name = XdataApplication };
+        apps.Add(record);
+        transaction.AddNewlyCreatedDBObject(record, true);
+    }
+
+    // The "V" property and allowed values are the confirmed legacy PXP-OA
+    // dynamic-block contract.  Failure is pre-commit and leaves no entity.
+    private static void SetConfirmedVisibility(BlockReference annotation, string visibilityState)
+    {
+        var property = annotation.DynamicBlockReferencePropertyCollection
+            .Cast<DynamicBlockReferenceProperty>()
+            .SingleOrDefault(value => string.Equals(value.PropertyName, "V", StringComparison.Ordinal));
+        var allowed = property?.GetAllowedValues().OfType<string>().ToArray() ?? [];
+        if (property is null || !allowed.Contains(visibilityState, StringComparer.Ordinal))
+            throw new InvalidOperationException($"ANNOTATION_VISIBILITY_STATE_UNSUPPORTED:Allowed={string.Join('|', allowed)}");
+        property.Value = visibilityState;
+    }
+}
@@ -0,0 +1,81 @@
+using System.Collections;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Text;
+using Autodesk.ProcessPower.Drawings2d;
+
+namespace PRecAnnot.Plant3D2026;
+
+// This is a diagnostic-only probe. It is never part of source resolution and is
+// called only by the explicit DryRun/OrthoStructure environment flag combination.
+internal static class OrthoRuntimeStructureInspector
+{
+    public static void Inspect(IDwgViewDef view)
+    {
+        if (!RuntimeDiagnostics.IsOrthoStructureDiagnosticsEnabled) return;
+
+        try
+        {
+            var query = view.DwgQuery;
+            var modelFiles = query?.ModelFiles;
+            var details = new Dictionary<string, object?>
+            {
+                ["ViewRuntimeType"] = TypeName(view.GetType()),
+                ["DwgQueryRuntimeType"] = query is null ? null : TypeName(query.GetType()),
+                ["ModelFilesDeclaredType"] = typeof(ModelFile[]).FullName,
+                ["ModelFilesRuntimeType"] = modelFiles?.GetType().AssemblyQualifiedName,
+                ["ModelFilesCount"] = modelFiles?.Length ?? 0,
+                ["ModelFileElements"] = modelFiles?.Select(DescribeModelFile).ToArray() ?? Array.Empty<IReadOnlyDictionary<string, object?>>()
+            };
+            RuntimeDiagnostics.Write("OrthoRuntimeStructureInspected", resultStatus: "Captured", details: details);
+        }
+        catch (Exception exception)
+        {
+            RuntimeDiagnostics.Write("OrthoRuntimeStructureInspectionFailed", "WARNING", resultStatus: "Failed", exception: exception);
+        }
+    }
+
+    private static IReadOnlyDictionary<string, object?> DescribeModelFile(ModelFile? modelFile)
+    {
+        if (modelFile is null)
+        {
+            return new Dictionary<string, object?> { ["IsNull"] = true };
+        }
+
+        var properties = modelFile.GetType()
+            .GetProperties(BindingFlags.Instance | BindingFlags.Public)
+            .Where(property => property.CanRead && property.GetIndexParameters().Length == 0)
+            .OrderBy(property => property.Name, StringComparer.Ordinal)
+            .Select(property => DescribeProperty(modelFile, property))
+            .ToArray();
+        return new Dictionary<string, object?>
+        {
+            ["RuntimeType"] = TypeName(modelFile.GetType()),
+            ["Properties"] = properties
+        };
+    }
+
+    private static IReadOnlyDictionary<string, object?> DescribeProperty(ModelFile modelFile, PropertyInfo property)
+    {
+        object? value;
+        try { value = property.GetValue(modelFile); }
+        catch { value = null; }
+        return new Dictionary<string, object?>
+        {
+            ["PropertyName"] = property.Name,
+            ["PropertyType"] = property.PropertyType.FullName,
+            ["ValueKind"] = value?.GetType().FullName ?? "null",
+            ["IsNull"] = value is null,
+            ["StringLength"] = value is string text ? text.Length : null,
+            ["PathKind"] = property.Name == "ModelFileName" && value is string path
+                ? (Path.IsPathRooted(path) ? "Absolute" : "ProjectRelative")
+                : null,
+            ["CollectionCount"] = value is ICollection collection ? collection.Count : null,
+            ["StableHash"] = value is null ? null : Hash(value.ToString() ?? string.Empty)
+        };
+    }
+
+    private static string TypeName(Type type) => $"{type.FullName}, {type.Assembly.GetName().Name}, {type.Assembly.GetName().Version}";
+
+    private static string Hash(string value) => Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(value)))[..16];
+}
@@ -14,7 +14,9 @@
    <Reference Include="PnPDataObjects"><HintPath>$(AutoCAD2026ManagedDir)\PnPDataObjects.dll</HintPath><Private>false</Private><CopyLocal>false</CopyLocal></Reference>
    <Reference Include="PnPProjectManagerMgd"><HintPath>$(Plant3D2026ManagedDir)\PnPProjectManagerMgd.dll</HintPath><Private>false</Private><CopyLocal>false</CopyLocal></Reference>
    <Reference Include="PnP3dObjectsMgd"><HintPath>$(Plant3D2026ManagedDir)\PnP3dObjectsMgd.dll</HintPath><Private>false</Private><CopyLocal>false</CopyLocal></Reference>
+    <Reference Include="PnP3dProjectPartsMgd"><HintPath>$(Plant3D2026ManagedDir)\PnP3dProjectPartsMgd.dll</HintPath><Private>false</Private><CopyLocal>false</CopyLocal></Reference>
    <Reference Include="PnP3dOrthoProjectPart"><HintPath>$(Plant3D2026ManagedDir)\PnP3dOrthoProjectPart.dll</HintPath><Private>false</Private><CopyLocal>false</CopyLocal></Reference>
    <Reference Include="PnPDwg2dDef"><HintPath>$(Plant3D2026ManagedDir)\PnPDwg2dDef.dll</HintPath><Private>false</Private><CopyLocal>false</CopyLocal></Reference>
+    <Reference Include="PnPDwg2dUtil"><HintPath>$(Plant3D2026ManagedDir)\PnPDwg2dUtil.dll</HintPath><Private>false</Private><CopyLocal>false</CopyLocal></Reference>
  </ItemGroup>
 </Project>
@@ -1,7 +1,11 @@
 using System.Security.Cryptography;
+using System.Collections.Specialized;
 using System.Text;
 using Autodesk.AutoCAD.ApplicationServices;
+using Autodesk.AutoCAD.DatabaseServices;
 using Autodesk.ProcessPower.DataLinks;
+using Autodesk.ProcessPower.Drawings2d;
+using Autodesk.ProcessPower.PnP3dObjects;
 using Autodesk.ProcessPower.P3dProjectParts;
 using Autodesk.ProcessPower.PlantInstance;
 using Autodesk.ProcessPower.ProjectManager;
@@ -12,9 +16,11 @@ namespace PRecAnnot.Plant3D2026;

 internal sealed class PlantRuntimeContextReader : IPlantRuntimeContextReader
 {
-    public PlantRuntimeContext ReadCurrentContext()
+    public PlantRuntimeContext ReadCurrentContext() => ReadCurrentContext(null);
+
+    public PlantRuntimeContext ReadCurrentContext(Document? explicitDocument = null)
    {
-        var document = AcadApplication.DocumentManager.MdiActiveDocument;
+        var document = explicitDocument ?? AcadApplication.DocumentManager.MdiActiveDocument;
        if (document is null)
        {
            return Empty(false, false, "NO_ACTIVE_DOCUMENT", "Активный документ отсутствует.");
@@ -32,6 +38,9 @@ internal sealed class PlantRuntimeContextReader : IPlantRuntimeContextReader
            return Empty(true, false, "NO_PLANT_PROJECT", "Активный Plant 3D-проект не найден.");
        }

+        var displayName = string.IsNullOrWhiteSpace(project.Name) ? null : project.Name.Trim();
+        var projectStatus = displayName is null ? PlantProjectDetectionStatus.FoundWithoutDisplayName : PlantProjectDetectionStatus.FoundWithName;
+
        OrthoProject? orthoProject;
        try { orthoProject = PlantApplication.ProjectPart("Ortho") as OrthoProject; }
        catch (Exception exception)
@@ -60,9 +69,10 @@ internal sealed class PlantRuntimeContextReader : IPlantRuntimeContextReader
                HasPlantProject = true,
                IsOrthoDrawing = true,
                DrawingName = Path.GetFileName(document.Name),
-                ProjectDisplayName = project.Name,
+                ProjectDisplayName = displayName ?? "display name unavailable",
+                ProjectDetectionStatus = projectStatus,
                Viewports = viewports,
-                Diagnostics = Array.Empty<RuntimeDiagnostic>(),
+                Diagnostics = displayName is null ? new[] { new RuntimeDiagnostic { Code = "PLANT_PROJECT_DISPLAY_NAME_EMPTY", Message = "Plant project is open but no display name is available.", Severity = "Warning" } } : Array.Empty<RuntimeDiagnostic>(),
                Detection = new OrthoDetectionResult
                {
                    Status = OrthoDetectionStatus.Confirmed,
@@ -82,6 +92,8 @@ internal sealed class PlantRuntimeContextReader : IPlantRuntimeContextReader
        HasActiveDocument = hasDocument,
        HasPlantProject = hasProject,
        IsOrthoDrawing = false,
+        ProjectDisplayName = hasProject ? "display name unavailable" : null,
+        ProjectDetectionStatus = hasProject ? PlantProjectDetectionStatus.Ambiguous : PlantProjectDetectionStatus.NotFound,
        Diagnostics = new[] { new RuntimeDiagnostic { Code = code, Message = message } },
        Detection = new OrthoDetectionResult { Status = status, Evidence = evidence, Diagnostics = new[] { new RuntimeDiagnostic { Code = code, Message = message } } }
    };
@@ -124,7 +136,7 @@ internal sealed class PlantOrthoViewportReader : IOrthoViewportReader
                        TwistAngle = 0,
                        IsOn = true,
                        IsLocked = false,
-                        SourceDrawingName = sheet.DwgName,
+                        SourceDrawingName = ReadSourceDrawingPath(view),
                        ViewName = view.ViewName
                    });
                }
@@ -143,52 +155,233 @@ internal sealed class PlantOrthoViewportReader : IOrthoViewportReader
        var hash = SHA256.HashData(Encoding.UTF8.GetBytes(sheetId + "|" + viewName));
        return "vp-" + Convert.ToHexString(hash)[..20];
    }
+
+    private static string? ReadSourceDrawingPath(IDwgViewDef view)
+    {
+        // Confirmed Plant 3D 2026 contract (PnPDwg2dDef/PnPDwg2dUtil):
+        // IDwgViewDef.DwgQuery -> IDwgQuery.ModelFiles -> ModelFile.ModelFileName.
+        // The Ortho sheet is never used as a Piping DataLinks source.
+        try
+        {
+            if (!OrthoModelFilesContract.IsSupported(view, out var diagnostic))
+            {
+                RuntimeDiagnostics.Write("OrthoModelFilesContractRejected", "WARNING", resultStatus: diagnostic.Code, details: diagnostic.Details);
+                return null;
+            }
+
+            if (RuntimeDiagnostics.IsOrthoStructureDiagnosticsEnabled)
+            {
+                OrthoRuntimeStructureInspector.Inspect(view);
+            }
+
+            return view.DwgQuery?.ModelFiles
+                .Select(file => file.ModelFileName)
+                .FirstOrDefault(value => !string.IsNullOrWhiteSpace(value));
+        }
+        catch (Exception exception)
+        {
+            RuntimeDiagnostics.Write("OrthoModelFilesReadFailed", "WARNING", resultStatus: "ORTHO_MODEL_FILES_API_UNSUPPORTED", exception: exception);
+        }
+        return null;
+    }
 }

+internal static class OrthoModelFilesContract
+{
+    private const string ExpectedViewType = "Autodesk.ProcessPower.Drawings2d.DwgViewDef";
+    private const string ExpectedQueryType = "Autodesk.ProcessPower.Drawings2d.DwgQueryByBox";
+    private const string ExpectedModelFileType = "Autodesk.ProcessPower.Drawings2d.ModelFile";
+    private const string ExpectedDefAssembly = "PnPDwg2dDef";
+    private const string ExpectedUtilAssembly = "PnPDwg2dUtil";
+    private const string ExpectedVersion = "0.0.0.0";
+
+    public static bool IsSupported(IDwgViewDef view, out OrthoModelFilesContractDiagnostic diagnostic)
+    {
+        var query = view.DwgQuery;
+        var files = query?.ModelFiles;
+        var valid = HasExpectedType(view, ExpectedViewType, ExpectedDefAssembly) &&
+                    query is not null && HasExpectedType(query, ExpectedQueryType, ExpectedDefAssembly) &&
+                    files is not null && files.GetType() == typeof(ModelFile[]) &&
+                    files.All(file => file is not null && HasExpectedType(file, ExpectedModelFileType, ExpectedUtilAssembly));
+        diagnostic = new OrthoModelFilesContractDiagnostic(
+            valid ? "ORTHO_MODEL_FILES_API_SUPPORTED" : "ORTHO_MODEL_FILES_API_UNSUPPORTED",
+            new Dictionary<string, object?>
+            {
+                ["ExpectedViewType"] = ExpectedViewType,
+                ["ActualViewType"] = TypeName(view),
+                ["ExpectedQueryType"] = ExpectedQueryType,
+                ["ActualQueryType"] = query is null ? null : TypeName(query),
+                ["ExpectedModelFileType"] = ExpectedModelFileType,
+                ["ActualModelFilesType"] = files?.GetType().AssemblyQualifiedName,
+                ["ExpectedAssemblyVersion"] = ExpectedVersion,
+                ["ActualViewAssemblyVersion"] = view.GetType().Assembly.GetName().Version?.ToString(),
+                ["ActualQueryAssemblyVersion"] = query?.GetType().Assembly.GetName().Version?.ToString(),
+                ["ActualModelFilesAssemblyVersion"] = files?.GetType().Assembly.GetName().Version?.ToString()
+            });
+        return valid;
+    }
+
+    private static bool HasExpectedType(object value, string expectedType, string expectedAssembly) =>
+        string.Equals(value.GetType().FullName, expectedType, StringComparison.Ordinal) &&
+        string.Equals(value.GetType().Assembly.GetName().Name, expectedAssembly, StringComparison.Ordinal) &&
+        string.Equals(value.GetType().Assembly.GetName().Version?.ToString(), ExpectedVersion, StringComparison.Ordinal);
+
+    private static string TypeName(object value) => $"{value.GetType().FullName}, {value.GetType().Assembly.GetName().Name}, {value.GetType().Assembly.GetName().Version}";
+}
+
+internal sealed record OrthoModelFilesContractDiagnostic(string Code, IReadOnlyDictionary<string, object?> Details);
+
 internal sealed class PlantObjectReader : IPlantObjectReader
 {
    public IReadOnlyList<PlantObjectSnapshot> ReadObjects(OrthoViewportInfo viewport, CancellationToken cancellationToken)
    {
-        var document = AcadApplication.DocumentManager.MdiActiveDocument;
-        if (document is null) return Array.Empty<PlantObjectSnapshot>();
+        if (string.IsNullOrWhiteSpace(viewport.SourceDrawingName))
+        {
+            WriteOutcome("ORTHO_SOURCE_DRAWING_NOT_RESOLVED", viewport);
+            return Array.Empty<PlantObjectSnapshot>();
+        }
+
+        PipingProject? pipingProject;
+        try { pipingProject = PlantApplication.ProjectPart("Piping") as PipingProject; }
+        catch (Exception exception)
+        {
+            WriteOutcome("PIPING_PROJECT_PART_NOT_FOUND", viewport, exception);
+            return Array.Empty<PlantObjectSnapshot>();
+        }
+        if (pipingProject is null)
+        {
+            WriteOutcome("PIPING_PROJECT_PART_NOT_FOUND", viewport);
+            return Array.Empty<PlantObjectSnapshot>();
+        }
+
+        var sourceDrawing = ResolveProjectDrawing(pipingProject, viewport.SourceDrawingName);
+        if (sourceDrawing is null) return Array.Empty<PlantObjectSnapshot>();

        DataLinksManager? dataLinks;
-        try { dataLinks = PlantApplication.ProjectPart("Piping")?.DataLinksManager; }
-        catch { return Array.Empty<PlantObjectSnapshot>(); }
-        if (dataLinks is null) return Array.Empty<PlantObjectSnapshot>();
+        try { dataLinks = pipingProject.DataLinksManager; }
+        catch (Exception exception)
+        {
+            WriteOutcome("SOURCE_DATALINKS_UNAVAILABLE", viewport, exception);
+            return Array.Empty<PlantObjectSnapshot>();
+        }
+        if (dataLinks is null)
+        {
+            WriteOutcome("SOURCE_DATALINKS_UNAVAILABLE", viewport);
+            return Array.Empty<PlantObjectSnapshot>();
+        }

        var snapshots = new List<PlantObjectSnapshot>();
-        foreach (var rowId in dataLinks.SelectAcPpRowIds(document.Database))
+        try
        {
-            try
+            // Confirmed Plant 3D 2026 contract: resolve the source model to the
+            // Piping project drawing record, then read its DataLinks by drawing Id.
+            // The active Ortho database is deliberately never passed to DataLinks.
+            var rowIds = dataLinks.SelectAcPpRowIds(sourceDrawing.Id);
+            if (rowIds.Count == 0)
            {
-                cancellationToken.ThrowIfCancellationRequested();
-                var className = dataLinks.GetObjectClassname(rowId);
-                var properties = dataLinks.GetAllProperties(rowId, true)
-                    .GroupBy(x => x.Key, StringComparer.OrdinalIgnoreCase)
-                    .ToDictionary(x => x.Key, x => x.Last().Value, StringComparer.OrdinalIgnoreCase);
-                string? Value(params string[] names) => properties.FirstOrDefault(x => names.Any(name => string.Equals(name, x.Key, StringComparison.OrdinalIgnoreCase))).Value;
-                snapshots.Add(new PlantObjectSnapshot
-                {
-                    SnapshotId = StableId(Path.GetFileName(document.Name), rowId, className),
-                    ObjectClass = className ?? string.Empty,
-                    Tag = Value("Tag", "TAG"),
-                    LineNumber = Value("Line Number", "LineNumber", "LINENUMBER"),
-                    SupportNumber = Value("Support Number", "SupportNumber"),
-                    EquipmentNumber = Value("Equipment Number", "EquipmentNumber"),
-                    Geometry = new GeometrySnapshot(),
-                    Properties = properties.ToDictionary(x => x.Key, x => (string?)x.Value, StringComparer.OrdinalIgnoreCase),
-                    Diagnostics = new[] { "GEOMETRY_NOT_MAPPED" }
-                });
+                WriteOutcome("SOURCE_DATALINKS_NO_ROWS", viewport, details: new Dictionary<string, object?> { ["ProjectDrawingResolved"] = true });
+                return Array.Empty<PlantObjectSnapshot>();
            }
-            catch
+
+            var membership = PlantViewportMembershipReader.Read(viewport, dataLinks, rowIds);
+
+            foreach (var rowId in rowIds)
            {
-                // Keep the read path best-effort; no write operation is attempted.
+                try
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    var className = dataLinks.GetObjectClassname(rowId);
+                    var properties = dataLinks.GetAllProperties(rowId, true)
+                        .GroupBy(x => x.Key, StringComparer.OrdinalIgnoreCase)
+                        .ToDictionary(x => x.Key, x => x.Last().Value, StringComparer.OrdinalIgnoreCase);
+                    string? Value(params string[] names) => properties.FirstOrDefault(x => names.Any(name => string.Equals(name, x.Key, StringComparison.OrdinalIgnoreCase))).Value;
+                    snapshots.Add(new PlantObjectSnapshot
+                    {
+                        SnapshotId = StableId(viewport.SourceDrawingName, rowId, className),
+                        ObjectClass = className ?? string.Empty,
+                        Tag = Value("Tag", "TAG"),
+                        LineNumber = Value("Line Number", "LineNumber", "LINENUMBER"),
+                        SupportNumber = Value("Support Number", "SupportNumber"),
+                        EquipmentNumber = Value("Equipment Number", "EquipmentNumber"),
+                        Geometry = membership.GeometryFor(rowId),
+                        Properties = properties.ToDictionary(x => x.Key, x => (string?)x.Value, StringComparer.OrdinalIgnoreCase),
+                        Diagnostics = new[] { "GEOMETRY_NOT_MAPPED" },
+                        MembershipStatus = membership.StatusFor(rowId),
+                        MembershipEvidenceCodes = membership.EvidenceFor(rowId)
+                    });
+                }
+                catch (Exception exception)
+                {
+                    RuntimeDiagnostics.Write("SourceDataLinksRowReadFailed", "WARNING", resultStatus: "SOURCE_DATABASE_READ_FAILED", exception: exception);
+                }
            }
        }
+        catch (DLException exception)
+        {
+            WriteOutcome("SOURCE_DATALINKS_UNAVAILABLE", viewport, exception);
+        }
+        catch (Exception exception)
+        {
+            WriteOutcome("SOURCE_DATABASE_READ_FAILED", viewport, exception);
+        }
+
+        WriteOutcome(snapshots.Count == 0 ? "SOURCE_PIPE_ROWS_NOT_FOUND" : "SOURCE_DATALINKS_READ", viewport,
+            details: new Dictionary<string, object?> { ["SourcePlantObjectsRead"] = snapshots.Count, ["PipeObjectsRead"] = snapshots.Count });
        return snapshots.OrderBy(x => x.SnapshotId, StringComparer.Ordinal).ToArray();
    }

+    private static PnPProjectDrawing? ResolveProjectDrawing(PipingProject pipingProject, string sourceDrawingPath)
+    {
+        if (!Path.IsPathRooted(sourceDrawingPath))
+        {
+            WriteOutcome("ORTHO_SOURCE_DRAWING_NOT_IN_PROJECT", null);
+            return null;
+        }
+
+        string normalizedSource;
+        try { normalizedSource = Path.GetFullPath(sourceDrawingPath); }
+        catch (Exception exception)
+        {
+            WriteOutcome("ORTHO_SOURCE_DRAWING_NOT_RESOLVED", null, exception);
+            return null;
+        }
+
+        var matches = pipingProject.GetPnPDrawingFiles()
+            .Where(drawing => MatchesSourcePath(drawing, normalizedSource))
+            .OrderBy(drawing => drawing.Id)
+            .ToArray();
+        if (matches.Length == 1)
+        {
+            RuntimeDiagnostics.Write("SourceProjectDrawingResolved", resultStatus: "SOURCE_FROM_PROJECT_DRAWING_ROW", details: new Dictionary<string, object?> { ["ProjectDrawingResolved"] = true });
+            return matches[0];
+        }
+
+        WriteOutcome(matches.Length == 0 ? "ORTHO_SOURCE_DRAWING_NOT_IN_PROJECT" : "ORTHO_SOURCE_DRAWING_AMBIGUOUS", null,
+            details: new Dictionary<string, object?> { ["CandidateCount"] = matches.Length });
+        return null;
+    }
+
+    private static bool MatchesSourcePath(PnPProjectDrawing drawing, string normalizedSource) =>
+        EquivalentPath(drawing.AbsoluteFileName, normalizedSource) ||
+        EquivalentPath(drawing.ResolvedFilePath, normalizedSource);
+
+    private static bool EquivalentPath(string? candidate, string normalizedSource)
+    {
+        if (string.IsNullOrWhiteSpace(candidate)) return false;
+        try { return string.Equals(Path.GetFullPath(candidate), normalizedSource, StringComparison.OrdinalIgnoreCase); }
+        catch { return false; }
+    }
+
+    private static void WriteOutcome(string code, OrthoViewportInfo? viewport, Exception? exception = null, IReadOnlyDictionary<string, object?>? details = null)
+    {
+        var sanitizedDetails = new Dictionary<string, object?>
+        {
+            ["SourceResolved"] = viewport?.SourceDrawingName is not null
+        };
+        if (details is not null) foreach (var detail in details) sanitizedDetails[detail.Key] = detail.Value;
+        RuntimeDiagnostics.Write("SourceDataLinksReadCompleted", code == "SOURCE_DATALINKS_READ" ? "INFO" : "WARNING", resultStatus: code, exception: exception, details: sanitizedDetails);
+    }
+
    private static string StableId(string drawingName, int rowId, string? className)
    {
        var hash = SHA256.HashData(Encoding.UTF8.GetBytes($"{drawingName}|{rowId}|{className}"));
@@ -196,11 +389,147 @@ internal sealed class PlantObjectReader : IPlantObjectReader
    }
 }

+internal sealed class PlantViewportMembershipReader
+{
+    internal readonly record struct MembershipReadResult(
+        IReadOnlySet<int> SelectedRows,
+        ViewMembershipStatus DefaultStatus,
+        string DefaultCode,
+        IReadOnlyDictionary<int, GeometrySnapshot>? Geometry = null)
+    {
+        public ViewMembershipStatus StatusFor(int rowId) =>
+            DefaultStatus == ViewMembershipStatus.Resolved && !SelectedRows.Contains(rowId)
+                ? ViewMembershipStatus.ObjectOutsideView
+                : DefaultStatus;
+
+        public IReadOnlyList<string> EvidenceFor(int rowId) =>
+            DefaultStatus == ViewMembershipStatus.Resolved && !SelectedRows.Contains(rowId)
+                ? new[] { "VIEW_MEMBERSHIP_OBJECT_OUTSIDE_CLIP" }
+                : new[] { DefaultCode };
+
+        public GeometrySnapshot GeometryFor(int rowId) =>
+            Geometry is not null && Geometry.TryGetValue(rowId, out var geometry)
+                ? geometry
+                : new GeometrySnapshot();
+    }
+
+    internal static MembershipReadResult Read(OrthoViewportInfo viewport, DataLinksManager dataLinks, Autodesk.ProcessPower.DataObjects.PnPRowIdArray sourceRows)
+    {
+        try
+        {
+            var project = PlantApplication.ProjectPart("Ortho") as OrthoProject;
+            if (project is null) return Unsupported("VIEW_MEMBERSHIP_API_UNSUPPORTED");
+
+            var candidates = project.DwgSheetDefinitions.AsArray()
+                .SelectMany(sheet => sheet.DwgViewDefs.AsArray()
+                    .Where(view => string.Equals(StableId(sheet.DwgGuid.ToString(), view.ViewName), viewport.Id, StringComparison.Ordinal))
+                    .Select(view => (sheet, view)))
+                .ToArray();
+            if (candidates.Length != 1) return Unsupported("VIEW_MEMBERSHIP_API_UNSUPPORTED");
+
+            var view = candidates[0].view;
+            if (!OrthoModelFilesContract.IsSupported(view, out var diagnostic))
+            {
+                RuntimeDiagnostics.Write("ViewportMembershipContractRejected", "WARNING", resultStatus: diagnostic.Code, details: diagnostic.Details);
+                return Unsupported("VIEW_MEMBERSHIP_API_UNSUPPORTED");
+            }
+
+            var selectedRows = new HashSet<int>();
+            var geometry = new Dictionary<int, GeometrySnapshot>();
+            var selected = view.DwgQuery.Execute(new StringCollection(), new StringCollection());
+            for (var index = 0; index < selected.Count; index++)
+            {
+                Autodesk.ProcessPower.Drawings2d.MdObjectId sourceId = default;
+                if (!selected.GetItem(index, ref sourceId) || sourceId.IsNull || sourceId.PrjObjectId.IsNull) continue;
+                try
+                {
+                    var rowId = dataLinks.FindAcPpRowId(sourceId.PrjObjectId);
+                    if (sourceRows.Contains(rowId))
+                    {
+                        selectedRows.Add(rowId);
+                        if (TryReadPipePlacement(sourceId, dataLinks, out var placement)) geometry[rowId] = placement;
+                    }
+                }
+                catch (DLException)
+                {
+                    // A generated entity without a Piping DataLinks row is outside this reader's source set.
+                }
+            }
+
+            RuntimeDiagnostics.Write("ViewportMembershipReadCompleted", "INFO", resultStatus: "VIEW_MEMBERSHIP_FROM_CONFIRMED_PNP_ID", details: new Dictionary<string, object?>
+            {
+                ["SelectedSourceRows"] = selectedRows.Count,
+                ["SourceRows"] = sourceRows.Count
+            });
+            return new MembershipReadResult(selectedRows, ViewMembershipStatus.Resolved, "VIEW_MEMBERSHIP_FROM_CONFIRMED_PNP_ID", geometry);
+        }
+        catch (Exception exception)
+        {
+            RuntimeDiagnostics.Write("ViewportMembershipReadCompleted", "WARNING", resultStatus: "VIEW_MEMBERSHIP_API_UNSUPPORTED", exception: exception);
+            return Unsupported("VIEW_MEMBERSHIP_API_UNSUPPORTED");
+        }
+    }
+
+    private static MembershipReadResult Unsupported(string code) => new(new HashSet<int>(), ViewMembershipStatus.NotResolved, code);
+
+    // Confirmed Plant 3D 2026 linkage: DwgQuery.Execute returns MdObjectId,
+    // whose PrjObjectId identifies the source entity and whose Xform projects
+    // that source entity into the particular Ortho view.  This is not a sheet
+    // coordinate heuristic.
+    private static bool TryReadPipePlacement(MdObjectId sourceId, DataLinksManager dataLinks, out GeometrySnapshot geometry)
+    {
+        geometry = new GeometrySnapshot();
+        var stage = "GetDatabase";
+        try
+        {
+            var openedByQuery = false;
+            // The source model is normally not an active document in an Ortho /b session.
+            // Ask MdObjectId to open its source database read-only and dispose it below when it did.
+            var sourceDatabase = sourceId.GetDatabase(true, ref openedByQuery);
+            try
+            {
+                stage = "StartTransaction";
+                using var transaction = sourceDatabase.TransactionManager.StartOpenCloseTransaction();
+                stage = "MakeAcDbObjectId";
+                var objectId = dataLinks.MakeAcDbObjectId(sourceId.PrjObjectId, sourceDatabase);
+                stage = "OpenPipe";
+                if (transaction.GetObject(objectId, OpenMode.ForRead) is not Pipe pipe) return false;
+                stage = "TransformStartPoint";
+                var point = pipe.StartPoint.TransformBy(sourceId.Xform);
+                geometry = new GeometrySnapshot
+                {
+                    PaperPosition = new Point2Dto(point.X, point.Y),
+                    Rotation = 0
+                };
+                return true;
+            }
+            finally
+            {
+                if (openedByQuery) sourceDatabase.Dispose();
+            }
+        }
+        catch (Exception exception)
+        {
+            RuntimeDiagnostics.Write("OrthoPipePlacementReadFailed", "ERROR", resultStatus: "ORTHO_PIPE_PLACEMENT_UNAVAILABLE", exception: exception, details: new Dictionary<string, object?> { ["PlacementStage"] = stage });
+            return false;
+        }
+    }
+
+    // Ortho viewport IDs are generated by PlantOrthoViewportReader from exactly this pair.
+    // Only an exact regenerated ID is accepted; the reader never chooses an arbitrary view.
+    private static string StableId(string sheetId, string? viewName)
+    {
+        var hash = SHA256.HashData(Encoding.UTF8.GetBytes(sheetId + "|" + (viewName ?? string.Empty)));
+        return "vp-" + Convert.ToHexString(hash)[..20];
+    }
+
+}
+
 internal sealed class RuntimeWriteGuard(PRecAnnotExecutionMode mode) : IRuntimeWriteGuard
 {
    public void EnsureWriteAllowed(string operation)
    {
-        if (mode == PRecAnnotExecutionMode.Apply) throw new InvalidOperationException("APPLY_MODE_NOT_IMPLEMENTED");
+        if (mode == PRecAnnotExecutionMode.Apply) return;
        throw new InvalidOperationException("SMOKE_WRITE_BLOCKED");
    }
 }
@@ -14,6 +14,10 @@ internal static class RuntimeDiagnostics

    public static string RuntimeMode => Environment.GetEnvironmentVariable("P_REC_ANNOT_RUNTIME_MODE") ?? "Normal";

+    public static bool IsOrthoStructureDiagnosticsEnabled =>
+        string.Equals(RuntimeMode, "DryRun", StringComparison.OrdinalIgnoreCase) &&
+        string.Equals(Environment.GetEnvironmentVariable("P_REC_ANNOT_DIAGNOSTICS"), "OrthoStructure", StringComparison.OrdinalIgnoreCase);
+
    public static void Write(
        string eventType,
        string level = "INFO",
@@ -0,0 +1,272 @@
+using System.Text.Json;
+using System.Reflection;
+using System.Security.Cryptography;
+using Autodesk.AutoCAD.ApplicationServices;
+using Autodesk.AutoCAD.DatabaseServices;
+using Autodesk.AutoCAD.Runtime;
+using Autodesk.ProcessPower.PlantInstance;
+using Autodesk.ProcessPower.ProjectManager;
+using PRecAnnot.Abstractions;
+using AcadApplication = Autodesk.AutoCAD.ApplicationServices.Application;
+
+namespace PRecAnnot.Plant3D2026;
+
+// Test-only observer. The AutoCAD /b processor, never this type, drives PXP-OA.
+internal static class ScriptDrivenFirstApplyAutomation
+{
+    private sealed record Config(string Phase, string OrthoDrawingPath, string EvidencePath, string FixtureMarkerPath, string ExpectedEntryAssemblySha256, bool Diagnostic);
+    private sealed record Run(int Sequence, string? PlanId, IReadOnlyList<string> Candidates, string? View, int Create, int Skip, bool? PermitAccepted, string? ApplyOutcome, int? DbmodBefore, int? DbmodAfter, AutomationEntityCounts? Before, AutomationEntityCounts? After, bool WillStart, bool Ended, bool Failed, bool Cancelled, int? SourceRows, int? MembershipResolved);
+    private static Config? config;
+    private static Document? fixture;
+    private static Database? database;
+    private static AutomationEntityCounts? baseline;
+    private static int? dbmodBaseline;
+    private static readonly List<Run> runs = [];
+    private static readonly List<string> transitions = [];
+    private static readonly List<string> commandEvents = [];
+    private static readonly List<AutomationSentinelEvidence> sentinels = [];
+    private static readonly List<AutomationCommandCorrelationEvidence> correlations = [];
+    private static PxpOaDiscoveryEvidence? discovery;
+    // Plant's implicit current-document lookup can lag between script commands.
+    // PREPARE has already proved this immutable context belongs to the live fixture;
+    // retain it for the two immediately following public PXP-OA commands only.
+    private static PlantRuntimeContext? preparedContext;
+    private static string? selectedTargetSnapshotId;
+    private static bool prepared;
+    private static bool terminal;
+    private static string? applyExceptionText;
+
+    internal static void Prepare()
+    {
+        try
+        {
+            if (terminal) return;
+            config = ReadConfig();
+            RequireGate(config);
+            discovery = DiscoverPxpOa(config);
+            RequireDiscovery(discovery);
+            var active = AcadApplication.DocumentManager.MdiActiveDocument ?? throw new InvalidOperationException("AUTOMATION_ACTIVE_DOCUMENT_MISSING");
+            if (!SamePath(active.Name, config.OrthoDrawingPath)) throw new InvalidOperationException("AUTOMATION_UNEXPECTED_ACTIVE_FIXTURE");
+            fixture = active;
+            database = active.Database ?? throw new InvalidOperationException("AUTOMATION_FIXTURE_DATABASE_MISSING");
+            fixture.CommandWillStart += OnWillStart;
+            fixture.CommandEnded += OnEnded;
+            fixture.CommandFailed += OnFailed;
+            fixture.CommandCancelled += OnCancelled;
+            var projectXml = Path.Combine(Path.GetDirectoryName(config.FixtureMarkerPath)!, "Project.xml");
+            if (!File.Exists(projectXml)) throw new InvalidOperationException("AUTOMATION_PROJECT_XML_MISSING");
+            var project = PlantProject.LoadProject(projectXml, false, string.Empty, string.Empty);
+            PlantApplication.SetCurrentProject(project, true);
+            var context = new PlantRuntimeContextReader().ReadCurrentContext(fixture);
+            if (!context.HasPlantProject || !context.IsOrthoDrawing || context.Viewports.Count != 1)
+                throw new InvalidOperationException("AUTOMATION_ORTHO_CONTEXT_INVALID");
+            var candidates = new PlantObjectReader().ReadObjects(context.Viewports.Single(), CancellationToken.None)
+                .Where(x => string.Equals(x.ObjectClass, "Pipe", StringComparison.OrdinalIgnoreCase) && x.MembershipStatus == ViewMembershipStatus.Resolved && x.Geometry.PaperPosition is not null)
+                .Select(x => x.SnapshotId).OrderBy(x => x, StringComparer.Ordinal).ToArray();
+            if (candidates.Length == 0) throw new InvalidOperationException("AUTOMATION_NO_ELIGIBLE_CANDIDATE");
+            preparedContext = context;
+            selectedTargetSnapshotId = candidates[0];
+            dbmodBaseline = Dbmod();
+            baseline = Counts(database);
+            prepared = true;
+            transitions.Add("Prepared");
+            Write(false, null);
+        }
+        catch (System.Exception exception) { Fail("AUTOMATION_PREPARE_FAILED", exception); }
+    }
+
+    internal static void RecordSentinel(string stage)
+    {
+        Guard(() =>
+        {
+            if (!prepared || terminal || fixture is null || database is null) return;
+            sentinels.Add(new(stage, fixture.Name, database.Filename, DateTimeOffset.UtcNow));
+            transitions.Add("Sentinel:" + stage);
+            Write(false, null);
+        });
+    }
+
+    internal static void RecordPxpOa(string? planId, IReadOnlyList<string> candidates, string? view, int create, int skip, bool? permitAccepted, int sourceRows, int membershipResolved)
+    {
+        if (!prepared || terminal || runs.Count == 0) return;
+        var last = runs[^1];
+        if (!last.WillStart || last.PlanId is not null) return;
+        runs[^1] = last with { PlanId = planId, Candidates = candidates, View = view, Create = create, Skip = skip, PermitAccepted = permitAccepted, SourceRows = sourceRows, MembershipResolved = membershipResolved };
+    }
+
+    internal static void RecordApplyOutcome(PipeAnnotationWriteOutcome outcome)
+    {
+        if (!prepared || terminal || runs.Count == 0) return;
+        var last = runs[^1];
+        runs[^1] = outcome == PipeAnnotationWriteOutcome.AlreadyExists
+            ? last with { ApplyOutcome = outcome.ToString(), Create = 0, Skip = 1 }
+            : last with { ApplyOutcome = outcome.ToString() };
+    }
+    internal static void RecordApplyFailure(System.Exception exception)
+    {
+        if (!prepared || terminal) return;
+        applyExceptionText = exception.ToString();
+        Write(false, "AUTOMATION_APPLY_COMMAND_FAILED");
+    }
+
+    internal static bool TryGetPreparedContext(Document? commandDocument, out PlantRuntimeContext context)
+    {
+        context = null!;
+        if (!prepared || terminal || fixture is null || preparedContext is null || commandDocument is null || config is null) return false;
+        if (!SamePath(commandDocument.Name, config.OrthoDrawingPath) || !SamePath(fixture.Name, config.OrthoDrawingPath)) return false;
+        if (commandDocument.Database is null || database is null || !SamePath(commandDocument.Database.Filename, database.Filename)) return false;
+        context = preparedContext;
+        return true;
+    }
+
+    internal static string? SelectedTargetSnapshotId => prepared && !terminal ? selectedTargetSnapshotId : null;
+
+    internal static void FinalizeAutomation()
+    {
+        try
+        {
+            if (!prepared) throw new InvalidOperationException("AUTOMATION_NOT_PREPARED");
+            if (runs.Count != 2) throw new InvalidOperationException("AUTOMATION_EXPECTS_EXACTLY_TWO_PXP_OA");
+            if (runs.Any(x => !x.WillStart || !x.Ended || x.Failed || x.Cancelled)) throw new InvalidOperationException("AUTOMATION_PXP_OA_NOT_ENDED");
+            if (runs.Any(x => string.IsNullOrWhiteSpace(x.PlanId))) throw new InvalidOperationException("PXP_OA_PLAN_RESULT_NOT_CAPTURED");
+            if (!string.Equals(runs[0].PlanId, runs[1].PlanId, StringComparison.Ordinal)) throw new InvalidOperationException("AUTOMATION_PLAN_IDS_DIFFER");
+            var apply = string.Equals(config!.Phase, "Apply", StringComparison.OrdinalIgnoreCase);
+            if ((!apply && runs.Any(x => x.Create != 1)) || (apply && (runs[0].Create != 1 || runs[1].Create != 0))) throw new InvalidOperationException("AUTOMATION_CREATE_COUNTS_INVALID");
+            if (runs[0].Candidates.Count == 0) throw new InvalidOperationException("AUTOMATION_NO_ELIGIBLE_CANDIDATE");
+            if (apply)
+            {
+                if (runs[0].PermitAccepted != true) throw new InvalidOperationException("AUTOMATION_APPLY_PERMIT_NOT_ACCEPTED");
+                if (!string.Equals(runs[0].ApplyOutcome, PipeAnnotationWriteOutcome.Created.ToString(), StringComparison.Ordinal)) throw new InvalidOperationException("AUTOMATION_APPLY_CREATE_NOT_CONFIRMED");
+                if (!string.Equals(runs[1].ApplyOutcome, PipeAnnotationWriteOutcome.AlreadyExists.ToString(), StringComparison.Ordinal)) throw new InvalidOperationException("AUTOMATION_APPLY_DUPLICATE_NOT_CONFIRMED");
+                var undoCounts = Counts(database!);
+                if (!Equals(undoCounts, baseline)) throw new InvalidOperationException("AUTOMATION_UNDO_DID_NOT_RESTORE_BASELINE");
+            }
+            else if (Dbmod() != dbmodBaseline || !Equals(Counts(database!), baseline)) throw new InvalidOperationException("AUTOMATION_INSPECTOR_INVARIANCE_FAILED");
+            terminal = true;
+            transitions.Add(apply ? "ApplyCompleted" : "PreviewCompleted");
+            Write(true, null);
+            Unsubscribe();
+        }
+        catch (System.Exception exception) { Fail("PREVIEW_ACCEPTANCE_FAILED", exception); }
+    }
+
+    private static void OnWillStart(object sender, CommandEventArgs args)
+    {
+        Guard(() =>
+        {
+            commandEvents.Add("WillStart:" + args.GlobalCommandName);
+            var correlation = Correlate("WillStart", sender, args.GlobalCommandName, runs.Count < 2);
+            correlations.Add(correlation);
+            if (correlation.RejectionReason is not null) return;
+            runs.Add(new Run(runs.Count + 1, null, [], null, 0, 0, null, null, Dbmod(), null, Counts(database!), null, true, false, false, false, null, null));
+            transitions.Add("PxpOaWillStart:" + runs.Count);
+        });
+    }
+    private static void OnEnded(object sender, CommandEventArgs args) => Finish(sender, args, false, false);
+    private static void OnFailed(object sender, CommandEventArgs args) => Finish(sender, args, true, false);
+    private static void OnCancelled(object sender, CommandEventArgs args) => Finish(sender, args, false, true);
+    private static void Finish(object sender, CommandEventArgs args, bool failed, bool cancelled)
+    {
+        Guard(() =>
+        {
+            var kind = failed ? "Failed" : cancelled ? "Cancelled" : "Ended";
+            commandEvents.Add(kind + ":" + args.GlobalCommandName);
+            var correlation = Correlate(kind, sender, args.GlobalCommandName, runs.Count > 0);
+            correlations.Add(correlation);
+            if (correlation.RejectionReason is not null) return;
+            var last = runs[^1];
+            if (last.Ended || last.Failed || last.Cancelled) return;
+            runs[^1] = last with { Ended = !failed && !cancelled, Failed = failed, Cancelled = cancelled, DbmodAfter = Dbmod(), After = Counts(database!) };
+            transitions.Add(failed ? "PxpOaFailed" : cancelled ? "PxpOaCancelled" : "PxpOaEnded:" + last.Sequence);
+            Write(false, null);
+        });
+    }
+    private static AutomationCommandCorrelationEvidence Correlate(string kind, object sender, string rawName, bool sequenceAccepted)
+    {
+        var normalized = rawName.Trim();
+        var command = string.Equals(normalized, "PXP-OA", StringComparison.OrdinalIgnoreCase);
+        var state = prepared && !terminal && config is not null && fixture is not null && database is not null;
+        var senderDocument = sender as Document;
+        var senderPath = senderDocument?.Name;
+        var expectedPath = config?.OrthoDrawingPath;
+        var activePath = AcadApplication.DocumentManager.MdiActiveDocument?.Name;
+        var fixturePath = senderPath is not null && expectedPath is not null && SamePath(senderPath, expectedPath);
+        var activeFixture = activePath is not null && expectedPath is not null && SamePath(activePath, expectedPath);
+        var document = fixturePath && activeFixture;
+        var databaseMatch = senderDocument?.Database is not null && database is not null && SamePath(senderDocument.Database.Filename, database.Filename);
+        var rejection = !command ? "COMMAND_NAME_MISMATCH" : !state ? "NOT_PREPARED" : !document ? "DOCUMENT_IDENTITY_MISMATCH" : !databaseMatch ? "DATABASE_IDENTITY_MISMATCH" : !sequenceAccepted ? "UNEXPECTED_SEQUENCE" : null;
+        return new(kind, rawName, normalized, command, state, document, databaseMatch, fixturePath, sequenceAccepted, rejection, sender.GetType().FullName, senderPath, expectedPath, activePath, runs.Count, DateTimeOffset.UtcNow);
+    }
+    private static void Guard(Action action) { try { if (!terminal) action(); } catch (System.Exception ex) { Fail("AUTOMATION_EVENT_HANDLER_FAILED", ex); } }
+    private static void Fail(string code, System.Exception exception) { if (terminal) return; terminal = true; transitions.Add("Failed:" + code); try { Write(false, code + ":" + exception); } finally { Unsubscribe(); } }
+    private static void Unsubscribe()
+    {
+        if (fixture is not null) try { fixture.CommandWillStart -= OnWillStart; fixture.CommandEnded -= OnEnded; fixture.CommandFailed -= OnFailed; fixture.CommandCancelled -= OnCancelled; } catch { }
+        preparedContext = null;
+        selectedTargetSnapshotId = null;
+    }
+    private static int? Dbmod() { try { return Convert.ToInt32(AcadApplication.GetSystemVariable("DBMOD")); } catch { return null; } }
+    private static AutomationEntityCounts Counts(Database db)
+    {
+        using var tx = db.TransactionManager.StartTransaction();
+        var space = (BlockTableRecord)tx.GetObject(db.CurrentSpaceId, OpenMode.ForRead);
+        var total = 0; var pipes = 0; var xdata = 0; var owned = 0;
+        foreach (ObjectId id in space) { if (tx.GetObject(id, OpenMode.ForRead) is not Entity entity) continue; total++; if (entity is BlockReference br && string.Equals(br.Name, "PIPE", StringComparison.OrdinalIgnoreCase)) pipes++; if (entity.XData is not null) { foreach (TypedValue value in entity.XData) if (value.Value is string text && string.Equals(text, "PXP-OA", StringComparison.OrdinalIgnoreCase)) { xdata++; owned++; break; } } }
+        return new(total, pipes, xdata, owned);
+    }
+    private static Config ReadConfig()
+    {
+        var path = Environment.GetEnvironmentVariable("P_REC_ANNOT_AUTOMATION_CONFIG") ?? throw new InvalidOperationException("AUTOMATION_CONFIG_MISSING");
+        using var json = JsonDocument.Parse(File.ReadAllText(path)); var root = json.RootElement;
+        return new(root.GetProperty("phase").GetString() ?? "Preview", root.GetProperty("orthoDrawingPath").GetString() ?? throw new InvalidOperationException("AUTOMATION_ORTHO_PATH_REQUIRED"), root.GetProperty("evidencePath").GetString() ?? throw new InvalidOperationException("AUTOMATION_EVIDENCE_PATH_REQUIRED"), root.GetProperty("fixtureMarkerPath").GetString() ?? throw new InvalidOperationException("AUTOMATION_MARKER_PATH_REQUIRED"), root.GetProperty("entryAssemblySha256").GetString() ?? throw new InvalidOperationException("AUTOMATION_ENTRY_ASSEMBLY_HASH_REQUIRED"), root.TryGetProperty("diagnostic", out var diagnostic) && diagnostic.ValueKind == JsonValueKind.True);
+    }
+    private static void RequireGate(Config value)
+    {
+        if (!string.Equals(Environment.GetEnvironmentVariable("P_REC_ANNOT_AUTOMATION"), "FirstLimitedApplyRuntimeTest", StringComparison.Ordinal) || !string.Equals(Environment.GetEnvironmentVariable("P_REC_ANNOT_LAUNCHER_MODE"), "NextPilot", StringComparison.Ordinal) || !File.Exists(value.FixtureMarkerPath)) throw new InvalidOperationException("AUTOMATION_GATE_REJECTED");
+    }
+    private static bool SamePath(string left, string right) => string.Equals(Path.GetFullPath(left), Path.GetFullPath(right), StringComparison.OrdinalIgnoreCase);
+    private static void Write(bool completed, string? error)
+    {
+        if (config is null) return;
+        var first = runs.ElementAtOrDefault(0); var second = runs.ElementAtOrDefault(1);
+        var apply = string.Equals(config.Phase, "Apply", StringComparison.OrdinalIgnoreCase);
+        var afterUndo = apply && terminal ? Counts(database!) : null;
+        var evidence = new FirstApplyAutomationEvidence { Phase = config.Phase, Completed = completed, Prepared = prepared, FunctionalEvidenceCompleted = completed, ErrorCode = error, DbmodBefore = dbmodBaseline, DbmodAfterCommand1 = first?.DbmodAfter, DbmodAfterCommand2 = second?.DbmodAfter, DbmodAfterUndo = apply && terminal ? Dbmod() : null, Baseline = baseline, AfterCommand1 = first?.After, AfterCommand2 = second?.After, AfterUndo = afterUndo, CompletedCommands = runs.Where(x => x.Ended).Select(x => "PXP-OA").Concat(apply && commandEvents.Any(x => string.Equals(x, "Ended:UNDO", StringComparison.OrdinalIgnoreCase)) ? ["UNDO"] : []).ToArray(), PlanIdRun1 = first?.PlanId, PlanIdRun2 = second?.PlanId, PlanIdsEqual = first is not null && second is not null ? string.Equals(first.PlanId, second.PlanId, StringComparison.Ordinal) : null, EligibleCandidateCount = first?.Candidates.Count, SelectedCandidateHash = first?.Candidates.OrderBy(x => x, StringComparer.Ordinal).FirstOrDefault(), ViewHash = first?.View, CreateRun1 = first?.Create, CreateRun2 = second?.Create, SkipRun2 = second?.Skip, ApplyOutcomeRun1 = first?.ApplyOutcome, ApplyOutcomeRun2 = second?.ApplyOutcome, PermitAccepted = first?.PermitAccepted, CommandsCompleted = runs.Count == 2 && runs.All(x => x.Ended) && (!apply || commandEvents.Any(x => string.Equals(x, "Ended:UNDO", StringComparison.OrdinalIgnoreCase))), InspectorsCompleted = baseline is not null && first?.After is not null && second?.After is not null && (!apply || afterUndo is not null), EvidenceFlushed = true, ExceptionText = applyExceptionText, CurrentState = terminal ? (completed ? "Completed" : "Failed") : "Prepared", StateTransitions = transitions, PxpOaDiscovery = discovery, Sentinels = sentinels, CommandEvents = commandEvents, CommandCorrelations = correlations };
+        Directory.CreateDirectory(Path.GetDirectoryName(config.EvidencePath)!);
+        var temp = config.EvidencePath + ".tmp"; File.WriteAllText(temp, JsonSerializer.Serialize(evidence)); File.Move(temp, config.EvidencePath, true);
+    }
+
+    private static PxpOaDiscoveryEvidence DiscoverPxpOa(Config value)
+    {
+        var entry = typeof(EntryPoint).Assembly;
+        var loaded = AppDomain.CurrentDomain.GetAssemblies().Any(x => ReferenceEquals(x, entry));
+        var location = entry.Location;
+        var hash = File.Exists(location) ? Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(location))) : null;
+        var declarations = AppDomain.CurrentDomain.GetAssemblies().SelectMany(Declarations).Where(x => string.Equals(x.Name, "PXP-OA", StringComparison.OrdinalIgnoreCase)).ToArray();
+        var owner = declarations.SingleOrDefault(x => x.Assembly == entry);
+        var commandClass = entry.GetCustomAttributesData().Any(x => string.Equals(x.AttributeType.FullName, "Autodesk.AutoCAD.Runtime.CommandClassAttribute", StringComparison.Ordinal) && x.ConstructorArguments.Any(a => string.Equals(a.Value as Type, typeof(EntryPoint))));
+        return new(owner is not null, owner?.Name, owner?.Group, owner?.Flags, owner?.Type.FullName, owner?.Assembly.GetName().Name, location, hash, loaded, commandClass, hash is not null && string.Equals(hash, value.ExpectedEntryAssemblySha256, StringComparison.OrdinalIgnoreCase), declarations.Length);
+    }
+    private sealed record Declaration(string Name, string? Group, string? Flags, Type Type, Assembly Assembly);
+    private static IEnumerable<Declaration> Declarations(Assembly assembly)
+    {
+        Type[] types; try { types = assembly.GetTypes(); } catch (ReflectionTypeLoadException exception) { types = exception.Types.Where(x => x is not null).Cast<Type>().ToArray(); }
+        foreach (var type in types) foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)) foreach (var attribute in method.GetCustomAttributesData().Where(x => string.Equals(x.AttributeType.FullName, "Autodesk.AutoCAD.Runtime.CommandMethodAttribute", StringComparison.Ordinal)))
+        {
+            var name = attribute.ConstructorArguments.FirstOrDefault().Value as string;
+            if (string.IsNullOrWhiteSpace(name)) continue;
+            var group = attribute.NamedArguments.FirstOrDefault(x => x.MemberName == "GroupName").TypedValue.Value as string;
+            var flags = attribute.NamedArguments.FirstOrDefault(x => x.MemberName == "Flags").TypedValue.Value?.ToString();
+            yield return new(name, group, flags, type, assembly);
+        }
+    }
+    private static void RequireDiscovery(PxpOaDiscoveryEvidence value)
+    {
+        if (!value.AssemblyLoaded) throw new InvalidOperationException("PXP_OA_ASSEMBLY_NOT_LOADED");
+        if (!value.BundleHashMatched) throw new InvalidOperationException("PXP_OA_BUNDLE_HASH_MISMATCH");
+        if (!value.CommandClassIncluded) throw new InvalidOperationException("PXP_OA_COMMANDCLASS_NOT_REGISTERED");
+        if (value.DeclarationCount > 1) throw new InvalidOperationException("PXP_OA_COMMAND_COLLISION");
+        if (value.DeclarationCount == 0 || !value.Found) throw new InvalidOperationException("PXP_OA_COMMAND_NOT_FOUND");
+        if (!string.Equals(value.GlobalName, "PXP-OA", StringComparison.Ordinal)) throw new InvalidOperationException("PXP_OA_GLOBAL_NAME_MISMATCH");
+    }
+}
@@ -61,6 +61,170 @@ public sealed class FoundationTests
        Assert.Contains("[CommandMethod(\"PHP_REC_ANNOT\")]", source);
        Assert.Contains("[CommandMethod(\"PXP-AAV\")]", source);
        Assert.Contains("[CommandMethod(\"PXP-OA\")]", source);
+        Assert.Contains("PHP_REC_AUTOMATION_READY", source);
+    }
+
+    [Fact] public void AutomationBootstrap_DefersPlantAndDocumentAccessUntilCoordinator()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        var bootstrap = source[..source.IndexOf("internal sealed record FirstApplyAutomationEvidence", StringComparison.Ordinal)];
+        Assert.DoesNotContain("PlantProject.LoadProject", bootstrap);
+        Assert.DoesNotContain("MdiActiveDocument", bootstrap);
+        Assert.Contains("AcadApplication.Idle += OnIdle", bootstrap);
+        Assert.Contains("observedIdle = true", bootstrap);
+        Assert.Contains("coordinatorStartCount++", bootstrap);
+    }
+
+    [Fact] public void AutomationLifecycleProbe_CompletesBeforePlantActivation()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.Contains("LifecycleProbe", source);
+        Assert.True(source.IndexOf("CompleteLifecycleProbe", StringComparison.Ordinal) < source.IndexOf("PlantProject.LoadProject", StringComparison.Ordinal));
+        Assert.Contains("PostStartupReady", source);
+    }
+
+    [Fact] public void AutomationProjectActivation_WaitsForFixtureDocumentAndQuiescence()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        var activation = source[source.IndexOf("private void TryActivateProjectAndVerifyContext", StringComparison.Ordinal)..];
+        Assert.Contains("!fixtureDocumentActivated", activation);
+        Assert.Contains("!AcadApplication.IsQuiescent", activation);
+        Assert.True(activation.IndexOf("PlantProject.LoadProject", StringComparison.Ordinal) > activation.IndexOf("AutomationBeforeProjectActivation", StringComparison.Ordinal));
+    }
+
+    [Fact] public void AutomationDocumentActivation_IsSubscribedBeforeFixtureOpen()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.True(source.IndexOf("DocumentActivated += OnDocumentActivated", StringComparison.Ordinal) < source.IndexOf("DocumentManager.Open(config.OrthoDrawingPath", StringComparison.Ordinal));
+        Assert.Contains("FixtureDocumentActivated", source);
+    }
+
+    [Fact] public void AutomationDocumentActivation_RecoversSynchronousOpenEvent()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        var start = source[source.IndexOf("public void Start()", StringComparison.Ordinal)..source.IndexOf("private void CompleteLifecycleProbe", StringComparison.Ordinal)];
+        Assert.Contains("FixtureDocumentActiveAfterOpen", start);
+        Assert.Contains("fixtureDocumentActivated = true", start);
+        Assert.Contains("QueueReadinessBarrier();", start);
+        Assert.Contains("ReadinessBarrierCompleted", source);
+        Assert.Contains("TryActivateProjectAndVerifyContext();", source);
+    }
+
+    [Fact] public void QueueReadinessBarrier_RequiresActiveFixtureAndUsesSafeDispatch()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        var dispatcher = source[source.IndexOf("private async Task DispatchCommandAsync", StringComparison.Ordinal)..source.IndexOf("private void OnCommandEnded", StringComparison.Ordinal)];
+        Assert.Contains("ExecuteInCommandContextAsync", dispatcher);
+        Assert.Contains("MdiActiveDocument", dispatcher);
+        Assert.Contains("AUTOMATION_COMMAND_DOCUMENT_NOT_ACTIVE", dispatcher);
+        Assert.Contains("Editor.CommandAsync", dispatcher);
+        Assert.DoesNotContain("SendStringToExecute", dispatcher);
+    }
+
+    [Fact] public void AutomationControlledExit_QueuesNativeQuitAfterPublicCommand()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.Contains("RequestControlledExit", source);
+        Assert.Contains("AcadApplication.Idle += OnExitIdle", source);
+        Assert.Contains("QuitDispatchAttempted", source);
+        Assert.Contains("exitDocument.SendStringToExecute(\"_.QUIT _N\\n\", true, true, false);", source);
+        Assert.Contains("var exitDocument = AcadApplication.DocumentManager.MdiActiveDocument;", source);
+    }
+
+    [Fact] public void Callback_AfterDocumentDestroyed_DoesNotAccessDocument()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.Contains("if (document is null || e.Document is null) return;", source);
+        Assert.Contains("if (IsTerminal || document is null) return;", source);
+    }
+
+    [Fact] public void Idle_WhenActiveDocumentNull_DoesNotThrow()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.Contains("AUTOMATION_EXIT_DOCUMENT_UNAVAILABLE", source);
+        Assert.Contains("QuitDispatchSkippedNoLiveDocument", source);
+    }
+
+    [Fact] public void TerminalState_IgnoresFurtherCallbacks()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.Contains("private bool IsTerminal", source);
+        Assert.Contains("if (IsTerminal && callback != \"ControlledExitIdle\") return;", source);
+    }
+
+    [Fact] public void HandlerException_ProducesFailedEvidence()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.Contains("exceptionText = exception.ToString();", source);
+        Assert.Contains("ExceptionText = exceptionText", source);
+        Assert.Contains("FailFromCallback", source);
+    }
+
+    [Fact] public void HandlerException_DoesNotEscapeToAutoCad()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.Contains("private void RunCallback", source);
+        Assert.Contains("catch (System.Exception exception) { FailFromCallback", source);
+        Assert.Contains("=> RunCallback(\"Idle\"", source);
+        Assert.Contains("=> RunCallback(\"CommandFailed\"", source);
+    }
+
+    [Fact] public void Unsubscribe_IsIdempotent()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.Contains("private bool documentHandlersSubscribed", source);
+        Assert.Contains("private bool lifecycleHandlersSubscribed", source);
+        Assert.Contains("private void UnsubscribeHandlers()", source);
+    }
+
+    [Fact] public void ControlledExit_DoesNotReuseDestroyedDocument()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        var controlledExit = source[source.IndexOf("private void RequestControlledExit", StringComparison.Ordinal)..];
+        Assert.DoesNotContain("document.CloseAndDiscard", controlledExit);
+        Assert.Contains("var exitDocument = AcadApplication.DocumentManager.MdiActiveDocument;", controlledExit);
+        Assert.Contains("document = null;", controlledExit);
+    }
+
+    [Fact] public void FinalCommandCompletion_UsesItsQuiescentExitBoundary()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.Contains("Complete(true, null, safeToExitNow: true)", source);
+        Assert.Contains("RequestControlledExit(safeToExitNow);", source);
+    }
+
+    [Fact] public void TerminalEvidence_IsFlushedBeforeExitAttempt()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        var exit = source[source.IndexOf("private void DispatchNativeQuit", StringComparison.Ordinal)..];
+        Assert.True(exit.IndexOf("TryWriteEvidence(functionalCompleted, null);", StringComparison.Ordinal) < exit.IndexOf("SendStringToExecute(\"_.QUIT _N\\n", StringComparison.Ordinal));
+        Assert.Contains("EvidenceFlushed = evidenceFlushed", source);
+        Assert.Contains("CommandsCompleted", source);
+        Assert.Contains("InspectorsCompleted", source);
+    }
+
+    [Fact] public void ExitFailure_DoesNotInvalidateCompletedFunctionalEvidence()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.Contains("if (functionalCompleted)", source);
+        Assert.Contains("ExitFailureCode = exitFailureCode", source);
+        Assert.Contains("TryWriteEvidence(functionalCompleted, null);", source);
+    }
+
+    [Fact] public void ExitDispatch_DoesNotUseUnavailableDocument()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        var exit = source[source.IndexOf("private void DispatchNativeQuit", StringComparison.Ordinal)..];
+        Assert.Contains("AcadApplication.IsQuiescent", exit);
+        Assert.Contains("QuitDispatchSkippedNoLiveDocument", exit);
+        Assert.DoesNotContain("document ?? AcadApplication.DocumentManager", exit);
+    }
+
+    [Fact] public void ProductionRuntime_DoesNotEnableForceAfterEvidence()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "FirstLimitedApplyAutomation.cs"));
+        Assert.DoesNotContain("ForceAfterEvidence", source);
+        Assert.Contains("P_REC_ANNOT_AUTOMATION", source);
    }

    [Fact] public void PrimaryCommand_IsRegistered() => Assert.Contains("[CommandMethod(\"PHP_REC_ANNOT\")]", File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "EntryPoint.cs")));
@@ -104,6 +268,62 @@ public sealed class FoundationTests
        Assert.Equal(first.Operations.Select(x => x.SourceSnapshotId), second.Operations.Select(x => x.SourceSnapshotId));
    }

+    [Fact] public void AnnotationPlan_ReversedObjectOrder_HasSamePlanId()
+    {
+        var first = Build(Snapshot("a", "Pipe", "L-1"), Snapshot("b", "Pipe", "L-2"));
+        var second = Build(Snapshot("b", "Pipe", "L-2"), Snapshot("a", "Pipe", "L-1"));
+        Assert.Equal(first.PlanId, second.PlanId);
+        Assert.Equal(first.Summary, second.Summary);
+    }
+
+    [Fact] public void AnnotationPlan_AbsolutePath_DoesNotAffectPlanId()
+    {
+        var builder = new AnnotationPlanBuilder();
+        var item = Snapshot("a", "Pipe", "L-1");
+        var first = builder.Build(new AnnotationPlanningRequest { CommandName = "PHP_REC_ANNOT", Viewport = new OrthoViewportInfo { Id = "v", DisplayName = "v", SourceDrawingName = "C:\\one\\model.dwg" }, Objects = new[] { item } });
+        var second = builder.Build(new AnnotationPlanningRequest { CommandName = "PHP_REC_ANNOT", Viewport = new OrthoViewportInfo { Id = "v", DisplayName = "v", SourceDrawingName = "D:\\two\\model.dwg" }, Objects = new[] { item } });
+        Assert.Equal(first.PlanId, second.PlanId);
+    }
+
+    [Fact] public void AnnotationPlan_ChangedRelevantProperty_ChangesPlanId()
+    {
+        var first = Build(Snapshot("a", "Pipe", "L-1"));
+        var second = Build(Snapshot("a", "Pipe", "L-2"));
+        Assert.NotEqual(first.PlanId, second.PlanId);
+    }
+
+    [Fact] public void AnnotationPlan_UnresolvedMembership_IsStableSkip()
+    {
+        var plan = Build(new PlantObjectSnapshot { SnapshotId = "a", ObjectClass = "Pipe", LineNumber = "L-1", Geometry = new GeometrySnapshot(), MembershipStatus = ViewMembershipStatus.NotResolved });
+        Assert.Equal(AnnotationOperationKind.Skip, Assert.Single(plan.Operations).Kind);
+        Assert.Contains("VIEW_MEMBERSHIP_NOT_RESOLVED", plan.SkipReasons);
+    }
+
+    [Fact] public void ViewportMembership_OutsideClip_IsSkippedWithStableReason()
+    {
+        var plan = Build(new PlantObjectSnapshot { SnapshotId = "a", ObjectClass = "Pipe", LineNumber = "L-1", Geometry = new GeometrySnapshot(), MembershipStatus = ViewMembershipStatus.ObjectOutsideView });
+        Assert.Equal(AnnotationOperationKind.Skip, Assert.Single(plan.Operations).Kind);
+        Assert.Contains("VIEW_MEMBERSHIP_OBJECT_OUTSIDE_CLIP", plan.SkipReasons);
+    }
+
+    [Fact] public void AnnotationPlan_ResolvedMembership_AffectsPlanId()
+    {
+        var resolved = Build(new PlantObjectSnapshot { SnapshotId = "a", ObjectClass = "Pipe", LineNumber = "L-1", Geometry = new GeometrySnapshot(), MembershipStatus = ViewMembershipStatus.Resolved });
+        var outside = Build(new PlantObjectSnapshot { SnapshotId = "a", ObjectClass = "Pipe", LineNumber = "L-1", Geometry = new GeometrySnapshot(), MembershipStatus = ViewMembershipStatus.ObjectOutsideView });
+        Assert.NotEqual(resolved.PlanId, outside.PlanId);
+    }
+
+    [Fact] public void AnnotationPlan_ReorderedMembership_HasSamePlanId()
+    {
+        var first = Build(
+            new PlantObjectSnapshot { SnapshotId = "a", ObjectClass = "Pipe", LineNumber = "L-1", Geometry = new GeometrySnapshot(), MembershipStatus = ViewMembershipStatus.Resolved },
+            new PlantObjectSnapshot { SnapshotId = "b", ObjectClass = "Pipe", LineNumber = "L-2", Geometry = new GeometrySnapshot(), MembershipStatus = ViewMembershipStatus.ObjectOutsideView });
+        var second = Build(
+            new PlantObjectSnapshot { SnapshotId = "b", ObjectClass = "Pipe", LineNumber = "L-2", Geometry = new GeometrySnapshot(), MembershipStatus = ViewMembershipStatus.ObjectOutsideView },
+            new PlantObjectSnapshot { SnapshotId = "a", ObjectClass = "Pipe", LineNumber = "L-1", Geometry = new GeometrySnapshot(), MembershipStatus = ViewMembershipStatus.Resolved });
+        Assert.Equal(first.PlanId, second.PlanId);
+    }
+
    [Fact] public void AnnotationPlan_MissingLineNumber_IsSkipped()
    {
        var plan = Build(Snapshot("a", "Pipe", null, null));
@@ -130,8 +350,165 @@ public sealed class FoundationTests
        Assert.Equal(AnnotationOperationKind.Conflict, plan.Operations.Last().Kind);
    }

+    [Fact] public void OrthoSourceResolver_OneView_ResolvesOneModelDrawing()
+    {
+        var result = new OrthoSourceDrawingResolver().Resolve(new OrthoDrawingSnapshot
+        {
+            StableId = "sheet",
+            Views = new[] { new OrthoViewSourceSnapshot { ViewStableId = "view", ReferencedDrawingPaths = new[] { "Plant 3D Models/TestPipeModel.dwg" } } }
+        });
+        var source = Assert.Single(result);
+        Assert.Equal(SourceDrawingResolutionStatus.Resolved, source.Status);
+        Assert.Equal("TestPipeModel.dwg", source.DisplayName);
+    }
+
+    [Fact] public void OrthoSourceResolver_DuplicateViews_DeduplicatesSource()
+    {
+        var result = new OrthoSourceDrawingResolver().Resolve(new OrthoDrawingSnapshot
+        {
+            StableId = "sheet",
+            Views = new[]
+            {
+                new OrthoViewSourceSnapshot { ViewStableId = "a", ReferencedDrawingPaths = new[] { "models/A.dwg" } },
+                new OrthoViewSourceSnapshot { ViewStableId = "b", ReferencedDrawingPaths = new[] { "models/A.dwg" } }
+            }
+        });
+        Assert.Single(result);
+    }
+
+    [Fact] public void OrthoSourceResolver_MissingSource_ReturnsDiagnostic()
+    {
+        var result = new OrthoSourceDrawingResolver().Resolve(new OrthoDrawingSnapshot { StableId = "sheet" });
+        var source = Assert.Single(result);
+        Assert.Equal(SourceDrawingResolutionStatus.NotReferenced, source.Status);
+        Assert.Contains("ORTHO_SOURCE_DRAWING_NOT_RESOLVED", source.EvidenceCodes);
+    }
+
+    [Fact] public void DwgQueryContract_UsesConfirmedModelFileContract()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "PlantReadPath.cs"));
+        Assert.Contains("view.DwgQuery?.ModelFiles", source);
+        Assert.Contains("file.ModelFileName", source);
+        Assert.Contains("ORTHO_MODEL_FILES_API_UNSUPPORTED", source);
+    }
+
+    [Fact] public void DwgQueryContract_DoesNotGuessAlternativePropertyNames()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "PlantReadPath.cs"));
+        Assert.DoesNotContain("GetProperty(\"ModelFileName\")", source);
+        Assert.DoesNotContain("GetProperty(\"Value\")", source);
+        Assert.DoesNotContain("GetProperty(\"FileName\")", source);
+    }
+
+    [Fact] public void OrthoSourceReader_UsesResolvedPipingProjectDrawingId()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "PlantReadPath.cs"));
+        Assert.Contains("pipingProject.GetPnPDrawingFiles()", source);
+        Assert.Contains("dataLinks.SelectAcPpRowIds(sourceDrawing.Id)", source);
+    }
+
+    [Fact] public void OrthoSourceReader_DoesNotQueryTheActiveOrthoDatabase()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "PlantReadPath.cs"));
+        Assert.DoesNotContain("SelectAcPpRowIds(sourceDatabase)", source);
+        Assert.DoesNotContain("ReadDwgFile(viewport.SourceDrawingName", source);
+    }
+
+    [Fact] public void OrthoSourceReader_ReportsDistinctSourceDiagnostics()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "PlantReadPath.cs"));
+        Assert.Contains("ORTHO_SOURCE_DRAWING_NOT_IN_PROJECT", source);
+        Assert.Contains("SOURCE_DATALINKS_UNAVAILABLE", source);
+        Assert.Contains("SOURCE_DATALINKS_NO_ROWS", source);
+    }
+
+    [Fact] public void ViewportMembership_UsesConfirmedPnpIdentityContract()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "PlantReadPath.cs"));
+        Assert.Contains("view.DwgQuery.Execute", source);
+        Assert.Contains("sourceId.PrjObjectId", source);
+        Assert.Contains("dataLinks.FindAcPpRowId", source);
+        Assert.Contains("VIEW_MEMBERSHIP_FROM_CONFIRMED_PNP_ID", source);
+    }
+
+    [Fact] public void ViewportMembership_DoesNotSelectFirstViewport()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "PlantReadPath.cs"));
+        Assert.DoesNotContain("DwgViewDefs.AsArray().First", source);
+        Assert.Contains("candidates.Length != 1", source);
+    }
+
+    [Fact] public void RuntimeInspector_IsDisabledByDefault()
+    {
+        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "RuntimeDiagnostics.cs"));
+        Assert.Contains("P_REC_ANNOT_DIAGNOSTICS", source);
+        Assert.Contains("OrthoStructure", source);
+    }
+
    [Fact] public void ApplyMode_IsBlocked() => Assert.Throws<InvalidOperationException>(() => new ExecutionModeWriteGuard(PRecAnnotExecutionMode.Apply).EnsureWriteAllowed("test"));

+    [Fact] public void FirstLimitedApply_RequiresApplyMode()
+    {
+        var context = FirstApplyContext();
+        Assert.Throws<InvalidOperationException>(() => new FirstLimitedApplyPlanner().Prepare(PRecAnnotExecutionMode.DryRun, context.Plan, context.Viewport, context.Objects, context.Permit));
+    }
+
+    [Fact] public void FirstLimitedApply_RequiresFreshPlan()
+    {
+        var context = FirstApplyContext();
+        var permit = context.Permit with { ExpectedPlanId = "stale" };
+        Assert.Throws<InvalidOperationException>(() => new FirstLimitedApplyPlanner().Prepare(PRecAnnotExecutionMode.Apply, context.Plan, context.Viewport, context.Objects, permit));
+    }
+
+    [Fact] public void FirstLimitedApply_RequiresResolvedMembership()
+    {
+        var context = FirstApplyContext();
+        var objects = new[] { context.Objects[0] with { MembershipStatus = ViewMembershipStatus.NotResolved } };
+        Assert.Throws<InvalidOperationException>(() => new FirstLimitedApplyPlanner().Prepare(PRecAnnotExecutionMode.Apply, context.Plan, context.Viewport, objects, context.Permit));
+    }
+
+    [Fact] public void FirstLimitedApply_RequiresExactlyOneTarget()
+    {
+        var context = FirstApplyContext();
+        var permit = context.Permit with { TargetSnapshotId = "missing" };
+        Assert.Throws<InvalidOperationException>(() => new FirstLimitedApplyPlanner().Prepare(PRecAnnotExecutionMode.Apply, context.Plan, context.Viewport, context.Objects, permit));
+    }
+
+    [Fact] public void FirstLimitedApply_CreatesDeterministicOperation()
+    {
+        var context = FirstApplyContext();
+        var planner = new FirstLimitedApplyPlanner();
+        var first = planner.Prepare(PRecAnnotExecutionMode.Apply, context.Plan, context.Viewport, context.Objects, context.Permit);
+        var second = planner.Prepare(PRecAnnotExecutionMode.Apply, context.Plan, context.Viewport, context.Objects, context.Permit);
+        Assert.Equal(first.Operation.OperationId, second.Operation.OperationId);
+        Assert.Equal(first.Operation.DuplicateKey, second.Operation.DuplicateKey);
+        Assert.DoesNotContain("C:\\", first.Operation.DuplicateKey, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact] public void FirstLimitedApplyPlan_OneResolvedPipeCreatesOnePipeOperation()
+    {
+        var viewport = new OrthoViewportInfo { Id = "vp", DisplayName = "view", SourceDrawingName = "model.dwg" };
+        var plan = new AnnotationPlanBuilder().Build(new AnnotationPlanningRequest
+        {
+            CommandName = "PXP-OA", Viewport = viewport,
+            Objects = new[] { Snapshot("pipe", "Pipe", null), Snapshot("other", "Valve", "TEST") },
+            LimitedApplyTargetSnapshotId = "pipe", LimitedApplyRuleId = FirstLimitedApplyPlanner.RuleId
+        });
+        Assert.Equal(1, plan.Summary.CreateCount);
+        Assert.Equal("PIPE", Assert.Single(plan.Operations.Where(x => x.Kind == AnnotationOperationKind.Create)).AnnotationType);
+        Assert.Contains("APPLY_NOT_SELECTED_TARGET", plan.Operations.Single(x => x.SourceSnapshotId == "other").Reasons);
+    }
+
+    [Fact] public void FirstLimitedApplyPlan_SelectionChangesCanonicalPlanId()
+    {
+        var viewport = new OrthoViewportInfo { Id = "vp", DisplayName = "view", SourceDrawingName = "model.dwg" };
+        var objects = new[] { Snapshot("one", "Pipe", null), Snapshot("two", "Pipe", null) };
+        var builder = new AnnotationPlanBuilder();
+        var one = builder.Build(new AnnotationPlanningRequest { CommandName = "PXP-OA", Viewport = viewport, Objects = objects, LimitedApplyTargetSnapshotId = "one", LimitedApplyRuleId = FirstLimitedApplyPlanner.RuleId });
+        var two = builder.Build(new AnnotationPlanningRequest { CommandName = "PXP-OA", Viewport = viewport, Objects = objects, LimitedApplyTargetSnapshotId = "two", LimitedApplyRuleId = FirstLimitedApplyPlanner.RuleId });
+        Assert.NotEqual(one.PlanId, two.PlanId);
+    }
+
    [Fact] public void DryRunPath_HasNoForWriteOperations()
    {
        var source = File.ReadAllText(Path.Combine(ProjectRoot, "src", "PRecAnnot.Plant3D2026", "PlantReadPath.cs"));
@@ -141,6 +518,21 @@ public sealed class FoundationTests
        Assert.DoesNotContain("SetProperties", source);
    }

+    private static (AnnotationPlan Plan, OrthoViewportInfo Viewport, PlantObjectSnapshot[] Objects, FirstLimitedApplyPermit Permit) FirstApplyContext()
+    {
+        var viewport = new OrthoViewportInfo { Id = "vp", DisplayName = "view", SourceDrawingName = "model.dwg" };
+        var objects = new[] { Snapshot("pipe", "Pipe", "TEST") };
+        var plan = new AnnotationPlanBuilder().Build(new AnnotationPlanningRequest
+        {
+            CommandName = "PXP-OA",
+            Viewport = viewport,
+            Objects = objects,
+            LimitedApplyTargetSnapshotId = "pipe",
+            LimitedApplyRuleId = FirstLimitedApplyPlanner.RuleId
+        });
+        return (plan, viewport, objects, new FirstLimitedApplyPermit { FixtureMarker = FirstLimitedApplyPlanner.FixtureMarker, AllowApply = true, TargetSnapshotId = "pipe", ExpectedPlanId = plan.PlanId });
+    }
+
    private static AnnotationPlan Build(params PlantObjectSnapshot[] objects) => new AnnotationPlanBuilder().Build(new AnnotationPlanningRequest { CommandName = "PHP_REC_ANNOT", Viewport = new OrthoViewportInfo { Id = "vp", DisplayName = "A", SourceDrawingName = "test.dwg" }, Objects = objects });
-    private static PlantObjectSnapshot Snapshot(string id, string type, string? line, string? tag = "TAG") => new() { SnapshotId = id, ObjectClass = type, LineNumber = line, Tag = tag, Geometry = new GeometrySnapshot { PaperPosition = new Point2Dto(1, 2) } };
+    private static PlantObjectSnapshot Snapshot(string id, string type, string? line, string? tag = "TAG") => new() { SnapshotId = id, ObjectClass = type, LineNumber = line, Tag = tag, Geometry = new GeometrySnapshot { PaperPosition = new Point2Dto(1, 2) }, MembershipStatus = ViewMembershipStatus.Resolved };
 }
@@ -0,0 +1,43 @@
+using Xunit;
+
+namespace PRecAnnot.Core.Tests;
+
+public sealed class PxpOaRegistrationTests
+{
+    private static string ProjectRoot
+    {
+        get
+        {
+            var directory = new DirectoryInfo(AppContext.BaseDirectory);
+            while (directory is not null && !File.Exists(Path.Combine(directory.FullName, "PRecAnnot2026.sln"))) directory = directory.Parent;
+            return Path.Combine(directory!.FullName, "src", "PRecAnnot.Plant3D2026");
+        }
+    }
+    private static string Entry => File.ReadAllText(Path.Combine(ProjectRoot, "EntryPoint.cs"));
+    private static string Observer => File.ReadAllText(Path.Combine(ProjectRoot, "ScriptDrivenFirstApplyAutomation.cs"));
+
+    [Fact] public void PxpOaDiscovery_FindsExactlyOneDeclaration() => Assert.Single(System.Text.RegularExpressions.Regex.Matches(Entry, "\\[CommandMethod\\(\"PXP-OA\"").Cast<object>());
+    [Fact] public void PxpOaDiscovery_RecordsGlobalName() => Assert.Contains("GlobalName", Observer);
+    [Fact] public void PxpOaDiscovery_RecordsCommandGroup() => Assert.Contains("GroupName", Observer);
+    [Fact] public void PxpOaDiscovery_RecordsFlags() => Assert.Contains("Flags", Observer);
+    [Fact] public void PxpOaDiscovery_RecordsDeclaringAssembly() => Assert.Contains("owner?.Assembly", Observer);
+    [Fact] public void PxpOaDiscovery_RequiresLoadedAssembly() => Assert.Contains("PXP_OA_ASSEMBLY_NOT_LOADED", Observer);
+    [Fact] public void PxpOaDiscovery_RequiresCommandClass() => Assert.Contains("PXP_OA_COMMANDCLASS_NOT_REGISTERED", Observer);
+    [Fact] public void PxpOaDiscovery_RejectsCollision() => Assert.Contains("PXP_OA_COMMAND_COLLISION", Observer);
+    [Fact] public void PxpOaDiscovery_RejectsBundleHashMismatch() => Assert.Contains("PXP_OA_BUNDLE_HASH_MISMATCH", Observer);
+    [Fact] public void Prepare_StopsOnPxpOaDiscoveryFailure() => Assert.True(Observer.IndexOf("RequireDiscovery(discovery)", StringComparison.Ordinal) < Observer.IndexOf("PlantProject.LoadProject", StringComparison.Ordinal));
+    [Fact] public void AutomationSentinel_DoesNotModifyDatabase() => Assert.DoesNotContain("StartTransaction", Entry[Entry.IndexOf("AutomationBeforePxp1Command", StringComparison.Ordinal)..Entry.IndexOf("private static void RunDiagnostic", StringComparison.Ordinal)]);
+    [Fact] public void AutomationSentinel_IsTestOnly() => Assert.Contains("RequireGate", Observer);
+    [Fact] public void Observer_RecordsRawEventBeforeCorrelation() => Assert.True(Observer.IndexOf("commandEvents.Add", Observer.IndexOf("OnWillStart", StringComparison.Ordinal), StringComparison.Ordinal) < Observer.IndexOf("Correlate(\"WillStart\"", StringComparison.Ordinal));
+    [Fact] public void Observer_RecordsEveryRejectionReason() => Assert.Contains("DOCUMENT_IDENTITY_MISMATCH", Observer);
+    [Fact] public void Observer_DoesNotUseManagedDocumentReferenceAsAcceptance() => Assert.DoesNotContain("ReferenceEquals(sender, fixture)", Observer);
+    [Fact] public void Observer_RecordsExactlyTwoSequentialRuns() => Assert.Contains("runs.Count < 2", Observer);
+    [Fact] public void Finalize_ReportsMissingPlanSeparatelyFromMissingRuns() => Assert.True(Observer.IndexOf("AUTOMATION_EXPECTS_EXACTLY_TWO_PXP_OA", StringComparison.Ordinal) < Observer.IndexOf("AUTOMATION_PLAN_IDS_DIFFER", StringComparison.Ordinal));
+    [Fact] public void ScriptDrivenPxpOa_BindsPlantContextToCommandDocument() => Assert.Contains("ReadCurrentContext(document)", Entry);
+    [Fact] public void ScriptDrivenPxpOa_UsesPreparedFixtureContextBeforeImplicitLookup() => Assert.Contains("TryGetPreparedContext(document, out var scriptContext)", Entry);
+    [Fact] public void ScriptDrivenPrepare_SelectsCanonicalTargetAndRetainsReadOnlyContext() { Assert.Contains("preparedContext = context", Observer); Assert.Contains("selectedTargetSnapshotId = candidates[0]", Observer); }
+    [Fact] public void ScriptDrivenApply_RecordsOutcomeAgainstTheAcceptedRun() { Assert.Contains("internal static void RecordApplyOutcome", Observer); Assert.Contains("ApplyOutcome = outcome.ToString()", Observer); }
+    [Fact] public void ScriptDrivenApply_RequiresActualUndoBaselineRestoration() { Assert.Contains("AUTOMATION_UNDO_DID_NOT_RESTORE_BASELINE", Observer); Assert.Contains("Ended:UNDO", Observer); }
+    [Fact] public void PlacementReadFailure_IsDiagnosedInsteadOfBeingSilentlyDiscarded() { var source = File.ReadAllText(Path.Combine(ProjectRoot, "PlantReadPath.cs")); Assert.Contains("OrthoPipePlacementReadFailed", source); Assert.Contains("ORTHO_PIPE_PLACEMENT_UNAVAILABLE", source); }
+    [Fact] public void PlacementReader_OpensSourceDatabaseWhenItIsNotActive() { var source = File.ReadAllText(Path.Combine(ProjectRoot, "PlantReadPath.cs")); Assert.Contains("sourceId.GetDatabase(true, ref openedByQuery)", source); }
+}
@@ -0,0 +1,7 @@
+# Autodesk Launcher architecture
+
+This section is the single architecture record for the corporate Autodesk launcher, its legacy P_Rec_Annot loading path, and the parallel Launcher Next foundation. Statements are labelled `CONFIRMED`, `HIGH_CONFIDENCE`, `INFERRED`, or `UNKNOWN` and link to the audit evidence map.
+
+The AS-IS flow is a locally synchronized legacy deployment with generated AutoLISP loading. Launcher Next is a .NET 8, one-visible-EXE design that stages signed-by-hash local packages and loads one managed entry assembly. It is a design/foundation only: production configuration, AutoCAD profiles, trusted paths, network roots and deploys were not changed.
+
+See [AS-IS](as-is/system-context.md), [target](target/architecture.md), [legacy compatibility and pilot](target/legacy-compatibility.md), [ADRs](adr/ADR-001-parallel-rewrite.md), and [evidence map](evidence-map.csv).
@@ -0,0 +1,3 @@
+# ADR-001: Parallel rewrite
+
+**Decision:** build Launcher Next beside legacy. **Status:** accepted. **Why:** legacy installer performs destructive synchronization and runtime bootstrap remains partly unknown. **Consequence:** Legacy remains default and rollback is immediate.
@@ -0,0 +1,3 @@
+# ADR-002: Single managed entrypoint
+
+**Decision:** NETLOAD only `PRecAnnot.Plant3D2026.dll`. **Status:** accepted. **Why:** removes orchestration of 20 independent loads and centralizes commands/Ribbon. **Consequence:** internal dependencies must be packaged as CLR dependencies, not NETLOAD targets.
@@ -0,0 +1,3 @@
+# ADR-003: Local versioned cache
+
+**Decision:** activate immutable local versions through a pointer. **Status:** accepted. **Why:** avoids in-use DLL replacement and supports offline starts. **Consequence:** retain current/previous versions and clean staging separately.
@@ -0,0 +1,3 @@
+# ADR-004: Atomic update
+
+**Decision:** stage, validate, rename then switch pointer. **Status:** accepted. **Why:** prevents partial activation. **Consequence:** locked/cancelled updates retain current version and report diagnostics.
@@ -0,0 +1,3 @@
+# ADR-005: Legacy fallback
+
+**Decision:** mode flag defaults to Legacy; NextPilot requires explicit selection. **Status:** accepted. **Why:** startup evidence is incomplete and production configuration must not be changed implicitly. **Consequence:** launcher must not start AutoCAD twice after a Next failure.
@@ -0,0 +1,3 @@
+# ADR-006: No direct UNC assembly loading
+
+**Decision:** validate and load only local package copies. **Status:** accepted. **Why:** network availability and mid-session replacement are unreliable; direct UNC loading is not proven as a required legacy contract. **Consequence:** a local cache is mandatory for Next packages.
@@ -0,0 +1,10 @@
+# AS-IS component model
+
+`All_Serv_InstallUpdater` updates and launches `All_Serv_Install`; `All_Serv_Install` is the confirmed visible installer/synchronizer. `All_Serv_Load` is an independent historical/alternate executable. `P_Serv_Starter` is a separate bootstrap repository selected through installer configuration, not a project reference.
+
+```text
+Updater (optional) -> Visible installer -> local Applications cache -> P_Serv_Starter
+P_Serv_Starter -> generated LISP + local batch -> Plant 3D -> OrthoLoader -> module settings -> 20 DLL
+```
+
+Network access is established for installation/update. Legacy module loading is intended from local Applications, not proven to be direct UNC loading. The installed state was absent on the audited workstation.
@@ -0,0 +1,11 @@
+# AS-IS configuration contracts
+
+| Contract | Format / owner | Consumer | Validation / fallback | Versioning / machine behavior | Confidence |
+|---|---|---|---|---|---|
+| Installer Settings.xml | XML, All_Serv_Install | installer and P_Serv_Starter | parse errors stop bootstrap; detailed fallback unknown | hard-coded server/local paths and machine rules | CONFIRMED |
+| Plugin catalog/install | XML fields | generated LISP | only existing local catalog emits load | order follows configuration | CONFIRMED |
+| OrthoLoader Settings.xml | XML, P_Rec deployment | OrthoLoader | per-module behavior partially known | ordered 20 module list | CONFIRMED |
+| AutoCAD executable/version | batch/source/config | local batch | exact current version unknown | machine-specific | HIGH_CONFIDENCE |
+| Profile/autoload | workstation AutoCAD config | AutoCAD | unknown | machine-specific | UNKNOWN |
+| Ribbon resources | deployed module resources/network possible | legacy modules | absence behavior unknown | unknown | UNKNOWN |
+| Offline mode | implicit local files | launcher/user | no proven policy | network dependent at sync | UNKNOWN |
@@ -0,0 +1,12 @@
+# AS-IS failure modes
+
+| Failure | Detection | Current handling | User-visible result | Data risk | Recovery | Target handling |
+|---|---|---|---|---|---|---|
+| Network unavailable | filesystem/XML operation | incomplete evidence | install/update may fail | stale files | unknown | use valid local cache |
+| Partial copy / version skew | no proven transaction | copy/delete code | missing module | load failure | reinstall | staging + atomic pointer |
+| Missing DLL / corrupted Settings.xml | generated load or loader parse | warnings/behavior varies | command/ribbon missing | none to DWG at load | manual repair | manifest validation |
+| One of 20 modules incompatible | ._netload result | sequential continuation unknown | partial functionality | inconsistent UI | manual repair | one entry package compatibility check |
+| Repeated NETLOAD / duplicate ribbon | runtime | module-specific | duplicate UI possible | UI only | restart | idempotent registry |
+| No write permission / AV lock | file operations | errors/messages vary | launch blocked | partial install | manual repair | diagnostics and no activation |
+| AutoCAD already running / profile missing / LISP/BAT absent | not fully proven | unknown | bootstrap may not execute | none | manual | explicit duplicate policy/preflight |
+| Update during use | legacy copy model | unknown | locked or mixed files | runtime instability | manual | versioned immutable directories |
@@ -0,0 +1,13 @@
+# AS-IS file flow
+
+| File | Created/copied by | Source -> destination | Read/executed by | Generated | Required phase | Mutable | Failure impact | Target |
+|---|---|---|---|---|---|---|---|---|
+| P_Serv_Starter.exe | installer | configured local support location | installer | static | install | replaced by updater | no bootstrap | Next EXE workflow |
+| start_plant_3d.bat | external local support | expected local location | P_Serv_Starter | static | startup | external | Plant not started | ProcessStartInfo |
+| launcher_starter.lsp | P_Serv_Starter | bootstrap output -> Applications | AutoCAD (mechanism unknown) | copied | startup | overwritten | generated loader not activated | temporary Next script |
+| _app_netload.lsp | P_Serv_Starter | generated in Applications | launcher_starter | generated | startup | overwritten | no plugin load | temporary Next script |
+| app_netload.lsp | launcher_starter | renamed local generated file | AutoCAD | generated | startup | mutable | no selected plugin load | one NETLOAD script |
+| OrthoLoader.dll | installer | network catalog -> local Applications/P_Rec_Annot | AutoCAD | static | startup | versioned only by legacy copy | P_Rec chain fails | PRecAnnot entry assembly |
+| Settings.xml | legacy deployment | adjacent to loader | OrthoLoader | static | startup | network/local unknown | modules unavailable | versioned manifest |
+| P_Rec DLL / icons / help / templates / project XML | legacy catalog | network -> local catalog | modules | static | command dependent | varies | feature-specific failure | explicit optional resources |
+| AutoCAD profile references | workstation | external configuration | AutoCAD | static | startup | external | bootstrap may not run | explicit validated profile |
@@ -0,0 +1,17 @@
+# AS-IS installation sequence
+
+```mermaid
+sequenceDiagram
+ participant U as User
+ participant I as All_Serv_Install
+ participant N as Corporate network
+ participant C as Local Applications
+ participant S as P_Serv_Starter
+ U->>I: select product/plugins
+ I->>N: read Settings.xml and selected files
+ I->>C: recursively copy catalogs
+ I->>S: start with product, target, settings, project, workdir
+ S->>C: create _app_netload.lsp and launcher_starter.lsp
+```
+
+Partial-copy recovery and all offline branches are not fully proven.
@@ -0,0 +1,8 @@
+# Known unknowns
+
+- `UNKNOWN_BOOTSTRAP`: automatic `launcher_starter.lsp` activation through `acaddoc.lsp`.
+- Actual runtime files and local cache were absent on the audited workstation.
+- Exact startup mechanism for every AutoCAD/Plant release and profile.
+- Network-offline behavior across all installer/updater/module branches.
+- Full per-module failure continuation, duplicate-load handling, resources and command-time network dependencies.
+- Actual deployed updater shortcut and current Plant executable arguments.
@@ -0,0 +1,27 @@
+# AS-IS performance profile
+
+The startup path performs network-dependent synchronization when installer/update is used, writes generated LISP files, starts a batch and may load 20 assemblies sequentially. No timings were collected; claims about latency, parallelism, cache hit rate, or behavior under unavailable network are `UNKNOWN`.
+
+| Source-level observation | Evidence | Performance implication | Confidence |
+|---|---|---|---|
+| Installer recursively copies selected catalogs and can delete files/directories | `All_Serv_Install/Form1.cs` copy path | filesystem and potentially network traversal; UI blocking behavior requires measurement | CONFIRMED |
+| Updater computes MD5/control sums and replaces local files | `All_Serv_InstallUpdater/Form1.cs` | repeat hash/read/copy work; no measured count or time | CONFIRMED |
+| Bootstrap emits one generated loader command per selected installed catalog | `P_Serv_Starter/Program.cs` | sequential startup work grows with selected modules | CONFIRMED |
+| OrthoLoader sequentially `. _netload`s 20 configured modules | legacy loading audit | 20 managed loads before all functionality is ready | CONFIRMED |
+| Repeated load on document/workspace events | no complete event evidence | cannot assert | UNKNOWN |
+
+No measured count is claimed for network requests, full copies, UI waits, `Process.WaitForExit`, `Thread.Sleep`, or repeated document-level loading. Those are measurement subjects, not observed facts.
+
+## Measurement plan (proposed)
+
+| Scenario | Start | End | Proposed metrics |
+|---|---|---|---|
+| Cold start | launcher action | Ribbon ready | elapsed time, files hashed/copied, bytes, NETLOAD count |
+| Warm start | launcher action | Ribbon ready | cache hit, network requests, elapsed time |
+| Offline start | launcher action with network unavailable | Plant prepared/started | valid cache use, retry count, user status |
+| No-update start | catalog read | launch prepared | manifest comparison and file operations |
+| Update start | catalog read | activation complete | staging time, hash time, atomic switch time |
+| Rollback | rollback request | previous pointer active | elapsed time and success/failure |
+| Plugin readiness | Plant process created | Initialize and Ribbon ready | process-start, entry-load, command/Ribbon timestamps |
+
+Targets are **PROPOSED** until baseline data is collected: one entry NETLOAD, zero network assembly loads, zero in-place replacement of active package files, and no repeated full copy on a valid no-update start.
@@ -0,0 +1,3 @@
+# AS-IS security model
+
+Legacy code writes local support files and uses generated LISP plus `NETLOAD`. It relies on the corporate local trusted support convention, but this audit did not change or verify `TRUSTEDPATHS`, profiles, registry demand loading, or deployment permissions. Network source access occurs during installation/update. The audit does not establish code signing, strong validation, complete hash coverage, or secret handling. Treat all of those as gaps.
@@ -0,0 +1,24 @@
+# AS-IS startup sequence
+
+```mermaid
+sequenceDiagram
+  participant U as User
+  participant I as All_Serv_Install
+  participant S as P_Serv_Starter
+  participant B as start_plant_3d.bat
+  participant A as Plant 3D
+  participant L as launcher_starter.lsp
+  participant O as OrthoLoader.dll
+  U->>I: select Plant product/project
+  I->>S: start configured bootstrap
+  S->>S: create _app_netload.lsp; copy LISP
+  S->>B: Process.Start
+  B->>A: launch (details UNKNOWN)
+  Note over A,L: UNKNOWN_BOOTSTRAP: automatic LISP invocation not observed
+  L->>L: rename/load app_netload.lsp
+  L->>O: NETLOAD local OrthoLoader.dll
+  O->>O: read Settings.xml; ._netload ordered modules
+  O->>A: create PluginsOrtho ribbon
+```
+
+The lower sequence is conditional on `launcher_starter.lsp` being started; the initiating AutoCAD configuration is unknown.
@@ -0,0 +1,19 @@
+# AS-IS system context
+
+| Component | Owner / repository | Process / runtime | Inputs / outputs | Side effects | Replacement | Evidence / confidence |
+|---|---|---|---|---|---|---|
+| User | Engineering | desktop | selects product and project | starts launcher | retained | launcher audit / CONFIRMED |
+| All_Serv_Install | `All_Serv_Install` | .NET Framework WinForms | server Settings.xml; local Applications; starts bootstrap | synchronizes and deletes local files | Launcher Next replaces gradually | launcher audit / CONFIRMED |
+| P_Serv_Starter | `P_Serv_Starter` | .NET Framework EXE | settings + paths; generated LISP | writes loader files; starts batch | Next startup builder | source audit / CONFIRMED |
+| start_plant_3d.bat | local support directory | cmd/batch | local support files | starts Plant process | direct ProcessStartInfo when viable | source reference only / HIGH_CONFIDENCE |
+| launcher_starter.lsp | P_Serv_Starter content | AutoLISP | `_app_netload.lsp` | updates SupportPath; loads generated LISP | temporary pilot script | source audit / CONFIRMED |
+| app_netload.lsp | generated locally | AutoLISP | plugin catalog/install entries | NETLOADs selected local modules | one entry NETLOAD | source audit / CONFIRMED |
+| AutoCAD Plant 3D | Autodesk | acad.exe, Plant runtime | profile, drawing, local plugin | executes commands | retained | product discovery / CONFIRMED |
+| OrthoLoader.dll | legacy P_Rec_Annot | managed AutoCAD extension | adjacent Settings.xml | loads 20 modules, ribbon | PRecAnnot.Plant3D2026.dll | legacy audit / CONFIRMED |
+| 20 legacy DLL | legacy deployment | managed extensions | Settings.xml ordered list | commands and ribbon behavior | consolidated dependencies | legacy audit / CONFIRMED |
+| Network root | corporate file share | SMB | legacy installation source | read at install/update | catalog source only | audits / CONFIRMED |
+| Local support directory | workstation | filesystem | cache, scripts and applications | local writes | configurable cache root | source audit / CONFIRMED |
+| AutoCAD profile / autoload registration | workstation configuration | AutoCAD startup | startup LISP | unknown | explicit Next configuration | no installed proof / UNKNOWN |
+| Plant project / Ribbon | Plant runtime | Plant/AutoCAD APIs | project and UI context | commands/transactions | retained through one entry assembly | legacy audit / CONFIRMED |
+
+`UNKNOWN_BOOTSTRAP`: source comments name `acaddoc.lsp`, but its deployed content and registration were not observed. It must not be represented as confirmed automatic startup.
@@ -0,0 +1,14 @@
+# AS-IS update sequence
+
+```mermaid
+sequenceDiagram
+ participant N as Network
+ participant U as All_Serv_InstallUpdater
+ participant I as All_Serv_Install
+ U->>N: compare MD5/control-sum data
+ U->>U: delete/copy local installer files
+ U->>I: start local installer
+ Note over U,I: Actual deployed updater entrypoint is INFERRED
+```
+
+The updater source performs MD5 comparison and replacement. It was not run and its complete recovery behavior is not established.
@@ -0,0 +1,6 @@
+Claim,Evidence,Location,Confidence
+Installer is visible synchronizer,Launcher source audit,migration/audits/launcher-source-architecture/architecture-summary.md,CONFIRMED
+P_Serv_Starter generates NETLOAD LISP,Launcher source audit,migration/audits/launcher-source-architecture/launcher-to-p-rec-annot.md,CONFIRMED
+OrthoLoader reads Settings and loads 20 modules,Legacy loading audit,migration/audits/p-rec-annot-legacy-loading/loading-chain.md,CONFIRMED
+Automatic acaddoc startup,No deployed proof,architecture/autodesk-launcher/as-is/known-unknowns.md,UNKNOWN
+Target local package/atomic activation,Design decision,architecture/autodesk-launcher/adr,ACCEPTED
@@ -0,0 +1,13 @@
+# Launcher Next target architecture
+
+Launcher Next is a parallel .NET 8 foundation: one visible x64 application, immutable versioned local packages, manifest/hash validation, atomic activation, rollback pointer, explicit dry-run Plant launch preparation and structured local logs. It does not deploy, alter profiles, start AutoCAD or change legacy files in this foundation.
+
+```text
+Launcher.Next.App -> Application orchestration -> Infrastructure adapters
+  -> product discovery (registry abstraction)
+  -> package catalog / local synchronizer / versioned store
+  -> manifest validation / SHA-256
+  -> startup script builder -> Process launcher dry-run
+```
+
+For P_Rec_Annot, one local entry `PRecAnnot.Plant3D2026.dll` replaces legacy `OrthoLoader -> Settings.xml -> 20 NETLOAD` orchestration. Its internal dependencies are CLR dependencies; Autodesk assemblies remain supplied by AutoCAD.
@@ -0,0 +1,11 @@
+# Compatibility matrix
+
+| Dimension | Legacy | Next foundation | Pilot decision |
+|---|---|---|---|
+| UI | WinForms installer | WPF shell | parallel |
+| Runtime | .NET Framework 4.7 | .NET 8 x64 | separate EXE |
+| Plugin load | generated multi-NETLOAD | one local NETLOAD | validate first |
+| Package source | network copy | manifest + local cache | no production UNC client yet |
+| Offline | unknown | last valid local version | design policy |
+| Rollback | manual/unknown | previous pointer | foundation tested |
+| AutoCAD version | historical 2019 evidence | discovery for Plant 2026 | require runtime confirmation |
@@ -0,0 +1,12 @@
+# Target component model
+
+| Component | Responsibility | Boundary | Side effects |
+|---|---|---|---|
+| Launcher.Next.App | minimal WPF shell and view model | UI only | none until explicit action |
+| Core | contracts, manifest models, validation policy | no WPF/registry/process/filesystem/Autodesk | none |
+| Application | synchronize/activate/prepare workflows | ports only | none directly |
+| Infrastructure | local files, hashes, catalog implementation | filesystem/network behind interfaces | staging/cache writes |
+| Autodesk | registry discovery, script construction, ProcessStartInfo | OS/process boundary | dry-run only in foundation |
+| Observability | redacted JSONL events | local logging | log file write |
+
+Feature flag: `Legacy`, `NextPilot`, `NextPreferred`; default is `Legacy`. No production configuration changes occur without explicit authorization.
@@ -0,0 +1,36 @@
+# Legacy compatibility and pilot contract
+
+## Required user-facing behavior
+
+| Legacy behavior | Preserve in Next | Pilot status |
+|---|---|---|
+| Product/project selection workflow | preserve after separate UX analysis | not implemented |
+| Plant 3D version discovery | preserve through adapter/override | foundation adapter |
+| Local corporate plugin availability | preserve through valid local cache | designed/tested locally |
+| P_Rec commands and Ribbon | preserve through one managed entry assembly | plugin-owned, not launched here |
+| Immediate legacy return | preserve `LauncherMode=Legacy` | designed |
+| Other legacy plugins | retain existing chain until individually migrated | required |
+
+## Can be removed only for migrated P_Rec_Annot
+
+- OrthoLoader configuration fan-out and twenty sequential `NETLOAD` calls.
+- Generated LISP/BAT as the package-loading mechanism, once explicit Next startup is runtime-proven.
+- Per-file legacy copy replacing an active module directory.
+
+They remain necessary for other legacy corporate plugins until those plugins have their own migration and acceptance evidence.
+
+## Duplicated or avoidable work
+
+The source shows installer recursive copy/delete, updater hash/copy work, generated LISP generation and twenty sequential module loads. The precise overlap and cost require measurement. Next reduces avoidable work by comparing manifests, reusing a valid local version, staging only a new version and loading one entry assembly. It must not claim that legacy runs these actions on every AutoCAD startup without runtime evidence.
+
+## P_Rec_Annot pilot
+
+The pilot is a dry-run contract only:
+
+```text
+discover Plant 3D 2026 -> validate fixture manifest -> local test-source staging
+-> activate version pointer -> build one startup NETLOAD script
+-> construct ProcessStartInfo -> do not start process
+```
+
+It uses a fixture manifest with a synthetic SHA-256 and a test-created placeholder file. No real bundle, Plant assembly, package cache or production catalog is included.
@@ -0,0 +1,11 @@
+# Local cache
+
+The configurable root defaults by policy to the corporate local support root:
+
+```text
+<SupportRoot>/Launcher/{config,logs,state,staging,rollback}
+<SupportRoot>/Applications/<PackageId>/versions/<version>/
+<SupportRoot>/Applications/<PackageId>/current.json
+```
+
+Keep `current`, `previous` and incomplete `staging` separate. Activated directories are immutable; do not overwrite a DLL used by AutoCAD. A valid cache permits offline use; an invalid or partial staging directory never becomes current.
@@ -0,0 +1,9 @@
+# Migration strategy
+
+1. Preserve legacy unchanged and default `LauncherMode=Legacy`.
+2. Pilot an isolated group with `NextPilot`, local cache and one P_Rec entry assembly.
+3. Validate package/hash/rollback and dry-run launch preparation before any runtime use.
+4. Test actual bootstrap only with separate authorization and non-production Plant data.
+5. Move to `NextPreferred` only after operational evidence; retain immediate Legacy fallback.
+
+No AppLoader, registry demand-loading or direct UNC deployment decision is implied by this foundation.
@@ -0,0 +1,5 @@
+# Observability
+
+Write best-effort JSONL records under `%LOCALAPPDATA%\Promhimproekt\LauncherNext\Logs`. Events: `LauncherStarted`, `ConfigurationLoaded`, `ProductDiscoveryStarted`, `ProductDiscovered`, `CatalogReadStarted`, `CatalogReadCompleted`, `PackageValidationStarted`, `PackageValidationCompleted`, `SynchronizationStarted`, `SynchronizationCompleted`, `ActivationCompleted`, `RollbackStarted`, `RollbackCompleted`, `LaunchPrepared`, `LaunchBlocked`, `LauncherFailed`.
+
+Records exclude user identity, tokens, passwords, full Plant project paths, project numbers and engineering-file content. Logs must never block a launch decision.
@@ -0,0 +1,26 @@
+# Package manifest
+
+```json
+{
+  "schemaVersion": 1,
+  "packageId": "P_Rec_Annot",
+  "version": "2026.1.0",
+  "product": "Plant3D",
+  "productYear": 2026,
+  "architecture": "x64",
+  "minimumLauncherVersion": "1.0.0",
+  "compatibleAutoCadSeries": ["R25.1"],
+  "requiredRuntime": ".NET 8",
+  "entryAssembly": "PRecAnnot.Plant3D2026.dll",
+  "files": [{ "path": "PRecAnnot.Plant3D2026.dll", "length": 0, "sha256": "<64 hex>" }],
+  "dependencies": [],
+  "optionalResources": [],
+  "rolloutChannel": "pilot",
+  "disabled": false,
+  "rollbackSafe": true,
+  "releaseNotesReference": "relative-release-notes.md",
+  "startup": { "type": "netload", "command": "PHP_REC_ANNOT" }
+}
+```
+
+Validation rejects absolute/traversal/duplicate paths, missing entry assembly, incompatible product/year/architecture, and Autodesk/Plant managed assemblies (`AcMgd`, `AcDbMgd`, `AcCoreMgd`, `AdWindows`, `PnP*`, `Autodesk.ProcessPower*`). No absolute paths belong in a manifest.
@@ -0,0 +1,5 @@
+# Plugin bootstrap
+
+Generate a temporary, locally stored startup script only from a validated package root. It contains exactly one escaped `NETLOAD` for the entry assembly and no separate dependency loads. The script is not executed by foundation tests.
+
+`PRecAnnot.Plant3D2026.dll` is the only managed entry. `PRecAnnot.Application`, `PRecAnnot.Core` and allowed third-party libraries resolve as CLR dependencies. Autodesk managed assemblies are neither copied nor included in package manifests; they load from the installed AutoCAD/Plant runtime.
@@ -0,0 +1,9 @@
+# Target security model
+
+- Load managed assemblies only from validated local version directories, never directly from UNC.
+- Hash every packaged file with SHA-256 before activation.
+- Validate package paths against traversal and package-root escape.
+- Forbid Autodesk runtime DLLs in packages.
+- Detect Autodesk installations through a read-only registry abstraction with configuration override for diagnostics.
+- Do not change `TRUSTEDPATHS`, registry, profiles or production deployment without explicit approval.
+- Keep credentials/secrets out of source, manifests and telemetry.
@@ -0,0 +1,22 @@
+# Target startup sequence
+
+```mermaid
+sequenceDiagram
+ participant U as User
+ participant L as Launcher Next
+ participant D as Product discovery
+ participant C as Package catalog
+ participant S as Local store
+ participant A as Plant 3D
+ participant P as PRecAnnot entry
+ U->>L: Prepare launch (NextPilot)
+ L->>D: discover installed Plant 3D
+ L->>C: read package manifest when network is available
+ L->>S: stage, hash-validate, activate package atomically
+ L->>L: build one validated NETLOAD startup script
+ L->>A: ProcessStartInfo (explicit profile/script)
+ A->>P: one NETLOAD local PRecAnnot.Plant3D2026.dll
+ P->>A: commands and Ribbon registry
+```
+
+Foundation performs through `LaunchPrepared`; real process start remains dry-run only.
@@ -0,0 +1,10 @@
+# Atomic update and rollback
+
+1. Read and validate manifest.
+2. Copy/download into a new staging directory with cancellation and bounded parallelism.
+3. Validate file length, SHA-256, required files, entry metadata and forbidden DLLs.
+4. Write local manifest, close streams and rename staging to `versions/<version>`.
+5. Atomically replace `current.json`; preserve prior pointer.
+6. On bootstrap failure, offer rollback by atomically restoring the prior pointer.
+
+Never update an active directory in place. Locked files leave the current version intact and yield a diagnostic status. Network failure uses the last valid local version; when none exists, policy is to launch Plant without the corporate plugin or offer Legacy fallback, never a partial Next package.
@@ -0,0 +1,35 @@
+# Capability ledger
+
+This directory is the versioned, machine-readable register that prevents active
+2019 capabilities from silently disappearing during the Autodesk 2026 migration.
+It is product-neutral by schema: Plant 3D, Revit and Navisworks records use the
+same required fields, while product adapters remain outside the ledger.
+
+Current coverage is deliberately narrow: active, non-archive `P_Rec_Annot`
+Plant 3D command registrations. The generated ledger does not claim to be a
+complete inventory of the 2019 ecosystem. Launcher, profiles, palettes,
+resources, Revit and Navisworks must be added as independently audited slices.
+
+## Working journal — 2026-08-05
+
+1. This work makes a real 2019 capability visible, owned and decidable rather
+   than treating the first migrated command as the programme boundary.
+2. It closes the risk that active P_Rec_Annot commands disappear unnoticed.
+3. The schema is reusable for Revit and Navisworks because it describes a
+   capability and its evidence, not a Plant API.
+4. No Launcher or product domain logic is introduced.
+5. The scope statement and source pointer make missing coverage explicit.
+6. Equivalence is proven only by the record's verification method and runtime
+   evidence; `NOT REPORTED` remains explicit.
+7. Users gain an accountable migration path for every currently-audited active
+   P_Rec_Annot command, including the already verified reference vertical.
+
+## Regeneration and validation
+
+```powershell
+pwsh migration/tools/Build-CapabilityLedger.ps1
+pwsh migration/tools/Test-CapabilityLedger.ps1
+```
+
+The builder consumes audited source records only, excludes `_archive`, writes
+stable IDs, and retains unknowns instead of manufacturing a target decision.
@@ -0,0 +1,607 @@
+{
+    "schemaVersion":  1,
+    "scope":  "Plant 3D P_Rec_Annot active command slice generated from audited non-archive command registrations. This is a ledger foundation, not a claim of complete ecosystem inventory.",
+    "source":  "migration/audits/p-rec-annot-v1.0.4/evidence/commands.csv",
+    "capabilities":  [
+                         {
+                             "id":  "PLANT3D-2019-CMD-BJ",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "PHPAnnotations\\PHPBlockJig.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: BJ",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-CAC",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "PHPAnnotations\\PHPAnnotations.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: CAC",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-CAC1",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "P3DNewMa\\NewMaControl.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: CAC1",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-CREATEANNOTATIONCOMMAND",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "PHPAnnotations\\PHPAnnotations.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: CreateAnnotationCommand",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-MTO-MA",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "P3DNewMa\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: mto-ma",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-MTO-MA1",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "P3DNewMa\\NewMaControl.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: mto-ma1",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-AAV",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "AutoAnnotateView\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-AAV",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "PRecAnnot.Plant3D2026",
+                             "owner":  "Plant annotation domain owner",
+                             "migrationStatus":  "RUNTIME_VERIFIED",
+                             "verificationMethod":  "Controlled Plant 3D 2026 Preview/Apply/repeated Apply/UNDO runtime acceptance",
+                             "runtimeEvidence":  "Accepted runtime session 7402fee6290b44438642f9204e8bdb6c; automation journal 0cf74ff1c90d4c69a10417904638c7b6",
+                             "knownDifferences":  "2026 implementation uses local immutable package staging and managed entry assembly; legacy loading mechanics are not retained.",
+                             "decision":  "MIGRATED_RUNTIME_VERIFIED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-AC",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "SwapAttributesMenuItem\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-AC",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-AE",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "AutoElevation\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-AE",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-ALC",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "AutoLinenumberConnections\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-ALC",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-COV",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "CheckOrthoView\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-COV",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-DJ",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "OrthoAutoAnnotate\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-DJ",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-ELN",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "AnnotateLineNumbers\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-ELN",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-ESN",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "AnnotateLineNumbers\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-ESN",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-GIT",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "ExtentsIntersect\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-GIT",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-IE",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "InsertElevation\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-IE",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-IOD",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "UpdateOrthoDrawings\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-IOD",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-LN",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "AnnotateLineNumbers\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-LN",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-MA",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "PHPAnnotations\\PHPAnnotations.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-MA",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-OA",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "OrthoAutoAnnotate\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-OA",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "PRecAnnot.Plant3D2026",
+                             "owner":  "Plant annotation domain owner",
+                             "migrationStatus":  "RUNTIME_VERIFIED",
+                             "verificationMethod":  "Controlled Plant 3D 2026 Preview/Apply/repeated Apply/UNDO runtime acceptance",
+                             "runtimeEvidence":  "Accepted runtime session 7402fee6290b44438642f9204e8bdb6c; automation journal 0cf74ff1c90d4c69a10417904638c7b6",
+                             "knownDifferences":  "2026 implementation uses local immutable package staging and managed entry assembly; legacy loading mechanics are not retained.",
+                             "decision":  "MIGRATED_RUNTIME_VERIFIED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-OSI",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "OrthoAutoAnnotate\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-OSI",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-RA",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "OrthoAutoAnnotate\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-RA",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-RMP",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "AnnotateLineNumbers\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-RMP",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-ULN",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "AnnotateLineNumbers\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-ULN",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         },
+                         {
+                             "id":  "PLANT3D-2019-CMD-PXP-UOB",
+                             "sourceProduct":  "Autodesk Plant 3D 2019",
+                             "sourceComponent":  "UpdateOrthoViewBlocks\\Commands.cs",
+                             "userPurpose":  "Registered AutoCAD command; command body and workflow require source-specific acceptance.",
+                             "launchMethod":  "AutoCAD command: PXP-UOB",
+                             "dependencies":  [
+                                                  "Plant 3D drawing",
+                                                  "P_Rec_Annot legacy module"
+                                              ],
+                             "resources":  [
+                                               "Project configuration",
+                                               "Drawing and annotation resources"
+                                           ],
+                             "projectConstraints":  "Plant project: verify body; reads drawing: yes; writes drawing: unknown",
+                             "legacyStatus":  "ACTIVE_LEGACY",
+                             "targetComponent":  "UNASSIGNED",
+                             "owner":  "UNASSIGNED",
+                             "migrationStatus":  "MIGRATION_PLANNED",
+                             "verificationMethod":  "Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance",
+                             "runtimeEvidence":  "NOT REPORTED",
+                             "knownDifferences":  "NOT ASSESSED",
+                             "decision":  "MIGRATION_REQUIRED"
+                         }
+                     ]
+}
@@ -0,0 +1,35 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Autodesk 2019 to 2026 capability ledger",
+  "type": "object",
+  "required": ["schemaVersion", "scope", "capabilities"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "scope": { "type": "string", "minLength": 1 },
+    "capabilities": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "sourceProduct", "sourceComponent", "userPurpose", "launchMethod", "dependencies", "resources", "projectConstraints", "legacyStatus", "targetComponent", "owner", "migrationStatus", "verificationMethod", "runtimeEvidence", "knownDifferences", "decision"],
+        "properties": {
+          "id": { "type": "string", "pattern": "^[A-Z0-9-]+$" },
+          "sourceProduct": { "type": "string" },
+          "sourceComponent": { "type": "string" },
+          "userPurpose": { "type": "string" },
+          "launchMethod": { "type": "string" },
+          "dependencies": { "type": "array", "items": { "type": "string" } },
+          "resources": { "type": "array", "items": { "type": "string" } },
+          "projectConstraints": { "type": "string" },
+          "legacyStatus": { "type": "string" },
+          "targetComponent": { "type": "string" },
+          "owner": { "type": "string" },
+          "migrationStatus": { "type": "string" },
+          "verificationMethod": { "type": "string" },
+          "runtimeEvidence": { "type": "string" },
+          "knownDifferences": { "type": "string" },
+          "decision": { "type": "string" }
+        }
+      }
+    }
+  }
+}
@@ -0,0 +1,62 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $false)]
+    [string]$RepositoryRoot,
+    [Parameter(Mandatory = $false)]
+    [string]$OutputPath
+)
+
+$ErrorActionPreference = 'Stop'
+if (-not $RepositoryRoot) { $RepositoryRoot = Split-Path -Parent $PSScriptRoot }
+$RepositoryRoot = [IO.Path]::GetFullPath($RepositoryRoot)
+$commandsPath = Join-Path $RepositoryRoot 'audits\p-rec-annot-v1.0.4\evidence\commands.csv'
+if (-not (Test-Path -LiteralPath $commandsPath -PathType Leaf)) { throw "CAPABILITY_LEDGER_COMMAND_SOURCE_MISSING: $commandsPath" }
+if (-not $OutputPath) { $OutputPath = Join-Path $RepositoryRoot 'capability-ledger\plant3d-p-rec-annot-commands.json' }
+$OutputPath = [IO.Path]::GetFullPath($OutputPath)
+
+$accepted = @{
+    'PXP-AAV' = @{ Component = 'PRecAnnot.Plant3D2026'; Evidence = 'Accepted runtime session 7402fee6290b44438642f9204e8bdb6c; automation journal 0cf74ff1c90d4c69a10417904638c7b6'; Decision = 'MIGRATED_RUNTIME_VERIFIED' }
+    'PXP-OA'  = @{ Component = 'PRecAnnot.Plant3D2026'; Evidence = 'Accepted runtime session 7402fee6290b44438642f9204e8bdb6c; automation journal 0cf74ff1c90d4c69a10417904638c7b6'; Decision = 'MIGRATED_RUNTIME_VERIFIED' }
+}
+
+$commands = Import-Csv -LiteralPath $commandsPath | Where-Object { $_.File -notmatch '(^|\\)_archive(\\|$)' } |
+    Group-Object Command | ForEach-Object { $_.Group | Select-Object -First 1 } | Sort-Object Command
+
+$capabilities = foreach ($command in $commands) {
+    $acceptedRecord = $accepted[$command.Command]
+    $status = if ($acceptedRecord) { 'RUNTIME_VERIFIED' } else { 'MIGRATION_PLANNED' }
+    [ordered]@{
+        id                 = ('PLANT3D-2019-CMD-' + ($command.Command.ToUpperInvariant() -replace '[^A-Z0-9]+', '-').Trim('-'))
+        sourceProduct      = 'Autodesk Plant 3D 2019'
+        sourceComponent    = $command.File
+        userPurpose        = 'Registered AutoCAD command; command body and workflow require source-specific acceptance.'
+        launchMethod       = ('AutoCAD command: ' + $command.Command)
+        dependencies       = @('Plant 3D drawing', 'P_Rec_Annot legacy module')
+        resources          = @('Project configuration', 'Drawing and annotation resources')
+        projectConstraints = ('Plant project: ' + $command.PlantProject + '; reads drawing: ' + $command.ReadsDrawing + '; writes drawing: ' + $command.WritesDrawing)
+        legacyStatus       = 'ACTIVE_LEGACY'
+        targetComponent    = if ($acceptedRecord) { $acceptedRecord.Component } else { 'UNASSIGNED' }
+        owner              = if ($acceptedRecord) { 'Plant annotation domain owner' } else { 'UNASSIGNED' }
+        migrationStatus    = $status
+        verificationMethod = if ($acceptedRecord) { 'Controlled Plant 3D 2026 Preview/Apply/repeated Apply/UNDO runtime acceptance' } else { 'Legacy source audit, contract, deterministic Preview, controlled Apply, idempotency, UNDO and visual acceptance' }
+        runtimeEvidence    = if ($acceptedRecord) { $acceptedRecord.Evidence } else { 'NOT REPORTED' }
+        knownDifferences   = if ($acceptedRecord) { '2026 implementation uses local immutable package staging and managed entry assembly; legacy loading mechanics are not retained.' } else { 'NOT ASSESSED' }
+        decision           = if ($acceptedRecord) { $acceptedRecord.Decision } else { 'MIGRATION_REQUIRED' }
+    }
+}
+
+$ledger = [ordered]@{
+    schemaVersion = 1
+    scope = 'Plant 3D P_Rec_Annot active command slice generated from audited non-archive command registrations. This is a ledger foundation, not a claim of complete ecosystem inventory.'
+    source = 'migration/audits/p-rec-annot-v1.0.4/evidence/commands.csv'
+    capabilities = @($capabilities)
+}
+
+$parent = Split-Path -Parent $OutputPath
+New-Item -ItemType Directory -Path $parent -Force | Out-Null
+$temporary = Join-Path $parent ((Split-Path -Leaf $OutputPath) + '.tmp')
+$json = $ledger | ConvertTo-Json -Depth 8
+[IO.File]::WriteAllText($temporary, $json + [Environment]::NewLine, [Text.UTF8Encoding]::new($false))
+Move-Item -LiteralPath $temporary -Destination $OutputPath -Force
+Write-Output "CAPABILITY_LEDGER_WRITTEN=$OutputPath"
+Write-Output "CAPABILITY_COUNT=$($capabilities.Count)"
@@ -0,0 +1,23 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $false)]
+    [string]$RepositoryRoot
+)
+
+$ErrorActionPreference = 'Stop'
+if (-not $RepositoryRoot) { $RepositoryRoot = Split-Path -Parent $PSScriptRoot }
+$RepositoryRoot = [IO.Path]::GetFullPath($RepositoryRoot)
+$ledgerPath = Join-Path $RepositoryRoot 'capability-ledger\plant3d-p-rec-annot-commands.json'
+$sourcePath = Join-Path $RepositoryRoot 'audits\p-rec-annot-v1.0.4\evidence\commands.csv'
+& (Join-Path $PSScriptRoot 'Build-CapabilityLedger.ps1') -RepositoryRoot $RepositoryRoot -OutputPath $ledgerPath | Out-Null
+$ledger = Get-Content -LiteralPath $ledgerPath -Raw -Encoding utf8 | ConvertFrom-Json
+$required = 'id','sourceProduct','sourceComponent','userPurpose','launchMethod','dependencies','resources','projectConstraints','legacyStatus','targetComponent','owner','migrationStatus','verificationMethod','runtimeEvidence','knownDifferences','decision'
+$expected = (Import-Csv -LiteralPath $sourcePath | Where-Object { $_.File -notmatch '(^|\\)_archive(\\|$)' } | Select-Object -ExpandProperty Command -Unique).Count
+if ($ledger.schemaVersion -ne 1) { throw 'CAPABILITY_LEDGER_SCHEMA_VERSION_INVALID' }
+if ($ledger.capabilities.Count -ne $expected) { throw "CAPABILITY_LEDGER_COUNT_MISMATCH: expected $expected, got $($ledger.capabilities.Count)" }
+if (($ledger.capabilities.id | Select-Object -Unique).Count -ne $ledger.capabilities.Count) { throw 'CAPABILITY_LEDGER_DUPLICATE_ID' }
+foreach ($capability in $ledger.capabilities) { foreach ($field in $required) { if (-not $capability.PSObject.Properties.Name.Contains($field)) { throw "CAPABILITY_LEDGER_REQUIRED_FIELD_MISSING: $($capability.id):$field" } } }
+$accepted = @($ledger.capabilities | Where-Object { $_.decision -eq 'MIGRATED_RUNTIME_VERIFIED' })
+if ($accepted.Count -ne 2 -or ($accepted.id -notcontains 'PLANT3D-2019-CMD-PXP-AAV') -or ($accepted.id -notcontains 'PLANT3D-2019-CMD-PXP-OA')) { throw 'CAPABILITY_LEDGER_REFERENCE_VERTICAL_MISSING' }
+Write-Output "CAPABILITY_LEDGER_VALIDATED=$ledgerPath"
+Write-Output "CAPABILITY_COUNT=$($ledger.capabilities.Count)"
Author	SHA1	Message	Date
codex	060f1c9ac1	migration: add capability ledger foundation	2026-08-05 08:57:24 +03:00
codex	c3ac183fff	docs: link shared project map from agent instructions	2026-08-05 07:14:45 +03:00
codex	68f500692c	fix: verify apply duplicate and capture runtime failures	2026-08-04 16:35:42 +03:00
codex	86cabb584b	fix: import legacy Pipe annotation template	2026-08-04 14:59:51 +03:00
codex	aefd3aa487	fix: finalize script-driven limited Apply evidence	2026-08-04 14:49:54 +03:00
codex	07ab3c436f	fix: open source database for Ortho placement	2026-08-04 14:43:59 +03:00
codex	c97f02c550	fix: identify failed Ortho pipe placement boundary	2026-08-04 14:34:15 +03:00
codex	62f470c7ba	fix: retain Ortho placement failure stack trace	2026-08-04 14:32:30 +03:00
codex	2fe1ca71df	fix: diagnose unavailable Ortho pipe placement	2026-08-04 14:30:29 +03:00
codex	e707456ab6	fix: retain prepared Ortho context for script PXP-OA	2026-08-04 14:25:44 +03:00
codex	3cecee4777	fix: bind script PXP-OA planning to command document	2026-08-04 14:19:20 +03:00
codex	8a9f95a605	fix: correlate script-driven PXP-OA command events	2026-08-04 14:09:14 +03:00
codex	c270a182ce	fix: verify PXP-OA registration for script Preview	2026-08-04 12:23:36 +03:00
codex	25311e89f0	Merge remote-tracking branch 'gitea/design/autodesk-launcher-next-20260731' into migration/plant3d-2026	2026-08-04 11:24:32 +03:00
codex	f5a70df68a	Merge remote-tracking branch 'gitea/audit/launcher-source-architecture-20260731' into migration/plant3d-2026	2026-08-04 11:24:32 +03:00
codex	5725bc8737	Merge remote-tracking branch 'gitea/audit/p-rec-annot-legacy-loading-20260731' into migration/plant3d-2026	2026-08-04 11:24:32 +03:00
codex	bfd31a3747	fix: activate fixture project in script preparation	2026-08-04 10:10:49 +03:00
codex	c5cf142159	refactor: observe commands driven by AutoCAD automation script	2026-08-04 10:06:57 +03:00
codex	bc481d4378	fix: execute automation commands in AutoCAD command context	2026-08-04 09:37:24 +03:00
codex	1fa25809de	fix: queue readiness command for active fixture document	2026-08-04 09:26:43 +03:00
codex	6ed1e4086b	fix: activate fixture command queue before dispatch	2026-08-04 07:39:21 +03:00
codex	c633107273	fix: terminate automation commands through AutoCAD queue	2026-08-04 07:37:56 +03:00
codex	2d9fbdd474	fix: queue readiness barrier after fixture activation	2026-08-04 07:29:37 +03:00
codex	98564b807f	fix: wait for AutoCAD command-queue readiness barrier	2026-08-04 07:28:32 +03:00
codex	1b4ff816ba	fix: match active fixture document by stable name	2026-08-04 07:26:45 +03:00
codex	13578b7c9b	fix: recover fixture activation raised during document open	2026-08-04 07:25:53 +03:00
codex	523d063ceb	fix: preserve completed automation evidence when quit is unavailable	2026-08-04 07:22:27 +03:00
codex	31171c9ed8	test: correct lifecycle exit assertions	2026-08-03 17:24:13 +03:00
codex	edf1640c4f	fix: dispatch lifecycle exit through live document	2026-08-03 17:23:44 +03:00
codex	81a075e684	fix: exit lifecycle probe without document command queue	2026-08-03 17:21:08 +03:00
codex	32607e2f34	fix: defer Plant activation until document is quiescent	2026-08-03 17:19:01 +03:00
codex	c9c4113e86	fix: queue native quit after automation commands	2026-08-03 17:14:14 +03:00
codex	33f91c26aa	fix: close all automation-opened documents	2026-08-03 17:10:02 +03:00
codex	ef615a1f8e	fix: dispatch automation exit from final command	2026-08-03 17:07:40 +03:00
codex	e7765cbdda	fix: close live document before automation exit	2026-08-03 17:04:56 +03:00
codex	d8e61b7a5e	fix: exit lifecycle probe from verified idle	2026-08-03 17:02:18 +03:00
codex	79067b72de	fix: contain automation callback failures	2026-08-03 16:58:18 +03:00
codex	44de0cf787	fix: dispatch controlled AutoCAD exit from idle	2026-08-03 16:49:57 +03:00
codex	239796aafe	fix: arm automation on post-netload command	2026-08-03 16:43:32 +03:00
codex	8a1735408a	fix: trace gated automation bootstrap	2026-08-03 16:41:15 +03:00
codex	544b329077	fix: defer Plant automation to first post-startup idle	2026-08-03 16:34:17 +03:00
codex	1563e2fae0	feat: expose limited Apply preview candidates	2026-08-03 11:00:13 +03:00
codex	bd5f47d811	feat: implement first limited Pipe annotation Apply	2026-08-03 10:50:51 +03:00
codex	1bfb91bc4b	feat: add first limited Pipe Apply preflight	2026-08-03 10:37:37 +03:00
codex	209b8b89b8	docs: record control versus DryRun project deltas	2026-08-03 10:25:49 +03:00
codex	31787fc05a	docs: strengthen P_Rec_Annot mapping and Apply rules	2026-08-03 10:14:29 +03:00
codex	11cf97c476	docs: document legacy and Plant 3D 2026 viewport mapping APIs	2026-08-03 10:14:21 +03:00
codex	76d362d2c3	feat: resolve Ortho viewport membership from confirmed evidence	2026-08-03 10:14:11 +03:00
codex	37d3cacc13	docs: record DryRun plan determinism evidence	2026-08-03 09:18:20 +03:00
codex	713e620485	feat: add deterministic annotation plan canonicalization	2026-08-03 09:14:19 +03:00
codex	6f32371418	docs: record source-model DataLinks runtime evidence	2026-08-03 09:08:47 +03:00
codex	243080a1aa	feat: resolve Ortho source using confirmed ModelFiles metadata	2026-08-03 09:08:38 +03:00
codex	75c27ee8e5	docs: define Ortho source DataLinks contract	2026-08-03 08:32:46 +03:00
codex	c83ff3d9b3	docs: define Plant 3D 2026 migration agent contract	2026-08-03 08:32:23 +03:00
codex	09c53be7f4	fix: read Plant 3D model file references	2026-08-03 08:28:41 +03:00
codex	bdd2c9c888	fix: resolve string Ortho model references	2026-08-03 08:18:44 +03:00
codex	95dba856c8	feat: resolve Ortho views to source model drawings	2026-08-03 08:16:11 +03:00
codex	6fa3af6eda	docs: record real Ortho pipe DryRun evidence	2026-08-03 08:09:45 +03:00
codex	c616188336	fix: tolerate missing Ortho DataLinks rows in DryRun	2026-08-03 07:54:00 +03:00
codex	bb44b1b1aa	fix: resolve Plant project context diagnostics	2026-07-31 15:57:06 +03:00
codex	6e4cc74e82	docs: define Launcher Next pilot and performance plan	2026-07-31 14:34:05 +03:00
codex	1127a8376f	docs: define Autodesk launcher next architecture	2026-07-31 14:30:19 +03:00